Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e804a548 authored by Ady Abraham's avatar Ady Abraham Committed by Android (Google) Code Review
Browse files

Merge "Fix memory leaks in libcompositionengine_test" into sc-dev

parents 1703644b eca9d75c

services/surfaceflinger/CompositionEngine/tests/CompositionEngineTest.cpp

+12 −12
Original line number Original line Diff line number Diff line
@@ -39,9 +39,6 @@ using ::testing::SaveArg; 
using ::testing::StrictMock;

using ::testing::StrictMock;





struct CompositionEngineTest : public testing::Test {

struct CompositionEngineTest : public testing::Test {

    android::mock::HWComposer* mHwc = new StrictMock<android::mock::HWComposer>();

    renderengine::mock::RenderEngine* mRenderEngine =

            new StrictMock<renderengine::mock::RenderEngine>();

    std::shared_ptr<TimeStats> mTimeStats;

    std::shared_ptr<TimeStats> mTimeStats;





    impl::CompositionEngine mEngine;

    impl::CompositionEngine mEngine;
@@ -58,15 +55,18 @@ TEST_F(CompositionEngineTest, canInstantiateCompositionEngine) { 
}

}





TEST_F(CompositionEngineTest, canSetHWComposer) {

TEST_F(CompositionEngineTest, canSetHWComposer) {

    mEngine.setHwComposer(std::unique_ptr<android::HWComposer>(mHwc));

    android::mock::HWComposer* hwc = new StrictMock<android::mock::HWComposer>();

    mEngine.setHwComposer(std::unique_ptr<android::HWComposer>(hwc));





    EXPECT_EQ(mHwc, &mEngine.getHwComposer());

    EXPECT_EQ(hwc, &mEngine.getHwComposer());

}

}





TEST_F(CompositionEngineTest, canSetRenderEngine) {

TEST_F(CompositionEngineTest, canSetRenderEngine) {

    mEngine.setRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));

    renderengine::mock::RenderEngine* renderEngine =

            new StrictMock<renderengine::mock::RenderEngine>();

    mEngine.setRenderEngine(std::unique_ptr<renderengine::RenderEngine>(renderEngine));





    EXPECT_EQ(mRenderEngine, &mEngine.getRenderEngine());

    EXPECT_EQ(renderEngine, &mEngine.getRenderEngine());

}

}





TEST_F(CompositionEngineTest, canSetTimeStats) {

TEST_F(CompositionEngineTest, canSetTimeStats) {
@@ -130,10 +130,10 @@ TEST_F(CompositionEnginePresentTest, worksAsExpected) { 
struct CompositionEngineUpdateCursorAsyncTest : public CompositionEngineTest {

struct CompositionEngineUpdateCursorAsyncTest : public CompositionEngineTest {

public:

public:

    struct Layer {

    struct Layer {

        Layer() { EXPECT_CALL(outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(layerFE)); }

        Layer() { EXPECT_CALL(outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE)); }





        StrictMock<mock::OutputLayer> outputLayer;

        StrictMock<mock::OutputLayer> outputLayer;

        StrictMock<mock::LayerFE> layerFE;

        sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();

        LayerFECompositionState layerFEState;

        LayerFECompositionState layerFEState;

    };

    };
@@ -175,21 +175,21 @@ TEST_F(CompositionEngineUpdateCursorAsyncTest, handlesMultipleLayersBeingCursorL 
    {

    {

        InSequence seq;

        InSequence seq;

        EXPECT_CALL(mOutput2Layer1.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));

        EXPECT_CALL(mOutput2Layer1.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));

        EXPECT_CALL(mOutput2Layer1.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));

        EXPECT_CALL(*mOutput2Layer1.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));

        EXPECT_CALL(mOutput2Layer1.outputLayer, writeCursorPositionToHWC());

        EXPECT_CALL(mOutput2Layer1.outputLayer, writeCursorPositionToHWC());

    }

    }





    {

    {

        InSequence seq;

        InSequence seq;

        EXPECT_CALL(mOutput3Layer1.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));

        EXPECT_CALL(mOutput3Layer1.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));

        EXPECT_CALL(mOutput3Layer1.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));

        EXPECT_CALL(*mOutput3Layer1.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));

        EXPECT_CALL(mOutput3Layer1.outputLayer, writeCursorPositionToHWC());

        EXPECT_CALL(mOutput3Layer1.outputLayer, writeCursorPositionToHWC());

    }

    }





    {

    {

        InSequence seq;

        InSequence seq;

        EXPECT_CALL(mOutput3Layer2.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));

        EXPECT_CALL(mOutput3Layer2.outputLayer, isHardwareCursor()).WillRepeatedly(Return(true));

        EXPECT_CALL(mOutput3Layer2.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));

        EXPECT_CALL(*mOutput3Layer2.layerFE, prepareCompositionState(LayerFE::StateSubset::Cursor));

        EXPECT_CALL(mOutput3Layer2.outputLayer, writeCursorPositionToHWC());

        EXPECT_CALL(mOutput3Layer2.outputLayer, writeCursorPositionToHWC());

    }

    }

