CE: Add test coverage for Output::generateClientCompositionRequests
Test: atest libcompositionengine_test
Bug: 144115935
Change-Id: I43c8f31e5cfee6d02dedeaec21c7d4d0ba49add5
diff --git a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
index d87389f..87beb0d 100644
--- a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
@@ -41,6 +41,7 @@
using testing::_;
using testing::ByMove;
+using testing::ByRef;
using testing::DoAll;
using testing::ElementsAreArray;
using testing::Eq;
@@ -3101,7 +3102,26 @@
}
};
+ struct Layer {
+ Layer() {
+ EXPECT_CALL(mOutputLayer, getState()).WillRepeatedly(ReturnRef(mOutputLayerState));
+ EXPECT_CALL(mOutputLayer, editState()).WillRepeatedly(ReturnRef(mOutputLayerState));
+ EXPECT_CALL(mOutputLayer, getLayer()).WillRepeatedly(ReturnRef(mLayer));
+ EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(mLayerFE));
+ EXPECT_CALL(mLayer, getFEState()).WillRepeatedly(ReturnRef(mLayerFEState));
+ }
+
+ StrictMock<mock::OutputLayer> mOutputLayer;
+ StrictMock<mock::Layer> mLayer;
+ StrictMock<mock::LayerFE> mLayerFE;
+ LayerFECompositionState mLayerFEState;
+ impl::OutputLayerCompositionState mOutputLayerState;
+ renderengine::LayerSettings mRELayerSettings;
+ };
+
GenerateClientCompositionRequestsTest() {
+ mOutput.mState.needsFiltering = false;
+
mOutput.setDisplayColorProfileForTest(
std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
@@ -3112,222 +3132,507 @@
StrictMock<OutputPartialMock> mOutput;
};
-// TODO(b/121291683): Add more unit test coverage for generateClientCompositionRequests
+struct GenerateClientCompositionRequestsTest_ThreeLayers
+ : public GenerateClientCompositionRequestsTest {
+ GenerateClientCompositionRequestsTest_ThreeLayers() {
+ mOutput.mState.frame = kDisplayFrame;
+ mOutput.mState.viewport = kDisplayViewport;
+ mOutput.mState.scissor = kDisplayScissor;
+ mOutput.mState.transform = ui::Transform{kDisplayOrientation};
+ mOutput.mState.orientation = kDisplayOrientation;
+ mOutput.mState.needsFiltering = false;
+ mOutput.mState.isSecure = false;
-TEST_F(GenerateClientCompositionRequestsTest, worksForLandscapeModeSplitScreen) {
- // In split-screen landscape mode, the screen is rotated 90 degrees, with
- // one layer on the left covering the left side of the output, and one layer
- // on the right covering that side of the output.
+ for (size_t i = 0; i < mLayers.size(); i++) {
+ mLayers[i].mOutputLayerState.clearClientTarget = false;
+ mLayers[i].mOutputLayerState.visibleRegion = Region(kDisplayFrame);
+ mLayers[i].mLayerFEState.isOpaque = true;
+ mLayers[i].mRELayerSettings.geometry.boundaries =
+ FloatRect{static_cast<float>(i + 1), 0.f, 0.f, 0.f};
+ mLayers[i].mRELayerSettings.source.solidColor = {1.0f, 1.0f, 1.0f};
+ mLayers[i].mRELayerSettings.alpha = 1.0f;
+ mLayers[i].mRELayerSettings.disableBlending = false;
- StrictMock<mock::OutputLayer> leftOutputLayer;
- StrictMock<mock::OutputLayer> rightOutputLayer;
+ EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(i))
+ .WillRepeatedly(Return(&mLayers[i].mOutputLayer));
+ EXPECT_CALL(mLayers[i].mOutputLayer, requiresClientComposition())
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(mLayers[i].mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
+ }
- StrictMock<mock::Layer> leftLayer;
- StrictMock<mock::LayerFE> leftLayerFE;
- StrictMock<mock::Layer> rightLayer;
- StrictMock<mock::LayerFE> rightLayerFE;
+ EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(mLayers.size()));
+ }
- impl::OutputLayerCompositionState leftOutputLayerState;
- leftOutputLayerState.clearClientTarget = false;
- leftOutputLayerState.visibleRegion = Region{Rect{0, 0, 1000, 1000}};
+ static constexpr uint32_t kDisplayOrientation = TR_IDENT;
+ static constexpr ui::Dataspace kDisplayDataspace = ui::Dataspace::UNKNOWN;
- LayerFECompositionState leftLayerFEState;
- leftLayerFEState.isOpaque = true;
+ static const Rect kDisplayFrame;
+ static const Rect kDisplayViewport;
+ static const Rect kDisplayScissor;
- const half3 leftLayerColor{1.f, 0.f, 0.f};
- renderengine::LayerSettings leftLayerRESettings;
- leftLayerRESettings.source.solidColor = leftLayerColor;
+ std::array<Layer, 3> mLayers;
+};
- impl::OutputLayerCompositionState rightOutputLayerState;
- rightOutputLayerState.clearClientTarget = false;
- rightOutputLayerState.visibleRegion = Region{Rect{1000, 0, 2000, 1000}};
+const Rect GenerateClientCompositionRequestsTest_ThreeLayers::kDisplayFrame(0, 0, 100, 200);
+const Rect GenerateClientCompositionRequestsTest_ThreeLayers::kDisplayViewport(0, 0, 101, 201);
+const Rect GenerateClientCompositionRequestsTest_ThreeLayers::kDisplayScissor(0, 0, 102, 202);
- LayerFECompositionState rightLayerFEState;
- rightLayerFEState.isOpaque = true;
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, handlesNoClientCompostionLayers) {
+ EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
+ EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
+ EXPECT_CALL(mLayers[2].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
- const half3 rightLayerColor{0.f, 1.f, 0.f};
- renderengine::LayerSettings rightLayerRESettings;
- rightLayerRESettings.source.solidColor = rightLayerColor;
-
- EXPECT_CALL(leftOutputLayer, getState()).WillRepeatedly(ReturnRef(leftOutputLayerState));
- EXPECT_CALL(leftOutputLayer, getLayer()).WillRepeatedly(ReturnRef(leftLayer));
- EXPECT_CALL(leftOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(leftLayerFE));
- EXPECT_CALL(leftOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
- EXPECT_CALL(leftOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
- EXPECT_CALL(leftLayer, getFEState()).WillRepeatedly(ReturnRef(leftLayerFEState));
- EXPECT_CALL(leftLayerFE, prepareClientComposition(_)).WillOnce(Return(leftLayerRESettings));
- EXPECT_CALL(leftLayerFE, prepareShadowClientComposition(_, _, _))
- .WillOnce(Return(std::optional<renderengine::LayerSettings>()));
- EXPECT_CALL(leftOutputLayer, editState()).WillRepeatedly(ReturnRef(leftOutputLayerState));
-
- EXPECT_CALL(rightOutputLayer, getState()).WillRepeatedly(ReturnRef(rightOutputLayerState));
- EXPECT_CALL(rightOutputLayer, getLayer()).WillRepeatedly(ReturnRef(rightLayer));
- EXPECT_CALL(rightOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(rightLayerFE));
- EXPECT_CALL(rightOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
- EXPECT_CALL(rightOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
- EXPECT_CALL(rightLayer, getFEState()).WillRepeatedly(ReturnRef(rightLayerFEState));
- EXPECT_CALL(rightLayerFE, prepareClientComposition(_)).WillOnce(Return(rightLayerRESettings));
- EXPECT_CALL(rightLayerFE, prepareShadowClientComposition(_, _, _))
- .WillOnce(Return(std::optional<renderengine::LayerSettings>()));
- EXPECT_CALL(rightOutputLayer, editState()).WillRepeatedly(ReturnRef(rightOutputLayerState));
-
- EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(2u));
- EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
- .WillRepeatedly(Return(&leftOutputLayer));
- EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(1u))
- .WillRepeatedly(Return(&rightOutputLayer));
-
- const Rect kPortraitFrame(0, 0, 1000, 2000);
- const Rect kPortraitViewport(0, 0, 2000, 1000);
- const Rect kPortraitScissor(0, 0, 1000, 2000);
- const uint32_t kPortraitOrientation = TR_ROT_90;
-
- mOutput.editState().frame = kPortraitFrame;
- mOutput.editState().viewport = kPortraitViewport;
- mOutput.editState().scissor = kPortraitScissor;
- mOutput.editState().transform = ui::Transform{kPortraitOrientation};
- mOutput.editState().orientation = kPortraitOrientation;
- mOutput.editState().needsFiltering = true;
- mOutput.editState().isSecure = false;
-
- constexpr bool supportsProtectedContent = false;
- Region clearRegion;
- auto requests = mOutput.generateClientCompositionRequests(supportsProtectedContent, clearRegion,
- mOutput.getState().targetDataspace);
-
- ASSERT_EQ(2u, requests.size());
- EXPECT_EQ(leftLayerColor, requests[0].source.solidColor);
- EXPECT_EQ(rightLayerColor, requests[1].source.solidColor);
-}
-
-TEST_F(GenerateClientCompositionRequestsTest, ignoresLayersThatDoNotIntersectWithViewport) {
- // Layers whose visible region does not intersect with the viewport will be
- // skipped when generating client composition request state.
-
- StrictMock<mock::OutputLayer> outputLayer;
- StrictMock<mock::Layer> layer;
- StrictMock<mock::LayerFE> layerFE;
-
- impl::OutputLayerCompositionState outputLayerState;
- outputLayerState.clearClientTarget = false;
- outputLayerState.visibleRegion = Region{Rect{3000, 0, 4000, 1000}};
-
- LayerFECompositionState layerFEState;
- layerFEState.isOpaque = true;
-
- EXPECT_CALL(outputLayer, getState()).WillRepeatedly(ReturnRef(outputLayerState));
- EXPECT_CALL(outputLayer, getLayer()).WillRepeatedly(ReturnRef(layer));
- EXPECT_CALL(outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(layerFE));
- EXPECT_CALL(outputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
- EXPECT_CALL(outputLayer, needsFiltering()).WillRepeatedly(Return(false));
- EXPECT_CALL(layer, getFEState()).WillRepeatedly(ReturnRef(layerFEState));
- EXPECT_CALL(layerFE, prepareClientComposition(_)).Times(0);
- EXPECT_CALL(outputLayer, editState()).WillRepeatedly(ReturnRef(outputLayerState));
-
- EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(1u));
- EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u)).WillRepeatedly(Return(&outputLayer));
-
- const Rect kPortraitFrame(0, 0, 1000, 2000);
- const Rect kPortraitViewport(0, 0, 2000, 1000);
- const Rect kPortraitScissor(0, 0, 1000, 2000);
- const uint32_t kPortraitOrientation = TR_ROT_90;
-
- mOutput.editState().frame = kPortraitFrame;
- mOutput.editState().viewport = kPortraitViewport;
- mOutput.editState().scissor = kPortraitScissor;
- mOutput.editState().transform = ui::Transform{kPortraitOrientation};
- mOutput.editState().orientation = kPortraitOrientation;
- mOutput.editState().needsFiltering = true;
- mOutput.editState().isSecure = false;
-
- constexpr bool supportsProtectedContent = false;
- Region clearRegion;
- auto requests = mOutput.generateClientCompositionRequests(supportsProtectedContent, clearRegion,
- mOutput.getState().targetDataspace);
-
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+ auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace);
EXPECT_EQ(0u, requests.size());
+ EXPECT_THAT(accumClearRegion, RegionEq(Region(Rect(10, 11, 12, 13))));
}
-TEST_F(GenerateClientCompositionRequestsTest, clearsDeviceLayesAfterFirst) {
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, requiresVisibleRegionAfterViewportClip) {
+ mLayers[0].mOutputLayerState.visibleRegion = Region(Rect(10, 10, 10, 10));
+ mLayers[1].mOutputLayerState.visibleRegion = Region(Rect(4000, 0, 4010, 10));
+ mLayers[2].mOutputLayerState.visibleRegion = Region(Rect(-10, -10, 0, 0));
+
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+ auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace);
+ EXPECT_EQ(0u, requests.size());
+ EXPECT_THAT(accumClearRegion, RegionEq(Region(Rect(10, 11, 12, 13))));
+}
+
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, gathersClientCompositionRequests) {
+ renderengine::LayerSettings mREShadowSettings;
+ mREShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
+
+ EXPECT_CALL(mLayers[0].mLayerFE, prepareClientComposition(_)).WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[1].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(mLayers[1].mRELayerSettings));
+ EXPECT_CALL(mLayers[1].mLayerFE,
+ prepareShadowClientComposition(mLayers[1].mRELayerSettings, kDisplayViewport,
+ kDisplayDataspace))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(mLayers[2].mRELayerSettings));
+ EXPECT_CALL(mLayers[2].mLayerFE,
+ prepareShadowClientComposition(mLayers[2].mRELayerSettings, kDisplayViewport,
+ kDisplayDataspace))
+ .WillOnce(Return(mREShadowSettings));
+
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+ auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace);
+ ASSERT_EQ(3u, requests.size());
+ EXPECT_EQ(mLayers[1].mRELayerSettings, requests[0]);
+ EXPECT_EQ(mREShadowSettings, requests[1]);
+ EXPECT_EQ(mLayers[2].mRELayerSettings, requests[2]);
+
+ EXPECT_THAT(accumClearRegion, RegionEq(Region(Rect(10, 11, 12, 13))));
+
+ // Check that a timestamp was set for the layers that generated requests
+ EXPECT_TRUE(0 == mLayers[0].mOutputLayerState.clientCompositionTimestamp);
+ EXPECT_TRUE(0 != mLayers[1].mOutputLayerState.clientCompositionTimestamp);
+ EXPECT_TRUE(0 != mLayers[2].mOutputLayerState.clientCompositionTimestamp);
+}
+
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
+ onlyClientComposesClientComposedLayersIfNoClearingNeeded) {
+ EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
+ EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
+ EXPECT_CALL(mLayers[2].mOutputLayer, requiresClientComposition()).WillOnce(Return(true));
+
+ mLayers[0].mOutputLayerState.clearClientTarget = false;
+ mLayers[1].mOutputLayerState.clearClientTarget = false;
+ mLayers[2].mOutputLayerState.clearClientTarget = false;
+
+ mLayers[0].mLayerFEState.isOpaque = true;
+ mLayers[1].mLayerFEState.isOpaque = true;
+ mLayers[2].mLayerFEState.isOpaque = true;
+
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(mLayers[2].mRELayerSettings));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareShadowClientComposition(_, _, _))
+ .WillOnce(Return(std::nullopt));
+
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+ auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace);
+ ASSERT_EQ(1u, requests.size());
+ EXPECT_EQ(mLayers[2].mRELayerSettings, requests[0]);
+
+ EXPECT_THAT(accumClearRegion, RegionEq(Region(Rect(10, 11, 12, 13))));
+}
+
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
+ onlyClientComposesClientComposedLayersIfOthersAreNotOpaque) {
+ EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
+ EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
+ EXPECT_CALL(mLayers[2].mOutputLayer, requiresClientComposition()).WillOnce(Return(true));
+
+ mLayers[0].mOutputLayerState.clearClientTarget = true;
+ mLayers[1].mOutputLayerState.clearClientTarget = true;
+ mLayers[2].mOutputLayerState.clearClientTarget = true;
+
+ mLayers[0].mLayerFEState.isOpaque = false;
+ mLayers[1].mLayerFEState.isOpaque = false;
+ mLayers[2].mLayerFEState.isOpaque = false;
+
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(mLayers[2].mRELayerSettings));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareShadowClientComposition(_, _, _))
+ .WillOnce(Return(std::nullopt));
+
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+ auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace);
+ ASSERT_EQ(1u, requests.size());
+ EXPECT_EQ(mLayers[2].mRELayerSettings, requests[0]);
+
+ EXPECT_THAT(accumClearRegion, RegionEq(Region(Rect(10, 11, 12, 13))));
+}
+
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, clearsHWCLayersIfOpaqueAndNotFirst) {
// If client composition is performed with some layers set to use device
// composition, device layers after the first layer (device or client) will
// clear the frame buffer if they are opaque and if that layer has a flag
// set to do so. The first layer is skipped as the frame buffer is already
// expected to be clear.
- StrictMock<mock::OutputLayer> leftOutputLayer;
- StrictMock<mock::OutputLayer> rightOutputLayer;
+ EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
+ EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
+ EXPECT_CALL(mLayers[2].mOutputLayer, requiresClientComposition()).WillOnce(Return(true));
- StrictMock<mock::Layer> leftLayer;
- StrictMock<mock::LayerFE> leftLayerFE;
- StrictMock<mock::Layer> rightLayer;
- StrictMock<mock::LayerFE> rightLayerFE;
+ mLayers[0].mOutputLayerState.clearClientTarget = true;
+ mLayers[1].mOutputLayerState.clearClientTarget = true;
+ mLayers[2].mOutputLayerState.clearClientTarget = true;
- impl::OutputLayerCompositionState leftOutputLayerState;
- leftOutputLayerState.clearClientTarget = true;
- leftOutputLayerState.visibleRegion = Region{Rect{0, 0, 1000, 1000}};
+ mLayers[0].mLayerFEState.isOpaque = true;
+ mLayers[1].mLayerFEState.isOpaque = true;
+ mLayers[2].mLayerFEState.isOpaque = true;
- LayerFECompositionState leftLayerFEState;
- leftLayerFEState.isOpaque = true;
+ EXPECT_CALL(mLayers[1].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(mLayers[1].mRELayerSettings));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(_))
+ .WillOnce(Return(mLayers[2].mRELayerSettings));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareShadowClientComposition(_, _, _))
+ .WillOnce(Return(std::nullopt));
- impl::OutputLayerCompositionState rightOutputLayerState;
- rightOutputLayerState.clearClientTarget = true;
- rightOutputLayerState.visibleRegion = Region{Rect{1000, 0, 2000, 1000}};
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+ auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace);
+ ASSERT_EQ(2u, requests.size());
- LayerFECompositionState rightLayerFEState;
- rightLayerFEState.isOpaque = true;
+ // The second layer is expected to be rendered as alpha=0 black with no blending
+ EXPECT_EQ(mLayers[1].mRELayerSettings.geometry.boundaries, requests[0].geometry.boundaries);
+ EXPECT_FALSE(requests[0].source.buffer.buffer);
+ EXPECT_EQ((half3{0.f, 0.f, 0.f}), requests[0].source.solidColor);
+ EXPECT_EQ(half{0.f}, requests[0].alpha);
+ EXPECT_EQ(true, requests[0].disableBlending);
- const half3 rightLayerColor{0.f, 1.f, 0.f};
- renderengine::LayerSettings rightLayerRESettings;
- rightLayerRESettings.geometry.boundaries = FloatRect{456, 0, 0, 0};
- rightLayerRESettings.source.solidColor = rightLayerColor;
+ EXPECT_EQ(mLayers[2].mRELayerSettings, requests[1]);
- EXPECT_CALL(leftOutputLayer, getState()).WillRepeatedly(ReturnRef(leftOutputLayerState));
- EXPECT_CALL(leftOutputLayer, getLayer()).WillRepeatedly(ReturnRef(leftLayer));
- EXPECT_CALL(leftOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(leftLayerFE));
- EXPECT_CALL(leftOutputLayer, requiresClientComposition()).WillRepeatedly(Return(false));
- EXPECT_CALL(leftOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
- EXPECT_CALL(leftLayer, getFEState()).WillRepeatedly(ReturnRef(leftLayerFEState));
- EXPECT_CALL(leftOutputLayer, editState()).WillRepeatedly(ReturnRef(leftOutputLayerState));
+ EXPECT_THAT(accumClearRegion, RegionEq(Region(Rect(10, 11, 12, 13))));
+}
- EXPECT_CALL(rightOutputLayer, getState()).WillRepeatedly(ReturnRef(rightOutputLayerState));
- EXPECT_CALL(rightOutputLayer, getLayer()).WillRepeatedly(ReturnRef(rightLayer));
- EXPECT_CALL(rightOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(rightLayerFE));
- EXPECT_CALL(rightOutputLayer, requiresClientComposition()).WillRepeatedly(Return(false));
- EXPECT_CALL(rightOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
- EXPECT_CALL(rightLayer, getFEState()).WillRepeatedly(ReturnRef(rightLayerFEState));
- EXPECT_CALL(rightLayerFE, prepareClientComposition(_)).WillOnce(Return(rightLayerRESettings));
- EXPECT_CALL(rightOutputLayer, editState()).WillRepeatedly(ReturnRef(rightOutputLayerState));
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
+ clippedVisibleRegionUsedToGenerateRequest) {
+ mLayers[0].mOutputLayerState.visibleRegion = Region(Rect(10, 10, 20, 20));
+ mLayers[1].mOutputLayerState.visibleRegion = Region(Rect(-10, -10, 30, 30));
+ mLayers[2].mOutputLayerState.visibleRegion = Region(Rect(-10, 0, 40, 4000));
- EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(2u));
- EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
- .WillRepeatedly(Return(&leftOutputLayer));
- EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(1u))
- .WillRepeatedly(Return(&rightOutputLayer));
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
+ Region(Rect(10, 10, 20, 20)),
+ false, /* identity transform */
+ false, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
+ Region(Rect(0, 0, 30, 30)),
+ false, /* identity transform */
+ false, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
+ Region(Rect(0, 0, 40, 201)),
+ false, /* identity transform */
+ false, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+
+ EXPECT_CALL(mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+
+ static_cast<void>(
+ mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace));
+}
+
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
+ perLayerNeedsFilteringUsedToGenerateRequests) {
+ mOutput.mState.needsFiltering = false;
+ EXPECT_CALL(mLayers[0].mOutputLayer, needsFiltering()).WillRepeatedly(Return(true));
+
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ true, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ false, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ false, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+
+ EXPECT_CALL(mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+
+ static_cast<void>(
+ mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace));
+}
+
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
+ wholeOutputNeedsFilteringUsedToGenerateRequests) {
+ mOutput.mState.needsFiltering = true;
+ EXPECT_CALL(mLayers[0].mOutputLayer, needsFiltering()).WillRepeatedly(Return(true));
+
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ true, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ true, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ true, /* needs filtering */
+ false, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+
+ EXPECT_CALL(mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+
+ static_cast<void>(
+ mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace));
+}
+
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
+ wholeOutputSecurityUsedToGenerateRequests) {
+ mOutput.mState.isSecure = true;
+
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ false, /* needs filtering */
+ true, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ false, /* needs filtering */
+ true, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ false, /* needs filtering */
+ true, /* secure */
+ false, /* supports protected content */
+ accumClearRegion,
+ };
+
+ EXPECT_CALL(mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+
+ static_cast<void>(
+ mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
+ accumClearRegion, kDisplayDataspace));
+}
+
+TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
+ protectedContentSupportUsedToGenerateRequests) {
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ false, /* needs filtering */
+ false, /* secure */
+ true, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ false, /* needs filtering */
+ false, /* secure */
+ true, /* supports protected content */
+ accumClearRegion,
+ };
+ compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
+ Region(kDisplayFrame),
+ false, /* identity transform */
+ false, /* needs filtering */
+ false, /* secure */
+ true, /* supports protected content */
+ accumClearRegion,
+ };
+
+ EXPECT_CALL(mLayers[0].mLayerFE, prepareClientComposition(Eq(ByRef(layer0TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[1].mLayerFE, prepareClientComposition(Eq(ByRef(layer1TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+ EXPECT_CALL(mLayers[2].mLayerFE, prepareClientComposition(Eq(ByRef(layer2TargetSettings))))
+ .WillOnce(Return(std::nullopt));
+
+ static_cast<void>(mOutput.generateClientCompositionRequests(true /* supportsProtectedContent */,
+ accumClearRegion,
+ kDisplayDataspace));
+}
+
+TEST_F(GenerateClientCompositionRequestsTest, handlesLandscapeModeSplitScreenRequests) {
+ // In split-screen landscape mode, the screen is rotated 90 degrees, with
+ // one layer on the left covering the left side of the output, and one layer
+ // on the right covering that side of the output.
const Rect kPortraitFrame(0, 0, 1000, 2000);
const Rect kPortraitViewport(0, 0, 2000, 1000);
const Rect kPortraitScissor(0, 0, 1000, 2000);
const uint32_t kPortraitOrientation = TR_ROT_90;
+ constexpr ui::Dataspace kOutputDataspace = ui::Dataspace::DISPLAY_P3;
- mOutput.editState().frame = kPortraitFrame;
- mOutput.editState().viewport = kPortraitViewport;
- mOutput.editState().scissor = kPortraitScissor;
- mOutput.editState().transform = ui::Transform{kPortraitOrientation};
- mOutput.editState().orientation = kPortraitOrientation;
- mOutput.editState().needsFiltering = true;
- mOutput.editState().isSecure = false;
+ mOutput.mState.frame = kPortraitFrame;
+ mOutput.mState.viewport = kPortraitViewport;
+ mOutput.mState.scissor = kPortraitScissor;
+ mOutput.mState.transform = ui::Transform{kPortraitOrientation};
+ mOutput.mState.orientation = kPortraitOrientation;
+ mOutput.mState.needsFiltering = false;
+ mOutput.mState.isSecure = true;
- constexpr bool supportsProtectedContent = false;
- Region clearRegion;
- auto requests = mOutput.generateClientCompositionRequests(supportsProtectedContent, clearRegion,
- mOutput.getState().targetDataspace);
+ Layer leftLayer;
+ Layer rightLayer;
- const half3 clearColor{0.f, 0.f, 0.f};
+ leftLayer.mOutputLayerState.clearClientTarget = false;
+ leftLayer.mOutputLayerState.visibleRegion = Region(Rect(0, 0, 1000, 1000));
+ leftLayer.mLayerFEState.isOpaque = true;
+ leftLayer.mRELayerSettings.source.solidColor = {1.f, 0.f, 0.f};
- ASSERT_EQ(1u, requests.size());
- EXPECT_EQ(456.f, requests[0].geometry.boundaries.left);
- EXPECT_EQ(clearColor, requests[0].source.solidColor);
+ rightLayer.mOutputLayerState.clearClientTarget = false;
+ rightLayer.mOutputLayerState.visibleRegion = Region(Rect(1000, 0, 2000, 1000));
+ rightLayer.mLayerFEState.isOpaque = true;
+ rightLayer.mRELayerSettings.source.solidColor = {0.f, 1.f, 0.f};
+
+ EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(2u));
+ EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
+ .WillRepeatedly(Return(&leftLayer.mOutputLayer));
+ EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(1u))
+ .WillRepeatedly(Return(&rightLayer.mOutputLayer));
+
+ Region accumClearRegion(Rect(10, 11, 12, 13));
+
+ compositionengine::LayerFE::ClientCompositionTargetSettings leftLayerSettings{
+ Region(Rect(0, 0, 1000, 1000)),
+ false, /* identity transform */
+ false, /* needs filtering */
+ true, /* secure */
+ true, /* supports protected content */
+ accumClearRegion,
+ };
+
+ EXPECT_CALL(leftLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
+ EXPECT_CALL(leftLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
+ EXPECT_CALL(leftLayer.mLayerFE, prepareClientComposition(Eq(ByRef(leftLayerSettings))))
+ .WillOnce(Return(leftLayer.mRELayerSettings));
+ EXPECT_CALL(leftLayer.mLayerFE,
+ prepareShadowClientComposition(leftLayer.mRELayerSettings, kPortraitViewport,
+ kOutputDataspace))
+ .WillOnce(Return(std::nullopt));
+
+ compositionengine::LayerFE::ClientCompositionTargetSettings rightLayerSettings{
+ Region(Rect(1000, 0, 2000, 1000)),
+ false, /* identity transform */
+ false, /* needs filtering */
+ true, /* secure */
+ true, /* supports protected content */
+ accumClearRegion,
+ };
+
+ EXPECT_CALL(rightLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
+ EXPECT_CALL(rightLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
+ EXPECT_CALL(rightLayer.mLayerFE, prepareClientComposition(Eq(ByRef(rightLayerSettings))))
+ .WillOnce(Return(rightLayer.mRELayerSettings));
+ EXPECT_CALL(rightLayer.mLayerFE,
+ prepareShadowClientComposition(rightLayer.mRELayerSettings, kPortraitViewport,
+ kOutputDataspace))
+ .WillOnce(Return(std::nullopt));
+
+ constexpr bool supportsProtectedContent = true;
+ auto requests = mOutput.generateClientCompositionRequests(supportsProtectedContent,
+ accumClearRegion, kOutputDataspace);
+ ASSERT_EQ(2u, requests.size());
+ EXPECT_EQ(leftLayer.mRELayerSettings, requests[0]);
+ EXPECT_EQ(rightLayer.mRELayerSettings, requests[1]);
}
} // namespace