SF: Refactor Layer::prepareClientCompositionList
Replace Layer::prepareClientCompositionList with
Layer::prepareClientComposition now that at most one layer is returned
for any call. Also changes OutputLayer::getOverrideCompositionList to
return an optional for the same reason.
Output::generateClientCompositionRequest is updated to use buffer ids
instead of strong pointers to buffers when determining whether or not
override settings are redundant. This is done to avoid duplicate checks
on whether or not overrideInfo has a non-null buffer.
Change-Id: I777f6ba8c3ca38ea31773e6fcbacb65fad287b03
Bug: b/188891810
Test: atest libcompositionengine_test
diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h
index ec610c1..f93fd99 100644
--- a/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h
+++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h
@@ -150,11 +150,11 @@
uint64_t frameNumber = 0;
};
- // Returns the z-ordered list of LayerSettings to pass to RenderEngine::drawLayers. The list
- // may contain shadows casted by the layer or the content of the layer itself. If the layer
- // does not render then an empty list will be returned.
- virtual std::vector<LayerSettings> prepareClientCompositionList(
- ClientCompositionTargetSettings&) = 0;
+ // Returns the LayerSettings to pass to RenderEngine::drawLayers. The state may contain shadows
+ // casted by the layer or the content of the layer itself. If the layer does not render then an
+ // empty optional will be returned.
+ virtual std::optional<LayerSettings> prepareClientComposition(
+ ClientCompositionTargetSettings&) const = 0;
// Called after the layer is displayed to update the presentation fence
virtual void onLayerDisplayed(ftl::SharedFuture<FenceResult>) = 0;
diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h
index bf5184e..6d0c395 100644
--- a/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h
+++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h
@@ -126,9 +126,9 @@
// Returns true if the composition settings scale pixels
virtual bool needsFiltering() const = 0;
- // Returns a composition list to be used by RenderEngine if the layer has been overridden
+ // Returns LayerSettings to be used by RenderEngine if the layer has been overridden
// during the composition process
- virtual std::vector<LayerFE::LayerSettings> getOverrideCompositionList() const = 0;
+ virtual std::optional<LayerFE::LayerSettings> getOverrideCompositionSettings() const = 0;
// Debugging
virtual void dump(std::string& result) const = 0;
diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h
index ecd432f..6d4abf9 100644
--- a/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h
+++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h
@@ -18,6 +18,7 @@
#include <cstdint>
#include <memory>
+#include <optional>
#include <string>
#include <compositionengine/LayerFE.h>
@@ -57,7 +58,7 @@
void prepareForDeviceLayerRequests() override;
void applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest request) override;
bool needsFiltering() const override;
- std::vector<LayerFE::LayerSettings> getOverrideCompositionList() const override;
+ std::optional<LayerFE::LayerSettings> getOverrideCompositionSettings() const override;
void dump(std::string&) const override;
virtual FloatRect calculateOutputSourceCrop(uint32_t internalDisplayRotationFlags) const;
diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/LayerFE.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/LayerFE.h
index 1c5c10f..2b704e6 100644
--- a/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/LayerFE.h
+++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/LayerFE.h
@@ -45,9 +45,9 @@
MOCK_METHOD1(onPreComposition, bool(nsecs_t));
MOCK_METHOD1(prepareCompositionState, void(compositionengine::LayerFE::StateSubset));
- MOCK_METHOD1(prepareClientCompositionList,
- std::vector<compositionengine::LayerFE::LayerSettings>(
- compositionengine::LayerFE::ClientCompositionTargetSettings&));
+ MOCK_CONST_METHOD1(prepareClientComposition,
+ std::optional<compositionengine::LayerFE::LayerSettings>(
+ compositionengine::LayerFE::ClientCompositionTargetSettings&));
MOCK_METHOD(void, onLayerDisplayed, (ftl::SharedFuture<FenceResult>), (override));
diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/OutputLayer.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/OutputLayer.h
index a6cb811..c22f1bf 100644
--- a/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/OutputLayer.h
+++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/mock/OutputLayer.h
@@ -16,6 +16,8 @@
#pragma once
+#include <optional>
+
#include <compositionengine/CompositionEngine.h>
#include <compositionengine/LayerFE.h>
#include <compositionengine/Output.h>
@@ -51,7 +53,7 @@
MOCK_METHOD0(prepareForDeviceLayerRequests, void());
MOCK_METHOD1(applyDeviceLayerRequest, void(Hwc2::IComposerClient::LayerRequest request));
MOCK_CONST_METHOD0(needsFiltering, bool());
- MOCK_CONST_METHOD0(getOverrideCompositionList, std::vector<LayerFE::LayerSettings>());
+ MOCK_CONST_METHOD0(getOverrideCompositionSettings, std::optional<LayerFE::LayerSettings>());
MOCK_CONST_METHOD1(dump, void(std::string&));
};
diff --git a/services/surfaceflinger/CompositionEngine/src/Output.cpp b/services/surfaceflinger/CompositionEngine/src/Output.cpp
index 8ebc5b1..6edc00f 100644
--- a/services/surfaceflinger/CompositionEngine/src/Output.cpp
+++ b/services/surfaceflinger/CompositionEngine/src/Output.cpp
@@ -1366,7 +1366,7 @@
bool firstLayer = true;
bool disableBlurs = false;
- sp<GraphicBuffer> previousOverrideBuffer = nullptr;
+ uint64_t previousOverrideBufferId = 0;
for (auto* layer : getOutputLayersOrderedByZ()) {
const auto& layerState = layer->getState();
@@ -1402,11 +1402,10 @@
!layerState.visibleRegion.subtract(layerState.shadowRegion).isEmpty();
if (clientComposition || clearClientComposition) {
- std::vector<LayerFE::LayerSettings> results;
- if (layer->getState().overrideInfo.buffer != nullptr) {
- if (layer->getState().overrideInfo.buffer->getBuffer() != previousOverrideBuffer) {
- results = layer->getOverrideCompositionList();
- previousOverrideBuffer = layer->getState().overrideInfo.buffer->getBuffer();
+ if (auto overrideSettings = layer->getOverrideCompositionSettings()) {
+ if (overrideSettings->bufferId != previousOverrideBufferId) {
+ previousOverrideBufferId = overrideSettings->bufferId;
+ clientCompositionLayers.push_back(std::move(*overrideSettings));
ALOGV("Replacing [%s] with override in RE", layer->getLayerFE().getDebugName());
} else {
ALOGV("Skipping redundant override buffer for [%s] in RE",
@@ -1432,20 +1431,18 @@
.clearContent = !clientComposition,
.blurSetting = blurSetting,
.whitePointNits = layerState.whitePointNits};
- results = layerFE.prepareClientCompositionList(targetSettings);
- if (realContentIsVisible && !results.empty()) {
- layer->editState().clientCompositionTimestamp = systemTime();
+ if (auto clientCompositionSettings =
+ layerFE.prepareClientComposition(targetSettings)) {
+ clientCompositionLayers.push_back(std::move(*clientCompositionSettings));
+ if (realContentIsVisible) {
+ layer->editState().clientCompositionTimestamp = systemTime();
+ }
}
}
if (clientComposition) {
outLayerFEs.push_back(&layerFE);
}
-
- clientCompositionLayers.insert(clientCompositionLayers.end(),
- std::make_move_iterator(results.begin()),
- std::make_move_iterator(results.end()));
- results.clear();
}
firstLayer = false;
diff --git a/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp b/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
index 1bb9d0eb..a39c527 100644
--- a/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
+++ b/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
@@ -787,7 +787,7 @@
sourceCrop.getWidth() != displayFrame.getWidth();
}
-std::vector<LayerFE::LayerSettings> OutputLayer::getOverrideCompositionList() const {
+std::optional<LayerFE::LayerSettings> OutputLayer::getOverrideCompositionSettings() const {
if (getState().overrideInfo.buffer == nullptr) {
return {};
}
@@ -816,7 +816,7 @@
settings.alpha = 1.0f;
settings.whitePointNits = getOutput().getState().sdrWhitePointNits;
- return {static_cast<LayerFE::LayerSettings>(settings)};
+ return settings;
}
void OutputLayer::dump(std::string& out) const {
diff --git a/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp b/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp
index 641b806..9058f67 100644
--- a/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp
+++ b/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp
@@ -190,11 +190,11 @@
std::vector<renderengine::LayerSettings> layerSettings;
renderengine::LayerSettings highlight;
for (const auto& layer : mLayers) {
- const auto clientCompositionList =
- layer.getState()->getOutputLayer()->getLayerFE().prepareClientCompositionList(
- targetSettings);
- layerSettings.insert(layerSettings.end(), clientCompositionList.cbegin(),
- clientCompositionList.cend());
+ if (auto clientCompositionSettings =
+ layer.getState()->getOutputLayer()->getLayerFE().prepareClientComposition(
+ targetSettings)) {
+ layerSettings.push_back(std::move(*clientCompositionSettings));
+ }
}
renderengine::LayerSettings blurLayerSettings;
@@ -202,43 +202,40 @@
auto blurSettings = targetSettings;
blurSettings.blurSetting =
LayerFE::ClientCompositionTargetSettings::BlurSetting::BackgroundBlurOnly;
- auto clientCompositionList =
- mBlurLayer->getOutputLayer()->getLayerFE().prepareClientCompositionList(
- blurSettings);
- blurLayerSettings = clientCompositionList.back();
+
+ auto blurLayerSettings =
+ mBlurLayer->getOutputLayer()->getLayerFE().prepareClientComposition(blurSettings);
// This mimics Layer::prepareClearClientComposition
- blurLayerSettings.skipContentDraw = true;
- blurLayerSettings.name = std::string("blur layer");
+ blurLayerSettings->skipContentDraw = true;
+ blurLayerSettings->name = std::string("blur layer");
// Clear out the shadow settings
- blurLayerSettings.shadow = {};
- layerSettings.push_back(blurLayerSettings);
+ blurLayerSettings->shadow = {};
+ layerSettings.push_back(std::move(*blurLayerSettings));
}
- renderengine::LayerSettings holePunchSettings;
- renderengine::LayerSettings holePunchBackgroundSettings;
if (mHolePunchLayer) {
auto& layerFE = mHolePunchLayer->getOutputLayer()->getLayerFE();
- auto clientCompositionList = layerFE.prepareClientCompositionList(targetSettings);
- // Assume that the final layer contains the buffer that we want to
- // replace with a hole punch.
- holePunchSettings = clientCompositionList.back();
+
+ auto holePunchSettings = layerFE.prepareClientComposition(targetSettings);
// This mimics Layer::prepareClearClientComposition
- holePunchSettings.source.buffer.buffer = nullptr;
- holePunchSettings.source.solidColor = half3(0.0f, 0.0f, 0.0f);
- holePunchSettings.disableBlending = true;
- holePunchSettings.alpha = 0.0f;
- holePunchSettings.name =
+ holePunchSettings->source.buffer.buffer = nullptr;
+ holePunchSettings->source.solidColor = half3(0.0f, 0.0f, 0.0f);
+ holePunchSettings->disableBlending = true;
+ holePunchSettings->alpha = 0.0f;
+ holePunchSettings->name =
android::base::StringPrintf("hole punch layer for %s", layerFE.getDebugName());
- layerSettings.push_back(holePunchSettings);
// Add a solid background as the first layer in case there is no opaque
// buffer behind the punch hole
+ renderengine::LayerSettings holePunchBackgroundSettings;
holePunchBackgroundSettings.alpha = 1.0f;
holePunchBackgroundSettings.name = std::string("holePunchBackground");
- holePunchBackgroundSettings.geometry.boundaries = holePunchSettings.geometry.boundaries;
+ holePunchBackgroundSettings.geometry.boundaries = holePunchSettings->geometry.boundaries;
holePunchBackgroundSettings.geometry.positionTransform =
- holePunchSettings.geometry.positionTransform;
- layerSettings.emplace(layerSettings.begin(), holePunchBackgroundSettings);
+ holePunchSettings->geometry.positionTransform;
+ layerSettings.emplace(layerSettings.begin(), std::move(holePunchBackgroundSettings));
+
+ layerSettings.push_back(std::move(*holePunchSettings));
}
if (sDebugHighlighLayers) {
diff --git a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
index ad0fb9d..163a11c 100644
--- a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
@@ -4308,6 +4308,8 @@
struct Layer {
Layer() {
+ EXPECT_CALL(mOutputLayer, getOverrideCompositionSettings())
+ .WillRepeatedly(Return(std::nullopt));
EXPECT_CALL(mOutputLayer, getState()).WillRepeatedly(ReturnRef(mOutputLayerState));
EXPECT_CALL(mOutputLayer, editState()).WillRepeatedly(ReturnRef(mOutputLayerState));
EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*mLayerFE));
@@ -4405,23 +4407,18 @@
}
TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, gathersClientCompositionRequests) {
- LayerFE::LayerSettings mShadowSettings;
- mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
-
- EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(_))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(_))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[1].mLayerSettings})));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>(
- {mShadowSettings, mLayers[2].mLayerSettings})));
+ EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[1].mLayerSettings)));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings)));
auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
kDisplayDataspace);
- ASSERT_EQ(3u, requests.size());
+ ASSERT_EQ(2u, requests.size());
EXPECT_EQ(mLayers[1].mLayerSettings, requests[0]);
- EXPECT_EQ(mShadowSettings, requests[1]);
- EXPECT_EQ(mLayers[2].mLayerSettings, requests[2]);
+ EXPECT_EQ(mLayers[2].mLayerSettings, requests[1]);
// Check that a timestamp was set for the layers that generated requests
EXPECT_TRUE(0 == mLayers[0].mOutputLayerState.clientCompositionTimestamp);
@@ -4438,27 +4435,21 @@
}
TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, overridesBlur) {
- LayerFE::LayerSettings mShadowSettings;
- mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
-
mLayers[2].mOutputLayerState.overrideInfo.disableBackgroundBlur = true;
- EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(_))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(_))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[1].mLayerSettings})));
+ EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[1].mLayerSettings)));
EXPECT_CALL(*mLayers[2].mLayerFE,
- prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq(
+ prepareClientComposition(ClientCompositionTargetSettingsBlurSettingsEq(
LayerFE::ClientCompositionTargetSettings::BlurSetting::BlurRegionsOnly)))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>(
- {mShadowSettings, mLayers[2].mLayerSettings})));
-
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings)));
auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
kDisplayDataspace);
- ASSERT_EQ(3u, requests.size());
+ ASSERT_EQ(2u, requests.size());
EXPECT_EQ(mLayers[1].mLayerSettings, requests[0]);
- EXPECT_EQ(mShadowSettings, requests[1]);
- EXPECT_EQ(mLayers[2].mLayerSettings, requests[2]);
+ EXPECT_EQ(mLayers[2].mLayerSettings, requests[1]);
// Check that a timestamp was set for the layers that generated requests
EXPECT_TRUE(0 == mLayers[0].mOutputLayerState.clientCompositionTimestamp);
@@ -4480,8 +4471,8 @@
mLayers[1].mLayerFEState.isOpaque = true;
mLayers[2].mLayerFEState.isOpaque = true;
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings)));
auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
kDisplayDataspace);
@@ -4503,8 +4494,8 @@
mLayers[1].mLayerFEState.isOpaque = false;
mLayers[2].mLayerFEState.isOpaque = false;
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings)));
auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
kDisplayDataspace);
@@ -4562,10 +4553,10 @@
mBlackoutSettings.alpha = 0.f;
mBlackoutSettings.disableBlending = true;
- EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mBlackoutSettings})));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));
+ EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mBlackoutSettings)));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings)));
auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
kDisplayDataspace);
@@ -4620,12 +4611,12 @@
kLayerWhitePointNits,
};
- EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
static_cast<void>(
mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
@@ -4674,12 +4665,12 @@
kLayerWhitePointNits,
};
- EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
static_cast<void>(
mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
@@ -4728,12 +4719,12 @@
kLayerWhitePointNits,
};
- EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
static_cast<void>(
mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
@@ -4781,12 +4772,12 @@
kLayerWhitePointNits,
};
- EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
static_cast<void>(
mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
@@ -4832,12 +4823,12 @@
kLayerWhitePointNits,
};
- EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>()));
static_cast<void>(mOutput.generateClientCompositionRequestsHelper(true /* supportsProtectedContent */,
kDisplayDataspace));
@@ -5018,8 +5009,8 @@
EXPECT_CALL(leftLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
EXPECT_CALL(leftLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
- EXPECT_CALL(*leftLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(leftLayerSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({leftLayer.mLayerSettings})));
+ EXPECT_CALL(*leftLayer.mLayerFE, prepareClientComposition(Eq(ByRef(leftLayerSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(leftLayer.mLayerSettings)));
compositionengine::LayerFE::ClientCompositionTargetSettings rightLayerSettings{
Region(Rect(1000, 0, 2000, 1000)),
@@ -5036,8 +5027,8 @@
EXPECT_CALL(rightLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
EXPECT_CALL(rightLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
- EXPECT_CALL(*rightLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(rightLayerSettings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({rightLayer.mLayerSettings})));
+ EXPECT_CALL(*rightLayer.mLayerFE, prepareClientComposition(Eq(ByRef(rightLayerSettings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(rightLayer.mLayerSettings)));
constexpr bool supportsProtectedContent = true;
auto requests =
@@ -5075,8 +5066,8 @@
EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mShadowSettings})));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2Settings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mShadowSettings)));
auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
kDisplayDataspace);
@@ -5093,9 +5084,6 @@
const Region kPartialContentWithPartialShadowRegion =
Region(kContentWithShadow).subtract(Rect(40, 40, 50, 80));
- LayerFE::LayerSettings mShadowSettings;
- mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
-
mLayers[2].mOutputLayerState.visibleRegion = kPartialContentWithPartialShadowRegion;
mLayers[2].mOutputLayerState.shadowRegion = kShadowRegion;
@@ -5114,16 +5102,14 @@
EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
- EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings))))
- .WillOnce(Return(std::vector<LayerFE::LayerSettings>(
- {mShadowSettings, mLayers[2].mLayerSettings})));
+ EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2Settings))))
+ .WillOnce(Return(std::optional<LayerFE::LayerSettings>(mLayers[2].mLayerSettings)));
auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
kDisplayDataspace);
- ASSERT_EQ(2u, requests.size());
+ ASSERT_EQ(1u, requests.size());
- EXPECT_EQ(mShadowSettings, requests[0]);
- EXPECT_EQ(mLayers[2].mLayerSettings, requests[1]);
+ EXPECT_EQ(mLayers[2].mLayerSettings, requests[0]);
}
} // namespace
diff --git a/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp b/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp
index 8a99e4e..cb4c4e2 100644
--- a/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp
@@ -345,13 +345,13 @@
CachedSet cachedSet(layer1);
cachedSet.append(CachedSet(layer2));
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;
- clientCompList1.push_back({});
- clientCompList1[0].alpha = 0.5f;
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp1;
+ clientComp1.emplace();
+ clientComp1->alpha = 0.5f;
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;
- clientCompList2.push_back({});
- clientCompList2[0].alpha = 0.75f;
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp2;
+ clientComp2.emplace();
+ clientComp2->alpha = 0.75f;
const auto drawLayers =
[&](const renderengine::DisplaySettings& displaySettings,
@@ -368,12 +368,10 @@
return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()});
};
- EXPECT_CALL(*layerFE1,
- prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(false)))
- .WillOnce(Return(clientCompList1));
- EXPECT_CALL(*layerFE2,
- prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(false)))
- .WillOnce(Return(clientCompList2));
+ EXPECT_CALL(*layerFE1, prepareClientComposition(ClientCompositionTargetSettingsSecureEq(false)))
+ .WillOnce(Return(clientComp1));
+ EXPECT_CALL(*layerFE2, prepareClientComposition(ClientCompositionTargetSettingsSecureEq(false)))
+ .WillOnce(Return(clientComp2));
EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _)).WillOnce(Invoke(drawLayers));
mOutputState.isSecure = false;
cachedSet.render(mRenderEngine, mTexturePool, mOutputState);
@@ -397,13 +395,13 @@
CachedSet cachedSet(layer1);
cachedSet.append(CachedSet(layer2));
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;
- clientCompList1.push_back({});
- clientCompList1[0].alpha = 0.5f;
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp1;
+ clientComp1.emplace();
+ clientComp1->alpha = 0.5f;
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;
- clientCompList2.push_back({});
- clientCompList2[0].alpha = 0.75f;
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp2;
+ clientComp2.emplace();
+ clientComp2->alpha = 0.75f;
const auto drawLayers =
[&](const renderengine::DisplaySettings& displaySettings,
@@ -421,12 +419,10 @@
return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()});
};
- EXPECT_CALL(*layerFE1,
- prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(true)))
- .WillOnce(Return(clientCompList1));
- EXPECT_CALL(*layerFE2,
- prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(true)))
- .WillOnce(Return(clientCompList2));
+ EXPECT_CALL(*layerFE1, prepareClientComposition(ClientCompositionTargetSettingsSecureEq(true)))
+ .WillOnce(Return(clientComp1));
+ EXPECT_CALL(*layerFE2, prepareClientComposition(ClientCompositionTargetSettingsSecureEq(true)))
+ .WillOnce(Return(clientComp2));
EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _)).WillOnce(Invoke(drawLayers));
mOutputState.isSecure = true;
cachedSet.render(mRenderEngine, mTexturePool, mOutputState);
@@ -450,11 +446,11 @@
CachedSet cachedSet(layer1);
cachedSet.append(CachedSet(layer2));
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;
- clientCompList1.push_back({});
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp1;
+ clientComp1.emplace();
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;
- clientCompList2.push_back({});
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp2;
+ clientComp2.emplace();
mOutputState.displayBrightnessNits = 400.f;
@@ -468,13 +464,13 @@
};
EXPECT_CALL(*layerFE1,
- prepareClientCompositionList(ClientCompositionTargetSettingsWhitePointEq(
+ prepareClientComposition(ClientCompositionTargetSettingsWhitePointEq(
mOutputState.displayBrightnessNits)))
- .WillOnce(Return(clientCompList1));
+ .WillOnce(Return(clientComp1));
EXPECT_CALL(*layerFE2,
- prepareClientCompositionList(ClientCompositionTargetSettingsWhitePointEq(
+ prepareClientComposition(ClientCompositionTargetSettingsWhitePointEq(
mOutputState.displayBrightnessNits)))
- .WillOnce(Return(clientCompList2));
+ .WillOnce(Return(clientComp2));
EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _)).WillOnce(Invoke(drawLayers));
mOutputState.isSecure = true;
cachedSet.render(mRenderEngine, mTexturePool, mOutputState);
@@ -498,13 +494,13 @@
CachedSet cachedSet(layer1);
cachedSet.append(CachedSet(layer2));
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;
- clientCompList1.push_back({});
- clientCompList1[0].alpha = 0.5f;
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp1;
+ clientComp1.emplace();
+ clientComp1->alpha = 0.5f;
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;
- clientCompList2.push_back({});
- clientCompList2[0].alpha = 0.75f;
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp2;
+ clientComp2.emplace();
+ clientComp2->alpha = 0.75f;
mOutputState.framebufferSpace = ProjectionSpace(ui::Size(10, 20), Rect(2, 3, 10, 5));
@@ -524,8 +520,8 @@
return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()});
};
- EXPECT_CALL(*layerFE1, prepareClientCompositionList(_)).WillOnce(Return(clientCompList1));
- EXPECT_CALL(*layerFE2, prepareClientCompositionList(_)).WillOnce(Return(clientCompList2));
+ EXPECT_CALL(*layerFE1, prepareClientComposition(_)).WillOnce(Return(clientComp1));
+ EXPECT_CALL(*layerFE2, prepareClientComposition(_)).WillOnce(Return(clientComp2));
EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _)).WillOnce(Invoke(drawLayers));
cachedSet.render(mRenderEngine, mTexturePool, mOutputState);
expectReadyBuffer(cachedSet);
@@ -722,22 +718,22 @@
cachedSet.addHolePunchLayerIfFeasible(layer3, true);
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;
- clientCompList1.push_back({});
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;
- clientCompList2.push_back({});
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList3;
- clientCompList3.push_back({});
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp1;
+ clientComp1.emplace();
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp2;
+ clientComp2.emplace();
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp3;
+ clientComp3.emplace();
- clientCompList3[0].source.buffer.buffer =
+ clientComp3->source.buffer.buffer =
std::make_shared<renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
1ULL /* bufferId */,
HAL_PIXEL_FORMAT_RGBA_8888,
0ULL /*usage*/);
- EXPECT_CALL(*layerFE1, prepareClientCompositionList(_)).WillOnce(Return(clientCompList1));
- EXPECT_CALL(*layerFE2, prepareClientCompositionList(_)).WillOnce(Return(clientCompList2));
- EXPECT_CALL(*layerFE3, prepareClientCompositionList(_)).WillOnce(Return(clientCompList3));
+ EXPECT_CALL(*layerFE1, prepareClientComposition(_)).WillOnce(Return(clientComp1));
+ EXPECT_CALL(*layerFE2, prepareClientComposition(_)).WillOnce(Return(clientComp2));
+ EXPECT_CALL(*layerFE3, prepareClientComposition(_)).WillOnce(Return(clientComp3));
const auto drawLayers =
[&](const renderengine::DisplaySettings&,
@@ -771,7 +767,7 @@
}
TEST_F(CachedSetTest, addHolePunch_noBuffer) {
- // Same as addHolePunch, except that clientCompList3 does not contain a
+ // Same as addHolePunch, except that clientComp3 does not contain a
// buffer. This imitates the case where the buffer had protected content, so
// BufferLayer did not add it to the LayerSettings. This should not assert.
mTestLayers[0]->outputLayerCompositionState.displayFrame = Rect(0, 0, 5, 5);
@@ -789,16 +785,16 @@
cachedSet.addHolePunchLayerIfFeasible(layer3, true);
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;
- clientCompList1.push_back({});
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;
- clientCompList2.push_back({});
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList3;
- clientCompList3.push_back({});
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp1;
+ clientComp1.emplace();
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp2;
+ clientComp2.emplace();
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp3;
+ clientComp3.emplace();
- EXPECT_CALL(*layerFE1, prepareClientCompositionList(_)).WillOnce(Return(clientCompList1));
- EXPECT_CALL(*layerFE2, prepareClientCompositionList(_)).WillOnce(Return(clientCompList2));
- EXPECT_CALL(*layerFE3, prepareClientCompositionList(_)).WillOnce(Return(clientCompList3));
+ EXPECT_CALL(*layerFE1, prepareClientComposition(_)).WillOnce(Return(clientComp1));
+ EXPECT_CALL(*layerFE2, prepareClientComposition(_)).WillOnce(Return(clientComp2));
+ EXPECT_CALL(*layerFE3, prepareClientComposition(_)).WillOnce(Return(clientComp3));
const auto drawLayers =
[&](const renderengine::DisplaySettings&,
@@ -923,34 +919,34 @@
cachedSet.addBackgroundBlurLayer(layer3);
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;
- clientCompList1.push_back({});
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;
- clientCompList2.push_back({});
- std::vector<compositionengine::LayerFE::LayerSettings> clientCompList3;
- clientCompList3.push_back({});
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp1;
+ clientComp1.emplace();
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp2;
+ clientComp2.emplace();
+ std::optional<compositionengine::LayerFE::LayerSettings> clientComp3;
+ clientComp3.emplace();
- clientCompList3[0].source.buffer.buffer =
+ clientComp3->source.buffer.buffer =
std::make_shared<renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
1ULL /* bufferId */,
HAL_PIXEL_FORMAT_RGBA_8888,
0ULL /*usage*/);
EXPECT_CALL(*layerFE1,
- prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq(
+ prepareClientComposition(ClientCompositionTargetSettingsBlurSettingsEq(
compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::
Enabled)))
- .WillOnce(Return(clientCompList1));
+ .WillOnce(Return(clientComp1));
EXPECT_CALL(*layerFE2,
- prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq(
+ prepareClientComposition(ClientCompositionTargetSettingsBlurSettingsEq(
compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::
Enabled)))
- .WillOnce(Return(clientCompList2));
+ .WillOnce(Return(clientComp2));
EXPECT_CALL(*layerFE3,
- prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq(
+ prepareClientComposition(ClientCompositionTargetSettingsBlurSettingsEq(
compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::
BackgroundBlurOnly)))
- .WillOnce(Return(clientCompList3));
+ .WillOnce(Return(clientComp3));
const auto drawLayers =
[&](const renderengine::DisplaySettings&,
diff --git a/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp b/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp
index 200278c..b624d1a 100644
--- a/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp
@@ -124,12 +124,11 @@
EXPECT_CALL(*testLayer->layerFE, getCompositionState)
.WillRepeatedly(Return(&testLayer->layerFECompositionState));
- std::vector<LayerFE::LayerSettings> clientCompositionList = {
- LayerFE::LayerSettings{},
- };
+ std::optional<LayerFE::LayerSettings> clientComposition;
+ clientComposition.emplace();
- EXPECT_CALL(*testLayer->layerFE, prepareClientCompositionList)
- .WillRepeatedly(Return(clientCompositionList));
+ EXPECT_CALL(*testLayer->layerFE, prepareClientComposition)
+ .WillRepeatedly(Return(clientComposition));
EXPECT_CALL(testLayer->outputLayer, getLayerFE)
.WillRepeatedly(ReturnRef(*testLayer->layerFE));
EXPECT_CALL(testLayer->outputLayer, getState)
@@ -638,16 +637,15 @@
EXPECT_CALL(*mTestLayers[2]->layerFE, hasRoundedCorners()).WillRepeatedly(Return(true));
- std::vector<LayerFE::LayerSettings> clientCompositionList = {
- LayerFE::LayerSettings{},
- };
- clientCompositionList[0].source.buffer.buffer = std::make_shared<
+ std::optional<LayerFE::LayerSettings> clientComposition;
+ clientComposition.emplace();
+ clientComposition->source.buffer.buffer = std::make_shared<
renderengine::impl::ExternalTexture>(mTestLayers[2]->layerFECompositionState.buffer,
mRenderEngine,
renderengine::impl::ExternalTexture::Usage::
READABLE);
- EXPECT_CALL(*mTestLayers[2]->layerFE, prepareClientCompositionList(_))
- .WillOnce(Return(clientCompositionList));
+ EXPECT_CALL(*mTestLayers[2]->layerFE, prepareClientComposition(_))
+ .WillOnce(Return(clientComposition));
const std::vector<const LayerState*> layers = {
layerState1.get(),
@@ -712,16 +710,15 @@
EXPECT_CALL(*mTestLayers[1]->layerFE, hasRoundedCorners()).WillRepeatedly(Return(true));
- std::vector<LayerFE::LayerSettings> clientCompositionList = {
- LayerFE::LayerSettings{},
- };
- clientCompositionList[0].source.buffer.buffer = std::make_shared<
+ std::optional<LayerFE::LayerSettings> clientComposition;
+ clientComposition.emplace();
+ clientComposition->source.buffer.buffer = std::make_shared<
renderengine::impl::ExternalTexture>(mTestLayers[1]->layerFECompositionState.buffer,
mRenderEngine,
renderengine::impl::ExternalTexture::Usage::
READABLE);
- EXPECT_CALL(*mTestLayers[1]->layerFE, prepareClientCompositionList(_))
- .WillOnce(Return(clientCompositionList));
+ EXPECT_CALL(*mTestLayers[1]->layerFE, prepareClientComposition(_))
+ .WillOnce(Return(clientComposition));
const std::vector<const LayerState*> layers = {
layerState0.get(),
@@ -784,16 +781,15 @@
EXPECT_CALL(*mTestLayers[1]->layerFE, hasRoundedCorners()).WillRepeatedly(Return(true));
- std::vector<LayerFE::LayerSettings> clientCompositionList = {
- LayerFE::LayerSettings{},
- };
- clientCompositionList[0].source.buffer.buffer = std::make_shared<
+ std::optional<LayerFE::LayerSettings> clientComposition;
+ clientComposition.emplace();
+ clientComposition->source.buffer.buffer = std::make_shared<
renderengine::impl::ExternalTexture>(mTestLayers[1]->layerFECompositionState.buffer,
mRenderEngine,
renderengine::impl::ExternalTexture::Usage::
READABLE);
- EXPECT_CALL(*mTestLayers[1]->layerFE, prepareClientCompositionList(_))
- .WillOnce(Return(clientCompositionList));
+ EXPECT_CALL(*mTestLayers[1]->layerFE, prepareClientComposition(_))
+ .WillOnce(Return(clientComposition));
const std::vector<const LayerState*> layers = {
layerState0.get(),