services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp

+43 −43
Original line number Original line Diff line number Diff line
@@ -1697,12 +1697,12 @@ struct OutputUpdateColorProfileTest : public testing::Test { 




    struct Layer {

    struct Layer {

        Layer() {

        Layer() {

            EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(mLayerFE));

            EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*mLayerFE));

            EXPECT_CALL(mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));

            EXPECT_CALL(*mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));

        }

        }





        StrictMock<mock::OutputLayer> mOutputLayer;

        StrictMock<mock::OutputLayer> mOutputLayer;

        StrictMock<mock::LayerFE> mLayerFE;

        sp<StrictMock<mock::LayerFE>> mLayerFE = sp<StrictMock<mock::LayerFE>>::make();

        LayerFECompositionState mLayerFEState;

        LayerFECompositionState mLayerFEState;

    };

    };
@@ -2712,12 +2712,12 @@ struct OutputPostFramebufferTest : public testing::Test { 




    struct Layer {

    struct Layer {

        Layer() {

        Layer() {

            EXPECT_CALL(outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(layerFE));

            EXPECT_CALL(outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));

            EXPECT_CALL(outputLayer, getHwcLayer()).WillRepeatedly(Return(&hwc2Layer));

            EXPECT_CALL(outputLayer, getHwcLayer()).WillRepeatedly(Return(&hwc2Layer));

        }

        }





        StrictMock<mock::OutputLayer> outputLayer;

        StrictMock<mock::OutputLayer> outputLayer;

        StrictMock<mock::LayerFE> layerFE;

        sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();

        StrictMock<HWC2::mock::Layer> hwc2Layer;

        StrictMock<HWC2::mock::Layer> hwc2Layer;

    };

    };
@@ -2793,11 +2793,11 @@ TEST_F(OutputPostFramebufferTest, releaseFencesAreSentToLayerFE) { 
    // are passed. This happens to work with the current implementation, but

    // are passed. This happens to work with the current implementation, but

    // would not survive certain calls like Fence::merge() which would return a

    // would not survive certain calls like Fence::merge() which would return a

    // new instance.

    // new instance.

    EXPECT_CALL(mLayer1.layerFE,

    EXPECT_CALL(*mLayer1.layerFE,

                onLayerDisplayed(Property(&sp<Fence>::get, Eq(layer1Fence.get()))));

                onLayerDisplayed(Property(&sp<Fence>::get, Eq(layer1Fence.get()))));

    EXPECT_CALL(mLayer2.layerFE,

    EXPECT_CALL(*mLayer2.layerFE,

                onLayerDisplayed(Property(&sp<Fence>::get, Eq(layer2Fence.get()))));

                onLayerDisplayed(Property(&sp<Fence>::get, Eq(layer2Fence.get()))));

    EXPECT_CALL(mLayer3.layerFE,

    EXPECT_CALL(*mLayer3.layerFE,

                onLayerDisplayed(Property(&sp<Fence>::get, Eq(layer3Fence.get()))));

                onLayerDisplayed(Property(&sp<Fence>::get, Eq(layer3Fence.get()))));





    mOutput.postFramebuffer();

    mOutput.postFramebuffer();
@@ -2824,9 +2824,9 @@ TEST_F(OutputPostFramebufferTest, releaseFencesIncludeClientTargetAcquireFence) 
    // Fence::merge is called, and since none of the fences are actually valid,

    // Fence::merge is called, and since none of the fences are actually valid,

    // Fence::NO_FENCE is returned and passed to each onLayerDisplayed() call.

    // Fence::NO_FENCE is returned and passed to each onLayerDisplayed() call.

    // This is the best we can do without creating a real kernel fence object.

    // This is the best we can do without creating a real kernel fence object.

    EXPECT_CALL(mLayer1.layerFE, onLayerDisplayed(Fence::NO_FENCE));

    EXPECT_CALL(*mLayer1.layerFE, onLayerDisplayed(Fence::NO_FENCE));

    EXPECT_CALL(mLayer2.layerFE, onLayerDisplayed(Fence::NO_FENCE));

    EXPECT_CALL(*mLayer2.layerFE, onLayerDisplayed(Fence::NO_FENCE));

    EXPECT_CALL(mLayer3.layerFE, onLayerDisplayed(Fence::NO_FENCE));

    EXPECT_CALL(*mLayer3.layerFE, onLayerDisplayed(Fence::NO_FENCE));





    mOutput.postFramebuffer();

    mOutput.postFramebuffer();

}

}
@@ -3330,12 +3330,12 @@ TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings, 
struct OutputComposeSurfacesTest_HandlesProtectedContent : public OutputComposeSurfacesTest {

struct OutputComposeSurfacesTest_HandlesProtectedContent : public OutputComposeSurfacesTest {

