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

Commit 46219f57 authored by Ady Abraham's avatar Ady Abraham
Browse files

composer: cleanup CommandWriterBase and CommandReaderBase part 2 

Bug: 208856704
Test: VTS
Change-Id: I30f4cfef66a1c833142b4645f69e8ad9fbf0de8e
parent b9b5df3c

graphics/composer/aidl/aidl_api/android.hardware.graphics.composer3/current/android/hardware/graphics/composer3/HandleIndex.aidl

deleted100644 → 0
+0 −39
Original line number Diff line number Diff line 
/**

 * Copyright (c) 2021, The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

///////////////////////////////////////////////////////////////////////////////

// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //

///////////////////////////////////////////////////////////////////////////////



// This file is a snapshot of an AIDL file. Do not edit it manually. There are

// two cases:

// 1). this is a frozen version file - do not edit this in any case.

// 2). this is a 'current' file. If you make a backwards compatible change to

//     the interface (from the latest frozen version), the build system will

//     prompt you to update this file with `m <name>-update-api`.

//

// You must not make a backward incompatible change to any AIDL file built

// with the aidl_interface module type with versions property set. The module

// type is used to build AIDL files in a way that they can be used across

// independently updatable components of the system. If a device is shipped

// with such a backward incompatible change, it has a high risk of breaking

// later when a module using the interface is updated, e.g., Mainline modules.



package android.hardware.graphics.composer3;

@Backing(type="int") @VintfStability

enum HandleIndex {

  EMPTY = -1,

  CACHED = -2,

}

graphics/composer/aidl/android/hardware/graphics/composer3/HandleIndex.aidl

deleted100644 → 0
+0 −33
Original line number Diff line number Diff line 
/**

 * Copyright (c) 2021, The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package android.hardware.graphics.composer3;



/**

 * Special index values (always negative) for command queue commands.

 */

@VintfStability

@Backing(type="int")

enum HandleIndex {

    /**

     * No handle

     */

    EMPTY = -1,

    /**

     * Use cached handle

     */

    CACHED = -2,

}

graphics/composer/aidl/android/hardware/graphics/composer3/translate-ndk.cpp

+0 −9
Original line number Diff line number Diff line
@@ -129,15 +129,6 @@ static_assert(aidl::android::hardware::graphics::composer3::DisplayRequest:: 
              static_cast<int>(::android::hardware::graphics::composer::V2_1::IComposerClient::

                                       DisplayRequest::WRITE_CLIENT_TARGET_TO_OUTPUT));



static_assert(aidl::android::hardware::graphics::composer3::HandleIndex::EMPTY ==

              static_cast<aidl::android::hardware::graphics::composer3::HandleIndex>(

                      ::android::hardware::graphics::composer::V2_1::IComposerClient::HandleIndex::

                              EMPTY));

static_assert(aidl::android::hardware::graphics::composer3::HandleIndex::CACHED ==

              static_cast<aidl::android::hardware::graphics::composer3::HandleIndex>(

                      ::android::hardware::graphics::composer::V2_1::IComposerClient::HandleIndex::

                              CACHED));



static_assert(

        aidl::android::hardware::graphics::composer3::PowerMode::OFF ==

        static_cast<aidl::android::hardware::graphics::composer3::PowerMode>(

graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp

+35 −103
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include <aidl/Gtest.h>

#include <aidl/Vintf.h>

#include <aidl/android/hardware/graphics/common/BufferUsage.h>

#include <aidl/android/hardware/graphics/composer3/IComposer.h>

#include <android/binder_manager.h>

#include <composer-vts/include/ReadbackVts.h>

#include <composer-vts/include/RenderEngineVts.h>
@@ -103,13 +104,8 @@ class GraphicsCompositionTestBase : public ::testing::Test { 
        ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::OFF));

        const auto errors = mReader.takeErrors();

        ASSERT_TRUE(mReader.takeErrors().empty());

        ASSERT_TRUE(mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty());



        std::vector<int64_t> layers;

        std::vector<Composition> types;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &layers, &types);



        ASSERT_TRUE(layers.empty());

        ASSERT_TRUE(types.empty());

        if (mComposerCallback != nullptr) {

            EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());

            EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
