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/BufferStateLayer.cpp b/services/surfaceflinger/BufferStateLayer.cpp
index 51a5445..cce6ad7 100644
--- a/services/surfaceflinger/BufferStateLayer.cpp
+++ b/services/surfaceflinger/BufferStateLayer.cpp
@@ -1109,7 +1109,29 @@
}
std::optional<compositionengine::LayerFE::LayerSettings> BufferStateLayer::prepareClientComposition(
- compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
+ compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) const {
+ std::optional<compositionengine::LayerFE::LayerSettings> layerSettings =
+ prepareClientCompositionInternal(targetSettings);
+ // Nothing to render.
+ if (!layerSettings) {
+ return {};
+ }
+
+ // HWC requests to clear this layer.
+ if (targetSettings.clearContent) {
+ prepareClearClientComposition(*layerSettings, false /* blackout */);
+ return *layerSettings;
+ }
+
+ // set the shadow for the layer if needed
+ prepareShadowClientComposition(*layerSettings, targetSettings.viewport);
+
+ return *layerSettings;
+}
+
+std::optional<compositionengine::LayerFE::LayerSettings>
+BufferStateLayer::prepareClientCompositionInternal(
+ compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) const {
ATRACE_CALL();
std::optional<compositionengine::LayerFE::LayerSettings> result =
@@ -1559,7 +1581,7 @@
return mBufferInfo.mBuffer ? mBufferInfo.mBuffer->getBuffer() : nullptr;
}
-void BufferStateLayer::getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) {
+void BufferStateLayer::getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) const {
sp<GraphicBuffer> buffer = getBuffer();
if (!buffer) {
ALOGE("Buffer should not be null!");
diff --git a/services/surfaceflinger/BufferStateLayer.h b/services/surfaceflinger/BufferStateLayer.h
index 8bad3d2..a0f13e2 100644
--- a/services/surfaceflinger/BufferStateLayer.h
+++ b/services/surfaceflinger/BufferStateLayer.h
@@ -159,6 +159,9 @@
std::atomic<int32_t>* getPendingBufferCounter() override { return &mPendingBufferTransactions; }
std::string getPendingBufferCounterName() override { return mBlastTransactionName; }
+ std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
+ compositionengine::LayerFE::ClientCompositionTargetSettings&) const override;
+
protected:
void gatherBufferInfo();
void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame);
@@ -188,9 +191,6 @@
BufferInfo mBufferInfo;
- std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
- compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
-
/*
* compositionengine::LayerFE overrides
*/
@@ -236,7 +236,7 @@
// Computes the transform matrix using the setFilteringEnabled to determine whether the
// transform matrix should be computed for use with bilinear filtering.
- void getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]);
+ void getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) const;
std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState;
@@ -270,6 +270,9 @@
const sp<Fence>& releaseFence,
uint32_t currentMaxAcquiredBufferCount);
+ std::optional<compositionengine::LayerFE::LayerSettings> prepareClientCompositionInternal(
+ compositionengine::LayerFE::ClientCompositionTargetSettings&) const;
+
ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID;
uint64_t mPreviousReleasedFrameNumber = 0;
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(),
diff --git a/services/surfaceflinger/EffectLayer.cpp b/services/surfaceflinger/EffectLayer.cpp
index d8bbc30..d161c51 100644
--- a/services/surfaceflinger/EffectLayer.cpp
+++ b/services/surfaceflinger/EffectLayer.cpp
@@ -47,11 +47,10 @@
EffectLayer::~EffectLayer() = default;
-std::vector<compositionengine::LayerFE::LayerSettings> EffectLayer::prepareClientCompositionList(
- compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
- std::vector<compositionengine::LayerFE::LayerSettings> results;
+std::optional<compositionengine::LayerFE::LayerSettings> EffectLayer::prepareClientComposition(
+ compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) const {
std::optional<compositionengine::LayerFE::LayerSettings> layerSettings =
- prepareClientComposition(targetSettings);
+ Layer::prepareClientComposition(targetSettings);
// Nothing to render.
if (!layerSettings) {
return {};
@@ -64,13 +63,13 @@
if (targetSettings.realContentIsVisible && fillsColor()) {
// Set color for color fill settings.
layerSettings->source.solidColor = getColor().rgb;
- results.push_back(*layerSettings);
+ return layerSettings;
} else if (hasBlur() || drawShadows()) {
layerSettings->skipContentDraw = true;
- results.push_back(*layerSettings);
+ return layerSettings;
}
- return results;
+ return {};
}
bool EffectLayer::isVisible() const {
diff --git a/services/surfaceflinger/EffectLayer.h b/services/surfaceflinger/EffectLayer.h
index 1dcb633..747b0bf 100644
--- a/services/surfaceflinger/EffectLayer.h
+++ b/services/surfaceflinger/EffectLayer.h
@@ -52,8 +52,9 @@
*/
const compositionengine::LayerFECompositionState* getCompositionState() const override;
void preparePerFrameCompositionState() override;
- std::vector<compositionengine::LayerFE::LayerSettings> prepareClientCompositionList(
- compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) override;
+ std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
+ compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings)
+ const override;
std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState;
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 5e1a858..dfff8fe 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -575,7 +575,7 @@
// ---------------------------------------------------------------------------
std::optional<compositionengine::LayerFE::LayerSettings> Layer::prepareClientComposition(
- compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
+ compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) const {
if (!getCompositionState()) {
return {};
}
@@ -653,30 +653,6 @@
layerSettings.name = getName();
}
-// TODO(b/188891810): This method now only ever returns 0 or 1 layers so we should return
-// std::optional instead of a vector. Additionally, we should consider removing
-// this method entirely in favor of calling prepareClientComposition directly.
-std::vector<compositionengine::LayerFE::LayerSettings> Layer::prepareClientCompositionList(
- compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
- std::optional<compositionengine::LayerFE::LayerSettings> layerSettings =
- prepareClientComposition(targetSettings);
- // Nothing to render.
- if (!layerSettings) {
- return {};
- }
-
- // HWC requests to clear this layer.
- if (targetSettings.clearContent) {
- prepareClearClientComposition(*layerSettings, false /* blackout */);
- return {*layerSettings};
- }
-
- // set the shadow for the layer if needed
- prepareShadowClientComposition(*layerSettings, targetSettings.viewport);
-
- return {*layerSettings};
-}
-
aidl::android::hardware::graphics::composer3::Composition Layer::getCompositionType(
const DisplayDevice& display) const {
const auto outputLayer = findOutputLayerForDisplay(&display);
@@ -2006,7 +1982,7 @@
}
void Layer::prepareShadowClientComposition(LayerFE::LayerSettings& caster,
- const Rect& layerStackRect) {
+ const Rect& layerStackRect) const {
renderengine::ShadowSettings state = mFlinger->mDrawingState.globalShadowSettings;
// Note: this preserves existing behavior of shadowing the entire layer and not cropping it if
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 22bb866..6e83b23 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -618,8 +618,9 @@
const compositionengine::LayerFECompositionState* getCompositionState() const override;
bool onPreComposition(nsecs_t) override;
void prepareCompositionState(compositionengine::LayerFE::StateSubset subset) override;
- std::vector<compositionengine::LayerFE::LayerSettings> prepareClientCompositionList(
- compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
+
+ std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
+ compositionengine::LayerFE::ClientCompositionTargetSettings&) const override;
void onLayerDisplayed(ftl::SharedFuture<FenceResult>) override;
void setWasClientComposed(const sp<Fence>& fence) override {
@@ -918,8 +919,6 @@
friend class TransactionSurfaceFrameTest;
virtual void setInitialValuesForClone(const sp<Layer>& clonedFrom);
- virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
- compositionengine::LayerFE::ClientCompositionTargetSettings&);
virtual void preparePerFrameCompositionState();
virtual void commitTransaction(State& stateToCommit);
virtual void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&) {}
@@ -940,7 +939,8 @@
// Modifies the passed in layer settings to clear the contents. If the blackout flag is set,
// the settings clears the content with a solid black fill.
void prepareClearClientComposition(LayerFE::LayerSettings&, bool blackout) const;
- void prepareShadowClientComposition(LayerFE::LayerSettings& caster, const Rect& layerStackRect);
+ void prepareShadowClientComposition(LayerFE::LayerSettings& caster,
+ const Rect& layerStackRect) const;
void prepareBasicGeometryCompositionState();
void prepareGeometryCompositionState();
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index db551d7..23c0459 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -6570,27 +6570,24 @@
isHdrLayer(layer) ? displayBrightnessNits : sdrWhitePointNits,
};
- std::vector<compositionengine::LayerFE::LayerSettings> results =
- layer->prepareClientCompositionList(targetSettings);
- if (results.size() > 0) {
- for (auto& settings : results) {
- settings.geometry.positionTransform =
- transform.asMatrix4() * settings.geometry.positionTransform;
- // There's no need to process blurs when we're executing region sampling,
- // we're just trying to understand what we're drawing, and doing so without
- // blurs is already a pretty good approximation.
- if (regionSampling) {
- settings.backgroundBlurRadius = 0;
- }
- captureResults.capturedHdrLayers |= isHdrLayer(layer);
- }
-
- clientCompositionLayers.insert(clientCompositionLayers.end(),
- std::make_move_iterator(results.begin()),
- std::make_move_iterator(results.end()));
- renderedLayers.push_back(layer);
+ std::optional<compositionengine::LayerFE::LayerSettings> settings =
+ layer->prepareClientComposition(targetSettings);
+ if (!settings) {
+ return;
}
+ settings->geometry.positionTransform =
+ transform.asMatrix4() * settings->geometry.positionTransform;
+ // There's no need to process blurs when we're executing region sampling,
+ // we're just trying to understand what we're drawing, and doing so without
+ // blurs is already a pretty good approximation.
+ if (regionSampling) {
+ settings->backgroundBlurRadius = 0;
+ }
+ captureResults.capturedHdrLayers |= isHdrLayer(layer);
+
+ clientCompositionLayers.push_back(std::move(*settings));
+ renderedLayers.push_back(layer);
});
std::vector<renderengine::LayerSettings> clientRenderEngineLayers;