    struct Layer {

    struct Layer {

        Layer() {

        Layer() {

            EXPECT_CALL(mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));

            EXPECT_CALL(*mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));

            EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(mLayerFE));

            EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*mLayerFE));

        }

        }





        StrictMock<mock::OutputLayer> mOutputLayer;

        StrictMock<mock::OutputLayer> mOutputLayer;

        StrictMock<mock::LayerFE> mLayerFE;

        sp<StrictMock<mock::LayerFE>> mLayerFE = sp<StrictMock<mock::LayerFE>>::make();

        LayerFECompositionState mLayerFEState;

        LayerFECompositionState mLayerFEState;

    };

    };
@@ -3546,12 +3546,12 @@ struct GenerateClientCompositionRequestsTest : public testing::Test { 
        Layer() {

        Layer() {

            EXPECT_CALL(mOutputLayer, getState()).WillRepeatedly(ReturnRef(mOutputLayerState));

            EXPECT_CALL(mOutputLayer, getState()).WillRepeatedly(ReturnRef(mOutputLayerState));

            EXPECT_CALL(mOutputLayer, editState()).WillRepeatedly(ReturnRef(mOutputLayerState));

            EXPECT_CALL(mOutputLayer, editState()).WillRepeatedly(ReturnRef(mOutputLayerState));

            EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(mLayerFE));

            EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*mLayerFE));

            EXPECT_CALL(mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));

            EXPECT_CALL(*mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));

        }

        }





        StrictMock<mock::OutputLayer> mOutputLayer;

        StrictMock<mock::OutputLayer> mOutputLayer;

        StrictMock<mock::LayerFE> mLayerFE;

        sp<StrictMock<mock::LayerFE>> mLayerFE = sp<StrictMock<mock::LayerFE>>::make();

        LayerFECompositionState mLayerFEState;

        LayerFECompositionState mLayerFEState;

        impl::OutputLayerCompositionState mOutputLayerState;

        impl::OutputLayerCompositionState mOutputLayerState;

        LayerFE::LayerSettings mLayerSettings;

        LayerFE::LayerSettings mLayerSettings;
@@ -3645,11 +3645,11 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, gathersClientCompositi 
    LayerFE::LayerSettings mShadowSettings;

    LayerFE::LayerSettings mShadowSettings;

    mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};

    mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};





    EXPECT_CALL(mLayers[0].mLayerFE, prepareClientCompositionList(_))

    EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(_))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[1].mLayerFE, prepareClientCompositionList(_))

    EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(_))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[1].mLayerSettings})));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[1].mLayerSettings})));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(_))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>(

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>(

                    {mShadowSettings, mLayers[2].mLayerSettings})));

                    {mShadowSettings, mLayers[2].mLayerSettings})));
@@ -3683,7 +3683,7 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 
    mLayers[1].mLayerFEState.isOpaque = true;

    mLayers[1].mLayerFEState.isOpaque = true;

    mLayers[2].mLayerFEState.isOpaque = true;

    mLayers[2].mLayerFEState.isOpaque = true;





    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(_))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));





    Region accumClearRegion(Rect(10, 11, 12, 13));

    Region accumClearRegion(Rect(10, 11, 12, 13));