@@ -118,12 +114,14 @@ class GraphicsCompositionTestBase : public ::testing::Test { 
    }



    ::android::sp<::android::GraphicBuffer> allocate() {

        const auto width = static_cast<uint32_t>(mDisplayWidth);

        const auto height = static_cast<uint32_t>(mDisplayHeight);

        const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |

                           static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);



        return ::android::sp<::android::GraphicBuffer>::make(

                mDisplayWidth, mDisplayHeight, ::android::PIXEL_FORMAT_RGBA_8888,

                /*layerCount*/ 1,

                static_cast<uint64_t>(static_cast<int>(common::BufferUsage::CPU_WRITE_OFTEN) |

                                      static_cast<int>(common::BufferUsage::CPU_READ_OFTEN)),

                "VtsHalGraphicsComposer3_ReadbackTest");

                width, height, ::android::PIXEL_FORMAT_RGBA_8888,

                /*layerCount*/ 1u, usage, "VtsHalGraphicsComposer3_ReadbackTest");

    }



    void writeLayers(const std::vector<std::shared_ptr<TestLayer>>& layers) {
@@ -141,10 +139,10 @@ class GraphicsCompositionTestBase : public ::testing::Test { 
        }



        std::vector<CommandResultPayload> results;

        const auto status = mComposerClient->executeCommands(commands, &results);

        auto status = mComposerClient->executeCommands(commands, &results);

        ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();



        mReader.parse(results);

        mReader.parse(std::move(results));

        mWriter.reset();

    }
@@ -262,11 +260,7 @@ TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) { 
        execute();

        // if hwc cannot handle and asks for composition change,

        // just succeed the test

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -320,11 +314,7 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) { 
        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();



        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -380,11 +370,7 @@ TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) { 
        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();



        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -495,14 +481,10 @@ TEST_P(GraphicsCompositionTest, ClientComposition) { 
        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();



        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

            ASSERT_EQ(1, changedCompositionLayers.size());

        auto changedCompositionTypes = mReader.takeChangedCompositionTypes(mPrimaryDisplay);

        if (!changedCompositionTypes.empty()) {

            ASSERT_EQ(1, changedCompositionTypes.size());

            ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0]);

            ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);



            PixelFormat clientFormat = PixelFormat::RGBA_8888;

            auto clientUsage = static_cast<uint32_t>(
@@ -537,9 +519,8 @@ TEST_P(GraphicsCompositionTest, ClientComposition) { 
            mWriter.setClientTarget(mPrimaryDisplay, 0, mGraphicBuffer->handle, fenceHandle.get(),

                                    clientDataspace, std::vector<common::Rect>(1, damage));

            execute();

            mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                                &changedCompositionTypes);

            ASSERT_TRUE(changedCompositionLayers.empty());

            changedCompositionTypes = mReader.takeChangedCompositionTypes(mPrimaryDisplay);

            ASSERT_TRUE(changedCompositionTypes.empty());

        }

        ASSERT_TRUE(mReader.takeErrors().empty());
