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

Commit 0a51a879 authored by Vishnu Nair's avatar Vishnu Nair
Browse files

Remove use of legacy layers from TransactionApplicationTest 

Legacy layers are no longer used in production, this
changes the unit tests to use requestedlayerstate
directly.

Flag: EXEMPT removing flagged code
Test: presubmit
Bug: 330785038
Change-Id: I50e3a5e15d9b97ec04e49af2b6b4aab77ed17e7a
parent 4dae3748

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+12 −0
Original line number Diff line number Diff line
@@ -620,6 +620,18 @@ public: 
        mFlinger->mNewLayers.emplace_back(std::move(layer));

    }



    // Used to add a layer before updateLayerSnapshots is called.

    // Must have transactionsFlushed enabled for the new layer to be updated.

    void addLayer(uint32_t layerId) {

        std::scoped_lock<std::mutex> lock(mFlinger->mCreatedLayersLock);

        LayerCreationArgs args(std::make_optional(layerId));

        args.flinger = this->mFlinger.get();

        auto layer = std::make_unique<frontend::RequestedLayerState>(args);

        auto legacyLayer = sp<Layer>::make(args);

        injectLegacyLayer(legacyLayer);

        mFlinger->mNewLayers.emplace_back(std::move(layer));

    }



    /* ------------------------------------------------------------------------

     * Read-only access to private data to assert post-conditions.

     */

services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp

+30 −14
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#undef LOG_TAG

#define LOG_TAG "TransactionApplicationTest"



#include <binder/Binder.h>

#include <common/test/FlagUtils.h>

#include <compositionengine/Display.h>

#include <compositionengine/mock/DisplaySurface.h>
@@ -26,10 +27,10 @@ 
#include <gui/SurfaceComposerClient.h>

#include <gui/fake/BufferData.h>

#include <log/log.h>

#include <renderengine/mock/RenderEngine.h>

#include <ui/MockFence.h>

#include <utils/String8.h>

#include <vector>

#include <binder/Binder.h>



#include "FrontEnd/TransactionHandler.h"