@@ -3709,7 +3709,7 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 
    mLayers[1].mLayerFEState.isOpaque = false;

    mLayers[1].mLayerFEState.isOpaque = false;

    mLayers[2].mLayerFEState.isOpaque = false;

    mLayers[2].mLayerFEState.isOpaque = false;





    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(_))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));





    Region accumClearRegion(Rect(10, 11, 12, 13));

    Region accumClearRegion(Rect(10, 11, 12, 13));
@@ -3773,9 +3773,9 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, clearsHWCLayersIfOpaqu 
    mBlackoutSettings.alpha = 0.f;

    mBlackoutSettings.alpha = 0.f;

    mBlackoutSettings.disableBlending = true;

    mBlackoutSettings.disableBlending = true;





    EXPECT_CALL(mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

    EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mBlackoutSettings})));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mBlackoutSettings})));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));





    auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,

    auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
@@ -3835,11 +3835,11 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 
            false /* disabledBlurs */,

            false /* disabledBlurs */,

    };

    };





    EXPECT_CALL(mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

    EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

    EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));





    static_cast<void>(

    static_cast<void>(
@@ -3891,11 +3891,11 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 
            false /* disabledBlurs */,

            false /* disabledBlurs */,

    };

    };





    EXPECT_CALL(mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

    EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

    EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));





    static_cast<void>(

    static_cast<void>(
@@ -3948,11 +3948,11 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 
            false /* disabledBlurs */,

            false /* disabledBlurs */,

    };

    };





    EXPECT_CALL(mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

    EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

    EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));





    static_cast<void>(

    static_cast<void>(
@@ -4003,11 +4003,11 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 
            false /* disabledBlurs */,

            false /* disabledBlurs */,

    };

    };





    EXPECT_CALL(mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

    EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

    EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));





    static_cast<void>(

    static_cast<void>(
@@ -4056,11 +4056,11 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 
            false /* disabledBlurs */,

            false /* disabledBlurs */,

    };

    };





    EXPECT_CALL(mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

    EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

    EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));





    static_cast<void>(mOutput.generateClientCompositionRequests(true /* supportsProtectedContent */,

    static_cast<void>(mOutput.generateClientCompositionRequests(true /* supportsProtectedContent */,
@@ -4188,7 +4188,7 @@ TEST_F(GenerateClientCompositionRequestsTest, handlesLandscapeModeSplitScreenReq 




    EXPECT_CALL(leftLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));

    EXPECT_CALL(leftLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));

    EXPECT_CALL(leftLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));

    EXPECT_CALL(leftLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));

    EXPECT_CALL(leftLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(leftLayerSettings))))

    EXPECT_CALL(*leftLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(leftLayerSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({leftLayer.mLayerSettings})));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({leftLayer.mLayerSettings})));





    compositionengine::LayerFE::ClientCompositionTargetSettings rightLayerSettings{

    compositionengine::LayerFE::ClientCompositionTargetSettings rightLayerSettings{
@@ -4206,7 +4206,7 @@ TEST_F(GenerateClientCompositionRequestsTest, handlesLandscapeModeSplitScreenReq 




    EXPECT_CALL(rightLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));

    EXPECT_CALL(rightLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));

    EXPECT_CALL(rightLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));

    EXPECT_CALL(rightLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));

    EXPECT_CALL(rightLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(rightLayerSettings))))

    EXPECT_CALL(*rightLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(rightLayerSettings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({rightLayer.mLayerSettings})));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({rightLayer.mLayerSettings})));





    constexpr bool supportsProtectedContent = true;

    constexpr bool supportsProtectedContent = true;
@@ -4246,7 +4246,7 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 




    EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));

    EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));

    EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));

    EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings))))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mShadowSettings})));

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mShadowSettings})));





    auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,

    auto requests = mOutput.generateClientCompositionRequests(false /* supportsProtectedContent */,
@@ -4286,7 +4286,7 @@ TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, 




    EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));

    EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));

    EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));

    EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));

    EXPECT_CALL(mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings))))

    EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings))))

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>(

            .WillOnce(Return(std::vector<LayerFE::LayerSettings>(

                    {mShadowSettings, mLayers[2].mLayerSettings})));

                    {mShadowSettings, mLayers[2].mLayerSettings})));