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

Commit c7ebf7c4 authored by Chavi Weingarten's avatar Chavi Weingarten Committed by Automerger Merge Worker
Browse files

Merge "Send transaction callbacks even when no BSL" into tm-dev am: f18ac6ca 

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



Change-Id: I3e949e0789c5790b38ac2f5d2aecfc9592061b3e
Ignore-AOSP-First: this is an automerge
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 4644d8c7 f18ac6ca

services/surfaceflinger/Layer.cpp

+12 −0
Original line number Original line Diff line number Diff line
@@ -2664,6 +2664,18 @@ void Layer::cloneDrawingState(const Layer* from) { 
    mDrawingState.callbackHandles = {};

    mDrawingState.callbackHandles = {};

}

}





bool Layer::setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& handles) {

    if (handles.empty()) {

        return false;

    }



    for (const auto& handle : handles) {

        mFlinger->getTransactionCallbackInvoker().registerUnpresentedCallbackHandle(handle);

    }



    return true;

}



// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------





std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate) {

std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate) {

services/surfaceflinger/Layer.h

+1 −3
Original line number Original line Diff line number Diff line
@@ -431,9 +431,7 @@ public: 
    virtual bool setApi(int32_t /*api*/) { return false; };

    virtual bool setApi(int32_t /*api*/) { return false; };

    virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/) { return false; };

    virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/) { return false; };

    virtual bool setTransactionCompletedListeners(

    virtual bool setTransactionCompletedListeners(

            const std::vector<sp<CallbackHandle>>& /*handles*/) {

            const std::vector<sp<CallbackHandle>>& /*handles*/);

        return false;

    };

    virtual bool addFrameEvent(const sp<Fence>& /*acquireFence*/, nsecs_t /*postedTime*/,

    virtual bool addFrameEvent(const sp<Fence>& /*acquireFence*/, nsecs_t /*postedTime*/,

                               nsecs_t /*requestedPresentTime*/) {

                               nsecs_t /*requestedPresentTime*/) {

        return false;

        return false;

services/surfaceflinger/tests/LayerCallback_test.cpp

+106 −15
Original line number Original line Diff line number Diff line
@@ -55,10 +55,8 @@ public: 
        return createLayer(mClient, "test", 0, 0, ISurfaceComposerClient::eFXSurfaceBufferState);

        return createLayer(mClient, "test", 0, 0, ISurfaceComposerClient::eFXSurfaceBufferState);

    }

    }





    static int fillTransaction(Transaction& transaction, CallbackHelper* callbackHelper,

    static int fillBuffer(Transaction& transaction, const sp<SurfaceControl>& layer,

                               const sp<SurfaceControl>& layer = nullptr, bool setBuffer = true,

                          bool setBuffer = true, bool setBackgroundColor = false) {

                               bool setBackgroundColor = false) {

        if (layer) {

        sp<GraphicBuffer> buffer;

        sp<GraphicBuffer> buffer;

        sp<Fence> fence;

        sp<Fence> fence;

        if (setBuffer) {

        if (setBuffer) {
@@ -74,6 +72,18 @@ public: 
            transaction.setBackgroundColor(layer, /*color*/ half3(1.0f, 0, 0), /*alpha*/ 1.0f,

            transaction.setBackgroundColor(layer, /*color*/ half3(1.0f, 0, 0), /*alpha*/ 1.0f,

                                           ui::Dataspace::UNKNOWN);

                                           ui::Dataspace::UNKNOWN);

        }

        }



        return NO_ERROR;

    }



    static int fillTransaction(Transaction& transaction, CallbackHelper* callbackHelper,

                               const sp<SurfaceControl>& layer = nullptr, bool setBuffer = true,

                               bool setBackgroundColor = false) {

        if (layer) {

            int err = fillBuffer(transaction, layer, setBuffer, setBackgroundColor);

            if (err != NO_ERROR) {

                return err;

            }

        }

        }





        transaction.addTransactionCompletedCallback(callbackHelper->function,

        transaction.addTransactionCompletedCallback(callbackHelper->function,
@@ -1115,7 +1125,7 @@ TEST_F(LayerCallbackTest, CommitCallbackOffscreenLayer) { 
    Transaction transaction;

    Transaction transaction;

    CallbackHelper callback;

    CallbackHelper callback;

    int err = fillTransaction(transaction, &callback, layer, true);

    int err = fillTransaction(transaction, &callback, layer, true);

    err |= fillTransaction(transaction, &callback, offscreenLayer, true);

    err |= fillBuffer(transaction, offscreenLayer);

    if (err) {

    if (err) {

        GTEST_SUCCEED() << "test not supported";

        GTEST_SUCCEED() << "test not supported";

        return;

        return;
@@ -1129,5 +1139,86 @@ TEST_F(LayerCallbackTest, CommitCallbackOffscreenLayer) { 
    committedSc.insert(layer);

    committedSc.insert(layer);

    committedSc.insert(offscreenLayer);

    committedSc.insert(offscreenLayer);

    EXPECT_NO_FATAL_FAILURE(waitForCommitCallback(callback, committedSc));

    EXPECT_NO_FATAL_FAILURE(waitForCommitCallback(callback, committedSc));



    ExpectedResult expected;

    expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);

    expected.addSurface(ExpectedResult::Transaction::PRESENTED, offscreenLayer);

    EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));

}

}



TEST_F(LayerCallbackTest, TransactionCommittedCallback_BSL) {

    sp<SurfaceControl> layer;

    ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());



    Transaction transaction;

    CallbackHelper callback;

    int err = fillTransaction(transaction, &callback, layer, true);

    if (err) {

        GTEST_SUCCEED() << "test not supported";

        return;

    }

    transaction.addTransactionCommittedCallback(callback.function, callback.getContext()).apply();

    std::unordered_set<sp<SurfaceControl>, SCHash> committedSc;

    committedSc.insert(layer);

    EXPECT_NO_FATAL_FAILURE(waitForCommitCallback(callback, committedSc));

    ExpectedResult expected;

    expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);

    EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));

}



