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

Commit 149cebde authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Fix caching flickering for unsecure displays" into sc-dev am: 5a68a6cf 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/15332036

Change-Id: I48fa6bd7ea20b754fb9e6c91a5963463af50a394
parents ac2bf48e 5a68a6cf

services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp

+1 −1
Original line number Diff line number Diff line
@@ -175,7 +175,7 @@ void CachedSet::render(renderengine::RenderEngine& renderEngine, TexturePool& te 
    LayerFE::ClientCompositionTargetSettings targetSettings{

            .clip = Region(viewport),

            .needsFiltering = false,

            .isSecure = true,

            .isSecure = outputState.isSecure,

            .supportsProtectedContent = false,

            .clearRegion = clearRegion,

            .viewport = viewport,

services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp

+69 −3
Original line number Diff line number Diff line
@@ -51,6 +51,15 @@ MATCHER_P(ClientCompositionTargetSettingsBlurSettingsEq, expectedBlurSetting, "" 


    return expectedBlurSetting == arg.blurSetting;

}



MATCHER_P(ClientCompositionTargetSettingsSecureEq, expectedSecureSetting, "") {

    *result_listener << "ClientCompositionTargetSettings' SecureSettings aren't equal \n";

    *result_listener << "expected " << expectedSecureSetting << "\n";

    *result_listener << "actual " << arg.isSecure << "\n";



    return expectedSecureSetting == arg.isSecure;

}



static const ui::Size kOutputSize = ui::Size(1, 1);



class CachedSetTest : public testing::Test {
@@ -315,7 +324,7 @@ TEST_F(CachedSetTest, updateAge_BufferUpdate) { 
    EXPECT_EQ(0u, cachedSet.getAge());

}



TEST_F(CachedSetTest, render) {

TEST_F(CachedSetTest, renderUnsecureOutput) {

    // Skip the 0th layer to ensure that the bounding box of the layers is offset from (0, 0)

    CachedSet::Layer& layer1 = *mTestLayers[1]->cachedSetLayer.get();

    sp<mock::LayerFE> layerFE1 = mTestLayers[1]->layerFE;
@@ -348,9 +357,66 @@ TEST_F(CachedSetTest, render) { 
        return NO_ERROR;

    };



    EXPECT_CALL(*layerFE1, prepareClientCompositionList(_)).WillOnce(Return(clientCompList1));

    EXPECT_CALL(*layerFE2, prepareClientCompositionList(_)).WillOnce(Return(clientCompList2));

    EXPECT_CALL(*layerFE1,

                prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(false)))

            .WillOnce(Return(clientCompList1));

    EXPECT_CALL(*layerFE2,

                prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(false)))

            .WillOnce(Return(clientCompList2));

    EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _, _)).WillOnce(Invoke(drawLayers));

    mOutputState.isSecure = false;

    cachedSet.render(mRenderEngine, mTexturePool, mOutputState);

    expectReadyBuffer(cachedSet);



    EXPECT_EQ(mOutputState.framebufferSpace, cachedSet.getOutputSpace());

    EXPECT_EQ(Rect(kOutputSize.width, kOutputSize.height), cachedSet.getTextureBounds());



    // Now check that appending a new cached set properly cleans up RenderEngine resources.

    CachedSet::Layer& layer3 = *mTestLayers[2]->cachedSetLayer.get();

    cachedSet.append(CachedSet(layer3));

}



TEST_F(CachedSetTest, renderSecureOutput) {

    // Skip the 0th layer to ensure that the bounding box of the layers is offset from (0, 0)

    CachedSet::Layer& layer1 = *mTestLayers[1]->cachedSetLayer.get();

    sp<mock::LayerFE> layerFE1 = mTestLayers[1]->layerFE;

    CachedSet::Layer& layer2 = *mTestLayers[2]->cachedSetLayer.get();

    sp<mock::LayerFE> layerFE2 = mTestLayers[2]->layerFE;



    CachedSet cachedSet(layer1);

    cachedSet.append(CachedSet(layer2));



    std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;

    clientCompList1.push_back({});

    clientCompList1[0].alpha = 0.5f;



    std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;

    clientCompList2.push_back({});

    clientCompList2[0].alpha = 0.75f;



    const auto drawLayers = [&](const renderengine::DisplaySettings& displaySettings,

                                const std::vector<const renderengine::LayerSettings*>& layers,

                                const std::shared_ptr<renderengine::ExternalTexture>&, const bool,

                                base::unique_fd&&, base::unique_fd*) -> size_t {

        EXPECT_EQ(mOutputState.framebufferSpace.content, displaySettings.physicalDisplay);

        EXPECT_EQ(mOutputState.layerStackSpace.content, displaySettings.clip);

        EXPECT_EQ(ui::Transform::toRotationFlags(mOutputState.framebufferSpace.orientation),

                  displaySettings.orientation);

        EXPECT_EQ(0.5f, layers[0]->alpha);

        EXPECT_EQ(0.75f, layers[1]->alpha);

        EXPECT_EQ(ui::Dataspace::SRGB, displaySettings.outputDataspace);



        return NO_ERROR;

    };



    EXPECT_CALL(*layerFE1,

                prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(true)))

            .WillOnce(Return(clientCompList1));

    EXPECT_CALL(*layerFE2,

                prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(true)))

            .WillOnce(Return(clientCompList2));

    EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _, _)).WillOnce(Invoke(drawLayers));

    mOutputState.isSecure = true;

    cachedSet.render(mRenderEngine, mTexturePool, mOutputState);

    expectReadyBuffer(cachedSet);