@@ -609,15 +590,12 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { 
        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();



        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        auto changedCompositionTypes = mReader.takeChangedCompositionTypes(mPrimaryDisplay);

        if (changedCompositionTypes.size() != 1) {

            continue;

        }

        // create client target buffer

        ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0]);

        ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);

        mGraphicBuffer->reallocate(static_cast<uint32_t>(mDisplayWidth),

                                   static_cast<uint32_t>(mDisplayHeight),

                                   static_cast<int32_t>(common::PixelFormat::RGBA_8888),
@@ -642,9 +620,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { 
        mWriter.setClientTarget(mPrimaryDisplay, 0, mGraphicBuffer->handle, fenceHandle.get(),

                                clientDataspace, std::vector<common::Rect>(1, clientFrame));

        execute();

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        ASSERT_EQ(0, changedCompositionLayers.size());

        changedCompositionTypes = mReader.takeChangedCompositionTypes(mPrimaryDisplay);

        ASSERT_TRUE(changedCompositionTypes.empty());

        ASSERT_TRUE(mReader.takeErrors().empty());



        mWriter.presentDisplay(mPrimaryDisplay);
@@ -687,11 +664,7 @@ TEST_P(GraphicsCompositionTest, SetLayerDamage) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -718,10 +691,7 @@ TEST_P(GraphicsCompositionTest, SetLayerDamage) { 
        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        ASSERT_TRUE(mReader.takeErrors().empty());

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        ASSERT_TRUE(changedCompositionLayers.empty());

        ASSERT_TRUE(changedCompositionTypes.empty());

        ASSERT_TRUE(mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty());

        mWriter.presentDisplay(mPrimaryDisplay);

        execute();

        ASSERT_TRUE(mReader.takeErrors().empty());
@@ -758,11 +728,7 @@ TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -821,11 +787,7 @@ TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -879,11 +841,7 @@ TEST_P(GraphicsCompositionTest, SetLayerZOrder) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -904,10 +862,7 @@ TEST_P(GraphicsCompositionTest, SetLayerZOrder) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        ASSERT_TRUE(changedCompositionLayers.empty());

        ASSERT_TRUE(changedCompositionTypes.empty());

        ASSERT_TRUE(mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty());

        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.presentDisplay(mPrimaryDisplay);

        execute();
@@ -1029,11 +984,7 @@ TEST_P(GraphicsBlendModeCompositionTest, None) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -1074,11 +1025,7 @@ TEST_P(GraphicsBlendModeCompositionTest, Coverage) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -1114,11 +1061,7 @@ TEST_P(GraphicsBlendModeCompositionTest, Premultiplied) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -1197,11 +1140,7 @@ TEST_P(GraphicsTransformCompositionTest, FLIP_H) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -1243,11 +1182,7 @@ TEST_P(GraphicsTransformCompositionTest, FLIP_V) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> changedCompositionLayers;

        std::vector<Composition> changedCompositionTypes;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &changedCompositionLayers,

                                            &changedCompositionTypes);

        if (!changedCompositionLayers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }
@@ -1289,10 +1224,7 @@ TEST_P(GraphicsTransformCompositionTest, ROT_180) { 
        ASSERT_TRUE(mReader.takeErrors().empty());

        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> layers;

        std::vector<Composition> types;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &layers, &types);

        if (!layers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED();

            return;

        }

graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp

+11 −20
Original line number Diff line number Diff line
@@ -1142,13 +1142,7 @@ class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest { 
    void TearDown() override {

        const auto errors = mReader.takeErrors();

        ASSERT_TRUE(mReader.takeErrors().empty());



        std::vector<int64_t> layers;

        std::vector<Composition> types;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &layers, &types);



        ASSERT_TRUE(layers.empty());

        ASSERT_TRUE(types.empty());

        ASSERT_TRUE(mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty());



        ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());

    }
@@ -1164,7 +1158,7 @@ class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest { 
        const auto status = mComposerClient->executeCommands(commands, &results);

        ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();



        mReader.parse(results);

        mReader.parse(std::move(results));

        mWriter.reset();

    }
@@ -1299,10 +1293,12 @@ class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest { 
        execute();

        EXPECT_TRUE(mReader.takeErrors().empty());



        int presentFence;

        mReader.takePresentFence(mPrimaryDisplay, &presentFence);

        EXPECT_NE(-1, presentFence);

        return sp<::android::Fence>::make(presentFence);

        auto presentFence = mReader.takePresentFence(mPrimaryDisplay);

        // take ownership

        const int fenceOwner = presentFence.get();

        *presentFence.getR() = -1;

        EXPECT_NE(-1, fenceOwner);

        return sp<::android::Fence>::make(fenceOwner);

    }



    int32_t getVsyncPeriod() {
@@ -1592,10 +1588,7 @@ TEST_P(GraphicsComposerAidlCommandTest, PRESENT_DISPLAY_NO_LAYER_STATE_CHANGES) 


        mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);

        execute();

        std::vector<int64_t> layers;

        std::vector<Composition> types;

        mReader.takeChangedCompositionTypes(mPrimaryDisplay, &layers, &types);

        if (!layers.empty()) {

        if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

            GTEST_SUCCEED() << "Composition change requested, skipping test";

            return;

        }
@@ -1640,10 +1633,8 @@ TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_CURSOR_POSITION) { 
    mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);



    execute();

    std::vector<int64_t> layers;

    std::vector<Composition> types;

    mReader.takeChangedCompositionTypes(mPrimaryDisplay, &layers, &types);

    if (!layers.empty()) {



    if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {

        GTEST_SUCCEED() << "Composition change requested, skipping test";

        return;

    }