TEST_F(LayerCallbackTest, TransactionCommittedCallback_EffectLayer) {

    sp<SurfaceControl> layer;

    ASSERT_NO_FATAL_FAILURE(layer = createColorLayer("ColorLayer", Color::RED));



    Transaction transaction;

    CallbackHelper callback;

    int err = fillTransaction(transaction, &callback);

    if (err) {

        GTEST_SUCCEED() << "test not supported";

        return;

    }

    transaction.addTransactionCommittedCallback(callback.function, callback.getContext()).apply();

    std::unordered_set<sp<SurfaceControl>, SCHash> committedSc;

    EXPECT_NO_FATAL_FAILURE(waitForCommitCallback(callback, committedSc));



    ExpectedResult expected;

    EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));

}



TEST_F(LayerCallbackTest, TransactionCommittedCallback_ContainerLayer) {

    sp<SurfaceControl> layer;

    ASSERT_NO_FATAL_FAILURE(layer = createLayer(mClient, "Container Layer", 0, 0,

                                                ISurfaceComposerClient::eFXSurfaceContainer));



    Transaction transaction;

    CallbackHelper callback;

    int err = fillTransaction(transaction, &callback);

    if (err) {

        GTEST_SUCCEED() << "test not supported";

        return;

    }

    transaction.addTransactionCommittedCallback(callback.function, callback.getContext()).apply();

    std::unordered_set<sp<SurfaceControl>, SCHash> committedSc;

    EXPECT_NO_FATAL_FAILURE(waitForCommitCallback(callback, committedSc));



    ExpectedResult expected;

    EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));

}



TEST_F(LayerCallbackTest, TransactionCommittedCallback_NoLayer) {

    Transaction transaction;

    CallbackHelper callback;

    int err = fillTransaction(transaction, &callback);

    if (err) {

        GTEST_SUCCEED() << "test not supported";

        return;

    }

    transaction.addTransactionCommittedCallback(callback.function, callback.getContext()).apply();

    std::unordered_set<sp<SurfaceControl>, SCHash> committedSc;

    EXPECT_NO_FATAL_FAILURE(waitForCommitCallback(callback, committedSc));



    ExpectedResult expected;

    EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));

}



} // namespace android
 
} // namespace android