#include "TestableSurfaceFlinger.h"
@@ -55,7 +56,9 @@ public: 


        mFlinger.setupComposer(std::make_unique<Hwc2::mock::Composer>());

        mFlinger.setupMockScheduler();

        mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));

        mFlinger.flinger()->addTransactionReadyFilters();

        mFlinger.enableLayerLifecycleManager();

    }



    ~TransactionApplicationTest() {
@@ -65,6 +68,7 @@ public: 
    }



    TestableSurfaceFlinger mFlinger;

    renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();



    struct TransactionInfo {

        Vector<ComposerState> states;
@@ -323,15 +327,17 @@ TEST_F(TransactionApplicationTest, ApplyTokensUseDifferentQueues) { 
    transaction1.states[0].state.bufferData =

            std::make_shared<fake::BufferData>(/* bufferId */ 1, /* width */ 1, /* height */ 1,

                                               /* pixelFormat */ 0, /* outUsage */ 0);

    mFlinger.addLayer(1);

    bool out;

    mFlinger.updateLayerSnapshots(VsyncId{1}, 0, /* transactionsFlushed */ true, out);

    transaction1.states[0].externalTexture =

            std::make_shared<FakeExternalTexture>(*transaction1.states[0].state.bufferData);

    transaction1.states[0].state.surface =

            sp<Layer>::make(LayerCreationArgs(mFlinger.flinger(), nullptr, "TestLayer", 0, {}))

                    ->getHandle();

    transaction1.states[0].state.surface = mFlinger.getLegacyLayer(1)->getHandle();

    auto fence = sp<mock::MockFence>::make();

    EXPECT_CALL(*fence, getStatus()).WillRepeatedly(Return(Fence::Status::Unsignaled));

    transaction1.states[0].state.bufferData->acquireFence = std::move(fence);

    transaction1.states[0].state.bufferData->flags = BufferData::BufferDataChange::fenceChanged;

    transaction1.states[0].layerId = 1;

    transaction1.isAutoTimestamp = true;



    // Transaction 2 should be ready to be applied.
@@ -361,8 +367,7 @@ public: 
        }

        mFlinger.getPendingTransactionQueue().clear();

        mFlinger.commitTransactionsLocked(eTransactionMask);

        mFlinger.mutableCurrentState().layersSortedByZ.clear();

        mFlinger.mutableDrawingState().layersSortedByZ.clear();

        mFlinger.destroyAllLayerHandles();

    }



    static sp<Fence> fence(Fence::Status status) {
@@ -371,8 +376,7 @@ public: 
        return fence;

    }



    ComposerState createComposerState(int layerId, sp<Fence> fence, uint64_t what,

                                      std::optional<sp<IBinder>> layerHandle = std::nullopt) {

    ComposerState createComposerState(int layerId, sp<Fence> fence, uint64_t what) {

        ComposerState state;

        state.state.bufferData =

                std::make_shared<fake::BufferData>(/* bufferId */ 123L, /* width */ 1,
@@ -380,9 +384,6 @@ public: 
                                                   /* outUsage */ 0);

        state.state.bufferData->acquireFence = std::move(fence);

        state.state.layerId = layerId;

        state.state.surface = layerHandle.value_or(

                sp<Layer>::make(LayerCreationArgs(mFlinger.flinger(), nullptr, "TestLayer", 0, {}))

                        ->getHandle());

        state.state.bufferData->flags = BufferData::BufferDataChange::fenceChanged;



        state.state.what = what;
@@ -418,6 +419,19 @@ public: 
                              size_t expectedTransactionsPending) {

        EXPECT_TRUE(mFlinger.getTransactionQueue().isEmpty());

        EXPECT_EQ(0u, mFlinger.getPendingTransactionQueue().size());

        std::unordered_set<uint32_t> createdLayers;

        for (auto transaction : transactions) {

            for (auto& state : transaction.states) {

                auto layerId = static_cast<uint32_t>(state.state.layerId);

                if (createdLayers.find(layerId) == createdLayers.end()) {

                    mFlinger.addLayer(layerId);

                    createdLayers.insert(layerId);

                }

            }

        }

        bool unused;

        bool mustComposite = mFlinger.updateLayerSnapshots(VsyncId{1}, /*frameTimeNs=*/0,

                                                           /*transactionsFlushed=*/true, unused);



        for (auto transaction : transactions) {

            std::vector<ResolvedComposerState> resolvedStates;
@@ -427,6 +441,9 @@ public: 
                resolvedState.state = std::move(state.state);

                resolvedState.externalTexture =

                        std::make_shared<FakeExternalTexture>(*resolvedState.state.bufferData);

                resolvedState.layerId = static_cast<uint32_t>(state.state.layerId);

                resolvedState.state.surface =

                        mFlinger.getLegacyLayer(resolvedState.layerId)->getHandle();

                resolvedStates.emplace_back(resolvedState);

            }
@@ -458,9 +475,8 @@ public: 
TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_RemovesSingleSignaledFromTheQueue) {

    const sp<IBinder> kApplyToken =

            IInterface::asBinder(TransactionCompletedListener::getIInstance());

    const auto kLayerId = 1;

    const auto kLayerId = 10;

    const auto kExpectedTransactionsPending = 0u;



    const auto signaledTransaction =

            createTransactionInfo(kApplyToken,

                                  {createComposerState(kLayerId, fence(Fence::Status::Signaled),
@@ -773,7 +789,7 @@ public: 
TEST_F(LatchUnsignaledDisabledTest, Flush_RemovesSignaledFromTheQueue) {

    const sp<IBinder> kApplyToken =

            IInterface::asBinder(TransactionCompletedListener::getIInstance());

    const auto kLayerId = 1;

    const auto kLayerId = 10;

    const auto kExpectedTransactionsPending = 0u;



    const auto signaledTransaction =