| /* |
| * Copyright (C) 2017 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. |
| */ |
| |
| // #define LOG_NDEBUG 0 |
| #undef LOG_TAG |
| #define LOG_TAG "FakeHwcTest" |
| |
| #include "FakeComposerClient.h" |
| #include "FakeComposerService.h" |
| #include "FakeComposerUtils.h" |
| |
| #include <gui/DisplayEventReceiver.h> |
| #include <gui/ISurfaceComposer.h> |
| #include <gui/LayerDebugInfo.h> |
| #include <gui/LayerState.h> |
| #include <gui/Surface.h> |
| #include <gui/SurfaceComposerClient.h> |
| |
| #include <android/hidl/manager/1.0/IServiceManager.h> |
| #include <android/looper.h> |
| #include <android/native_window.h> |
| #include <binder/ProcessState.h> |
| #include <hwbinder/ProcessState.h> |
| #include <log/log.h> |
| #include <private/gui/ComposerService.h> |
| #include <ui/DisplayInfo.h> |
| #include <utils/Looper.h> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include <limits> |
| |
| using namespace std::chrono_literals; |
| |
| using namespace android; |
| using namespace android::hardware; |
| |
| using namespace sftest; |
| |
| namespace { |
| |
| // Mock test helpers |
| using ::testing::Invoke; |
| using ::testing::Return; |
| using ::testing::SetArgPointee; |
| using ::testing::_; |
| |
| using Transaction = SurfaceComposerClient::Transaction; |
| |
| /////////////////////////////////////////////// |
| |
| struct TestColor { |
| public: |
| uint8_t r; |
| uint8_t g; |
| uint8_t b; |
| uint8_t a; |
| }; |
| |
| constexpr static TestColor RED = {195, 63, 63, 255}; |
| constexpr static TestColor LIGHT_RED = {255, 177, 177, 255}; |
| constexpr static TestColor GREEN = {63, 195, 63, 255}; |
| constexpr static TestColor BLUE = {63, 63, 195, 255}; |
| constexpr static TestColor DARK_GRAY = {63, 63, 63, 255}; |
| constexpr static TestColor LIGHT_GRAY = {200, 200, 200, 255}; |
| |
| // Fill an RGBA_8888 formatted surface with a single color. |
| static void fillSurfaceRGBA8(const sp<SurfaceControl>& sc, const TestColor& color, |
| bool unlock = true) { |
| ANativeWindow_Buffer outBuffer; |
| sp<Surface> s = sc->getSurface(); |
| ASSERT_TRUE(s != nullptr); |
| ASSERT_EQ(NO_ERROR, s->lock(&outBuffer, nullptr)); |
| uint8_t* img = reinterpret_cast<uint8_t*>(outBuffer.bits); |
| for (int y = 0; y < outBuffer.height; y++) { |
| for (int x = 0; x < outBuffer.width; x++) { |
| uint8_t* pixel = img + (4 * (y * outBuffer.stride + x)); |
| pixel[0] = color.r; |
| pixel[1] = color.g; |
| pixel[2] = color.b; |
| pixel[3] = color.a; |
| } |
| } |
| if (unlock) { |
| ASSERT_EQ(NO_ERROR, s->unlockAndPost()); |
| } |
| } |
| |
| inline RenderState makeSimpleRect(int left, int top, int right, int bottom) { |
| RenderState res; |
| res.mDisplayFrame = hwc_rect_t{left, top, right, bottom}; |
| res.mPlaneAlpha = 1.0f; |
| res.mSwapCount = 0; |
| res.mSourceCrop = hwc_frect_t{0.f, 0.f, static_cast<float>(right - left), |
| static_cast<float>(bottom - top)}; |
| return res; |
| } |
| |
| inline RenderState makeSimpleRect(unsigned int left, unsigned int top, unsigned int right, |
| unsigned int bottom) { |
| EXPECT_LE(left, static_cast<unsigned int>(INT_MAX)); |
| EXPECT_LE(top, static_cast<unsigned int>(INT_MAX)); |
| EXPECT_LE(right, static_cast<unsigned int>(INT_MAX)); |
| EXPECT_LE(bottom, static_cast<unsigned int>(INT_MAX)); |
| return makeSimpleRect(static_cast<int>(left), static_cast<int>(top), static_cast<int>(right), |
| static_cast<int>(bottom)); |
| } |
| |
| //////////////////////////////////////////////// |
| |
| class DisplayTest : public ::testing::Test { |
| public: |
| class MockComposerClient : public FakeComposerClient { |
| public: |
| MOCK_METHOD2(getDisplayType, Error(Display display, ComposerClient::DisplayType* outType)); |
| MOCK_METHOD4(getDisplayAttribute, |
| Error(Display display, Config config, IComposerClient::Attribute attribute, |
| int32_t* outValue)); |
| |
| // Re-routing to basic fake implementation |
| Error getDisplayAttributeFake(Display display, Config config, |
| IComposerClient::Attribute attribute, int32_t* outValue) { |
| return FakeComposerClient::getDisplayAttribute(display, config, attribute, outValue); |
| } |
| }; |
| |
| protected: |
| static int processDisplayEvents(int fd, int events, void* data); |
| |
| void SetUp() override; |
| void TearDown() override; |
| |
| void waitForDisplayTransaction(); |
| bool waitForHotplugEvent(uint32_t id, bool connected); |
| |
| sp<IComposer> mFakeService; |
| sp<SurfaceComposerClient> mComposerClient; |
| |
| MockComposerClient* mMockComposer; |
| |
| std::unique_ptr<DisplayEventReceiver> mReceiver; |
| sp<Looper> mLooper;; |
| std::deque<DisplayEventReceiver::Event> mReceivedDisplayEvents; |
| }; |
| |
| void DisplayTest::SetUp() { |
| // TODO: The mMockComposer should be a unique_ptr, but it needs to |
| // outlive the test class. Currently ComposerClient only dies |
| // when the service is replaced. The Mock deletes itself when |
| // removeClient is called on it, which is ugly. This can be |
| // changed if HIDL ServiceManager allows removing services or |
| // ComposerClient starts taking the ownership of the contained |
| // implementation class. Moving the fake class to the HWC2 |
| // interface instead of the current Composer interface might also |
| // change the situation. |
| mMockComposer = new MockComposerClient; |
| sp<ComposerClient> client = new ComposerClient(mMockComposer); |
| mFakeService = new FakeComposerService(client); |
| (void)mFakeService->registerAsService("mock"); |
| |
| android::hardware::ProcessState::self()->startThreadPool(); |
| android::ProcessState::self()->startThreadPool(); |
| |
| EXPECT_CALL(*mMockComposer, getDisplayType(PRIMARY_DISPLAY, _)) |
| .WillOnce(DoAll(SetArgPointee<1>(IComposerClient::DisplayType::PHYSICAL), |
| Return(Error::NONE))); |
| // Primary display will be queried twice for all 5 attributes. One |
| // set of queries comes from the SurfaceFlinger proper an the |
| // other set from the VR composer. |
| // TODO: Is VR composer always present? Change to atLeast(5)? |
| EXPECT_CALL(*mMockComposer, getDisplayAttribute(PRIMARY_DISPLAY, 1, _, _)) |
| .Times(2 * 5) |
| .WillRepeatedly(Invoke(mMockComposer, &MockComposerClient::getDisplayAttributeFake)); |
| |
| startSurfaceFlinger(); |
| |
| // Fake composer wants to enable VSync injection |
| mMockComposer->onSurfaceFlingerStart(); |
| |
| mComposerClient = new SurfaceComposerClient; |
| ASSERT_EQ(NO_ERROR, mComposerClient->initCheck()); |
| |
| mReceiver.reset(new DisplayEventReceiver()); |
| mLooper = new Looper(false); |
| mLooper->addFd(mReceiver->getFd(), 0, ALOOPER_EVENT_INPUT, processDisplayEvents, this); |
| } |
| |
| void DisplayTest::TearDown() { |
| mLooper = nullptr; |
| mReceiver = nullptr; |
| |
| mComposerClient->dispose(); |
| mComposerClient = nullptr; |
| |
| // Fake composer needs to release SurfaceComposerClient before the stop. |
| mMockComposer->onSurfaceFlingerStop(); |
| stopSurfaceFlinger(); |
| |
| mFakeService = nullptr; |
| // TODO: Currently deleted in FakeComposerClient::removeClient(). Devise better lifetime |
| // management. |
| mMockComposer = nullptr; |
| } |
| |
| |
| int DisplayTest::processDisplayEvents(int /*fd*/, int /*events*/, void* data) { |
| auto self = static_cast<DisplayTest*>(data); |
| |
| ssize_t n; |
| DisplayEventReceiver::Event buffer[1]; |
| |
| while ((n = self->mReceiver->getEvents(buffer, 1)) > 0) { |
| for (int i=0 ; i<n ; i++) { |
| self->mReceivedDisplayEvents.push_back(buffer[i]); |
| } |
| } |
| ALOGD_IF(n < 0, "Error reading events (%s)\n", strerror(-n)); |
| return 1; |
| } |
| |
| void DisplayTest::waitForDisplayTransaction() { |
| // Both a refresh and a vsync event are needed to apply pending display |
| // transactions. |
| mMockComposer->refreshDisplay(EXTERNAL_DISPLAY); |
| mMockComposer->runVSyncAndWait(); |
| |
| // Extra vsync and wait to avoid a 10% flake due to a race. |
| mMockComposer->runVSyncAndWait(); |
| } |
| |
| bool DisplayTest::waitForHotplugEvent(uint32_t id, bool connected) { |
| int waitCount = 20; |
| while (waitCount--) { |
| while (!mReceivedDisplayEvents.empty()) { |
| auto event = mReceivedDisplayEvents.front(); |
| mReceivedDisplayEvents.pop_front(); |
| |
| ALOGV_IF(event.header.type == DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG, |
| "event hotplug: id %d, connected %d\t", event.header.id, |
| event.hotplug.connected); |
| |
| if (event.header.type == DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG && |
| event.header.id == id && event.hotplug.connected == connected) { |
| return true; |
| } |
| } |
| |
| mLooper->pollOnce(1); |
| } |
| |
| return false; |
| } |
| |
| TEST_F(DisplayTest, Hotplug) { |
| ALOGD("DisplayTest::Hotplug"); |
| |
| EXPECT_CALL(*mMockComposer, getDisplayType(EXTERNAL_DISPLAY, _)) |
| .Times(2) |
| .WillRepeatedly(DoAll(SetArgPointee<1>(IComposerClient::DisplayType::PHYSICAL), |
| Return(Error::NONE))); |
| // The attribute queries will get done twice. This is for defaults |
| EXPECT_CALL(*mMockComposer, getDisplayAttribute(EXTERNAL_DISPLAY, 1, _, _)) |
| .Times(2 * 3) |
| .WillRepeatedly(Invoke(mMockComposer, &MockComposerClient::getDisplayAttributeFake)); |
| // ... and then special handling for dimensions. Specifying these |
| // rules later means that gmock will try them first, i.e., |
| // ordering of width/height vs. the default implementation for |
| // other queries is significant. |
| EXPECT_CALL(*mMockComposer, |
| getDisplayAttribute(EXTERNAL_DISPLAY, 1, IComposerClient::Attribute::WIDTH, _)) |
| .Times(2) |
| .WillRepeatedly(DoAll(SetArgPointee<3>(400), Return(Error::NONE))); |
| |
| EXPECT_CALL(*mMockComposer, |
| getDisplayAttribute(EXTERNAL_DISPLAY, 1, IComposerClient::Attribute::HEIGHT, _)) |
| .Times(2) |
| .WillRepeatedly(DoAll(SetArgPointee<3>(200), Return(Error::NONE))); |
| |
| mMockComposer->hotplugDisplay(EXTERNAL_DISPLAY, IComposerCallback::Connection::CONNECTED); |
| |
| waitForDisplayTransaction(); |
| |
| EXPECT_TRUE(waitForHotplugEvent(ISurfaceComposer::eDisplayIdHdmi, true)); |
| |
| { |
| sp<android::IBinder> display( |
| SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdHdmi)); |
| DisplayInfo info; |
| SurfaceComposerClient::getDisplayInfo(display, &info); |
| ASSERT_EQ(400u, info.w); |
| ASSERT_EQ(200u, info.h); |
| |
| auto surfaceControl = |
| mComposerClient->createSurface(String8("Display Test Surface Foo"), info.w, info.h, |
| PIXEL_FORMAT_RGBA_8888, 0); |
| ASSERT_TRUE(surfaceControl != nullptr); |
| ASSERT_TRUE(surfaceControl->isValid()); |
| fillSurfaceRGBA8(surfaceControl, BLUE); |
| |
| { |
| TransactionScope ts(*mMockComposer); |
| ts.setDisplayLayerStack(display, 0); |
| |
| ts.setLayer(surfaceControl, INT32_MAX - 2) |
| .show(surfaceControl); |
| } |
| } |
| |
| mMockComposer->hotplugDisplay(EXTERNAL_DISPLAY, IComposerCallback::Connection::DISCONNECTED); |
| |
| mMockComposer->clearFrames(); |
| |
| mMockComposer->hotplugDisplay(EXTERNAL_DISPLAY, IComposerCallback::Connection::CONNECTED); |
| |
| waitForDisplayTransaction(); |
| |
| EXPECT_TRUE(waitForHotplugEvent(ISurfaceComposer::eDisplayIdHdmi, false)); |
| EXPECT_TRUE(waitForHotplugEvent(ISurfaceComposer::eDisplayIdHdmi, true)); |
| |
| { |
| sp<android::IBinder> display( |
| SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdHdmi)); |
| DisplayInfo info; |
| SurfaceComposerClient::getDisplayInfo(display, &info); |
| ASSERT_EQ(400u, info.w); |
| ASSERT_EQ(200u, info.h); |
| |
| auto surfaceControl = |
| mComposerClient->createSurface(String8("Display Test Surface Bar"), info.w, info.h, |
| PIXEL_FORMAT_RGBA_8888, 0); |
| ASSERT_TRUE(surfaceControl != nullptr); |
| ASSERT_TRUE(surfaceControl->isValid()); |
| fillSurfaceRGBA8(surfaceControl, BLUE); |
| |
| { |
| TransactionScope ts(*mMockComposer); |
| ts.setDisplayLayerStack(display, 0); |
| |
| ts.setLayer(surfaceControl, INT32_MAX - 2) |
| .show(surfaceControl); |
| } |
| } |
| mMockComposer->hotplugDisplay(EXTERNAL_DISPLAY, IComposerCallback::Connection::DISCONNECTED); |
| } |
| |
| TEST_F(DisplayTest, HotplugPrimaryDisplay) { |
| ALOGD("DisplayTest::HotplugPrimaryDisplay"); |
| |
| mMockComposer->hotplugDisplay(PRIMARY_DISPLAY, IComposerCallback::Connection::DISCONNECTED); |
| |
| waitForDisplayTransaction(); |
| |
| EXPECT_TRUE(waitForHotplugEvent(ISurfaceComposer::eDisplayIdMain, false)); |
| |
| { |
| sp<android::IBinder> display( |
| SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain)); |
| DisplayInfo info; |
| auto result = SurfaceComposerClient::getDisplayInfo(display, &info); |
| EXPECT_NE(NO_ERROR, result); |
| } |
| |
| mMockComposer->clearFrames(); |
| |
| EXPECT_CALL(*mMockComposer, getDisplayType(PRIMARY_DISPLAY, _)) |
| .Times(2) |
| .WillRepeatedly(DoAll(SetArgPointee<1>(IComposerClient::DisplayType::PHYSICAL), |
| Return(Error::NONE))); |
| // The attribute queries will get done twice. This is for defaults |
| EXPECT_CALL(*mMockComposer, getDisplayAttribute(PRIMARY_DISPLAY, 1, _, _)) |
| .Times(2 * 3) |
| .WillRepeatedly(Invoke(mMockComposer, &MockComposerClient::getDisplayAttributeFake)); |
| // ... and then special handling for dimensions. Specifying these |
| // rules later means that gmock will try them first, i.e., |
| // ordering of width/height vs. the default implementation for |
| // other queries is significant. |
| EXPECT_CALL(*mMockComposer, |
| getDisplayAttribute(PRIMARY_DISPLAY, 1, IComposerClient::Attribute::WIDTH, _)) |
| .Times(2) |
| .WillRepeatedly(DoAll(SetArgPointee<3>(400), Return(Error::NONE))); |
| |
| EXPECT_CALL(*mMockComposer, |
| getDisplayAttribute(PRIMARY_DISPLAY, 1, IComposerClient::Attribute::HEIGHT, _)) |
| .Times(2) |
| .WillRepeatedly(DoAll(SetArgPointee<3>(200), Return(Error::NONE))); |
| |
| mMockComposer->hotplugDisplay(PRIMARY_DISPLAY, IComposerCallback::Connection::CONNECTED); |
| |
| waitForDisplayTransaction(); |
| |
| EXPECT_TRUE(waitForHotplugEvent(ISurfaceComposer::eDisplayIdMain, true)); |
| |
| { |
| sp<android::IBinder> display( |
| SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain)); |
| DisplayInfo info; |
| auto result = SurfaceComposerClient::getDisplayInfo(display, &info); |
| EXPECT_EQ(NO_ERROR, result); |
| ASSERT_EQ(400u, info.w); |
| ASSERT_EQ(200u, info.h); |
| } |
| } |
| |
| //////////////////////////////////////////////// |
| |
| class TransactionTest : public ::testing::Test { |
| protected: |
| // Layer array indexing constants. |
| constexpr static int BG_LAYER = 0; |
| constexpr static int FG_LAYER = 1; |
| |
| static void SetUpTestCase(); |
| static void TearDownTestCase(); |
| |
| void SetUp() override; |
| void TearDown() override; |
| |
| sp<SurfaceComposerClient> mComposerClient; |
| sp<SurfaceControl> mBGSurfaceControl; |
| sp<SurfaceControl> mFGSurfaceControl; |
| std::vector<RenderState> mBaseFrame; |
| uint32_t mDisplayWidth; |
| uint32_t mDisplayHeight; |
| |
| static FakeComposerClient* sFakeComposer; |
| }; |
| |
| FakeComposerClient* TransactionTest::sFakeComposer; |
| |
| void TransactionTest::SetUpTestCase() { |
| // TODO: See TODO comment at DisplayTest::SetUp for background on |
| // the lifetime of the FakeComposerClient. |
| sFakeComposer = new FakeComposerClient; |
| sp<ComposerClient> client = new ComposerClient(sFakeComposer); |
| sp<IComposer> fakeService = new FakeComposerService(client); |
| (void)fakeService->registerAsService("mock"); |
| |
| android::hardware::ProcessState::self()->startThreadPool(); |
| android::ProcessState::self()->startThreadPool(); |
| |
| startSurfaceFlinger(); |
| |
| // Fake composer wants to enable VSync injection |
| sFakeComposer->onSurfaceFlingerStart(); |
| } |
| |
| void TransactionTest::TearDownTestCase() { |
| // Fake composer needs to release SurfaceComposerClient before the stop. |
| sFakeComposer->onSurfaceFlingerStop(); |
| stopSurfaceFlinger(); |
| // TODO: This is deleted when the ComposerClient calls |
| // removeClient. Devise better lifetime control. |
| sFakeComposer = nullptr; |
| } |
| |
| void TransactionTest::SetUp() { |
| ALOGI("TransactionTest::SetUp"); |
| mComposerClient = new SurfaceComposerClient; |
| ASSERT_EQ(NO_ERROR, mComposerClient->initCheck()); |
| |
| ALOGI("TransactionTest::SetUp - display"); |
| sp<android::IBinder> display( |
| SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain)); |
| DisplayInfo info; |
| SurfaceComposerClient::getDisplayInfo(display, &info); |
| |
| mDisplayWidth = info.w; |
| mDisplayHeight = info.h; |
| |
| // Background surface |
| mBGSurfaceControl = mComposerClient->createSurface(String8("BG Test Surface"), mDisplayWidth, |
| mDisplayHeight, PIXEL_FORMAT_RGBA_8888, 0); |
| ASSERT_TRUE(mBGSurfaceControl != nullptr); |
| ASSERT_TRUE(mBGSurfaceControl->isValid()); |
| fillSurfaceRGBA8(mBGSurfaceControl, BLUE); |
| |
| // Foreground surface |
| mFGSurfaceControl = mComposerClient->createSurface(String8("FG Test Surface"), 64, 64, |
| PIXEL_FORMAT_RGBA_8888, 0); |
| ASSERT_TRUE(mFGSurfaceControl != nullptr); |
| ASSERT_TRUE(mFGSurfaceControl->isValid()); |
| |
| fillSurfaceRGBA8(mFGSurfaceControl, RED); |
| |
| Transaction t; |
| t.setDisplayLayerStack(display, 0); |
| |
| t.setLayer(mBGSurfaceControl, INT32_MAX - 2); |
| t.show(mBGSurfaceControl); |
| |
| t.setLayer(mFGSurfaceControl, INT32_MAX - 1); |
| t.setPosition(mFGSurfaceControl, 64, 64); |
| t.show(mFGSurfaceControl); |
| |
| // Synchronous transaction will stop this thread, so we set up a |
| // delayed, off-thread vsync request before closing the |
| // transaction. In the test code this is usually done with |
| // TransactionScope. Leaving here in the 'vanilla' form for |
| // reference. |
| ASSERT_EQ(0, sFakeComposer->getFrameCount()); |
| sFakeComposer->runVSyncAfter(1ms); |
| t.apply(); |
| sFakeComposer->waitUntilFrame(1); |
| |
| // Reference data. This is what the HWC should see. |
| static_assert(BG_LAYER == 0 && FG_LAYER == 1, "Unexpected enum values for array indexing"); |
| mBaseFrame.push_back(makeSimpleRect(0u, 0u, mDisplayWidth, mDisplayHeight)); |
| mBaseFrame[BG_LAYER].mSwapCount = 1; |
| mBaseFrame.push_back(makeSimpleRect(64, 64, 64 + 64, 64 + 64)); |
| mBaseFrame[FG_LAYER].mSwapCount = 1; |
| |
| auto frame = sFakeComposer->getFrameRects(0); |
| ASSERT_TRUE(framesAreSame(mBaseFrame, frame)); |
| } |
| |
| void TransactionTest::TearDown() { |
| ALOGD("TransactionTest::TearDown"); |
| |
| mComposerClient->dispose(); |
| mBGSurfaceControl = 0; |
| mFGSurfaceControl = 0; |
| mComposerClient = 0; |
| |
| sFakeComposer->runVSyncAndWait(); |
| mBaseFrame.clear(); |
| sFakeComposer->clearFrames(); |
| ASSERT_EQ(0, sFakeComposer->getFrameCount()); |
| |
| sp<ISurfaceComposer> sf(ComposerService::getComposerService()); |
| std::vector<LayerDebugInfo> layers; |
| status_t result = sf->getLayerDebugInfo(&layers); |
| if (result != NO_ERROR) { |
| ALOGE("Failed to get layers %s %d", strerror(-result), result); |
| } else { |
| // If this fails, the test being torn down leaked layers. |
| EXPECT_EQ(0u, layers.size()); |
| if (layers.size() > 0) { |
| for (auto layer = layers.begin(); layer != layers.end(); ++layer) { |
| std::cout << to_string(*layer).c_str(); |
| } |
| // To ensure the next test has clean slate, will run the class |
| // tear down and setup here. |
| TearDownTestCase(); |
| SetUpTestCase(); |
| } |
| } |
| ALOGD("TransactionTest::TearDown - complete"); |
| } |
| |
| TEST_F(TransactionTest, LayerMove) { |
| ALOGD("TransactionTest::LayerMove"); |
| |
| // The scope opens and closes a global transaction and, at the |
| // same time, makes sure the SurfaceFlinger progresses one frame |
| // after the transaction closes. The results of the transaction |
| // should be available in the latest frame stored by the fake |
| // composer. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setPosition(mFGSurfaceControl, 128, 128); |
| // NOTE: No changes yet, so vsync will do nothing, HWC does not get any calls. |
| // (How to verify that? Throw in vsync and wait a 2x frame time? Separate test?) |
| // |
| // sFakeComposer->runVSyncAndWait(); |
| } |
| |
| fillSurfaceRGBA8(mFGSurfaceControl, GREEN); |
| sFakeComposer->runVSyncAndWait(); |
| |
| ASSERT_EQ(3, sFakeComposer->getFrameCount()); // Make sure the waits didn't time out and there's |
| // no extra frames. |
| |
| // NOTE: Frame 0 is produced in the SetUp. |
| auto frame1Ref = mBaseFrame; |
| frame1Ref[FG_LAYER].mDisplayFrame = |
| hwc_rect_t{128, 128, 128 + 64, 128 + 64}; // Top-most layer moves. |
| EXPECT_TRUE(framesAreSame(frame1Ref, sFakeComposer->getFrameRects(1))); |
| |
| auto frame2Ref = frame1Ref; |
| frame2Ref[FG_LAYER].mSwapCount++; |
| EXPECT_TRUE(framesAreSame(frame2Ref, sFakeComposer->getFrameRects(2))); |
| } |
| |
| TEST_F(TransactionTest, LayerResize) { |
| ALOGD("TransactionTest::LayerResize"); |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| } |
| |
| fillSurfaceRGBA8(mFGSurfaceControl, GREEN); |
| sFakeComposer->runVSyncAndWait(); |
| |
| ASSERT_EQ(3, sFakeComposer->getFrameCount()); // Make sure the waits didn't time out and there's |
| // no extra frames. |
| |
| auto frame1Ref = mBaseFrame; |
| // NOTE: The resize should not be visible for frame 1 as there's no buffer with new size posted. |
| EXPECT_TRUE(framesAreSame(frame1Ref, sFakeComposer->getFrameRects(1))); |
| |
| auto frame2Ref = frame1Ref; |
| frame2Ref[FG_LAYER].mSwapCount++; |
| frame2Ref[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 128, 64 + 128}; |
| frame2Ref[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 128.f, 128.f}; |
| EXPECT_TRUE(framesAreSame(frame2Ref, sFakeComposer->getFrameRects(2))); |
| } |
| |
| TEST_F(TransactionTest, LayerCrop) { |
| // TODO: Add scaling to confirm that crop happens in buffer space? |
| { |
| TransactionScope ts(*sFakeComposer); |
| Rect cropRect(16, 16, 32, 32); |
| ts.setCrop(mFGSurfaceControl, cropRect); |
| } |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mSourceCrop = hwc_frect_t{16.f, 16.f, 32.f, 32.f}; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{64 + 16, 64 + 16, 64 + 32, 64 + 32}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, LayerFinalCrop) { |
| // TODO: Add scaling to confirm that crop happens in display space? |
| { |
| TransactionScope ts(*sFakeComposer); |
| Rect cropRect(32, 32, 32 + 64, 32 + 64); |
| ts.setFinalCrop(mFGSurfaceControl, cropRect); |
| } |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| |
| // In display space we are cropping with [32, 32, 96, 96] against display rect |
| // [64, 64, 128, 128]. Should yield display rect [64, 64, 96, 96] |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 32.f, 32.f}; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 32, 64 + 32}; |
| |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, LayerFinalCropEmpty) { |
| // TODO: Add scaling to confirm that crop happens in display space? |
| { |
| TransactionScope ts(*sFakeComposer); |
| Rect cropRect(16, 16, 32, 32); |
| ts.setFinalCrop(mFGSurfaceControl, cropRect); |
| } |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| |
| // In display space we are cropping with [16, 16, 32, 32] against display rect |
| // [64, 64, 128, 128]. The intersection is empty and only the background layer is composited. |
| std::vector<RenderState> referenceFrame(1); |
| referenceFrame[BG_LAYER] = mBaseFrame[BG_LAYER]; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, LayerSetLayer) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setLayer(mFGSurfaceControl, INT_MAX - 3); |
| } |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| |
| // The layers will switch order, but both are rendered because the background layer is |
| // transparent (RGBA8888). |
| std::vector<RenderState> referenceFrame(2); |
| referenceFrame[0] = mBaseFrame[FG_LAYER]; |
| referenceFrame[1] = mBaseFrame[BG_LAYER]; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, LayerSetLayerOpaque) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setLayer(mFGSurfaceControl, INT_MAX - 3); |
| ts.setFlags(mBGSurfaceControl, layer_state_t::eLayerOpaque, |
| layer_state_t::eLayerOpaque); |
| } |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| |
| // The former foreground layer is now covered with opaque layer - it should have disappeared |
| std::vector<RenderState> referenceFrame(1); |
| referenceFrame[BG_LAYER] = mBaseFrame[BG_LAYER]; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, SetLayerStack) { |
| ALOGD("TransactionTest::SetLayerStack"); |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setLayerStack(mFGSurfaceControl, 1); |
| } |
| |
| // Foreground layer should have disappeared. |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| std::vector<RenderState> refFrame(1); |
| refFrame[BG_LAYER] = mBaseFrame[BG_LAYER]; |
| EXPECT_TRUE(framesAreSame(refFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, LayerShowHide) { |
| ALOGD("TransactionTest::LayerShowHide"); |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.hide(mFGSurfaceControl); |
| } |
| |
| // Foreground layer should have disappeared. |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| std::vector<RenderState> refFrame(1); |
| refFrame[BG_LAYER] = mBaseFrame[BG_LAYER]; |
| EXPECT_TRUE(framesAreSame(refFrame, sFakeComposer->getLatestFrame())); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mFGSurfaceControl); |
| } |
| |
| // Foreground layer should be back |
| ASSERT_EQ(3, sFakeComposer->getFrameCount()); |
| EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, LayerSetAlpha) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setAlpha(mFGSurfaceControl, 0.75f); |
| } |
| |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mPlaneAlpha = 0.75f; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, LayerSetFlags) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setFlags(mFGSurfaceControl, layer_state_t::eLayerHidden, |
| layer_state_t::eLayerHidden); |
| } |
| |
| // Foreground layer should have disappeared. |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| std::vector<RenderState> refFrame(1); |
| refFrame[BG_LAYER] = mBaseFrame[BG_LAYER]; |
| EXPECT_TRUE(framesAreSame(refFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, LayerSetMatrix) { |
| struct matrixTestData { |
| float matrix[4]; |
| hwc_transform_t expectedTransform; |
| hwc_rect_t expectedDisplayFrame; |
| }; |
| |
| // The matrix operates on the display frame and is applied before |
| // the position is added. So, the foreground layer rect is (0, 0, |
| // 64, 64) is first transformed, potentially yielding negative |
| // coordinates and then the position (64, 64) is added yielding |
| // the final on-screen rectangles given. |
| |
| const matrixTestData MATRIX_TESTS[7] = // clang-format off |
| {{{-1.f, 0.f, 0.f, 1.f}, HWC_TRANSFORM_FLIP_H, {0, 64, 64, 128}}, |
| {{1.f, 0.f, 0.f, -1.f}, HWC_TRANSFORM_FLIP_V, {64, 0, 128, 64}}, |
| {{0.f, 1.f, -1.f, 0.f}, HWC_TRANSFORM_ROT_90, {0, 64, 64, 128}}, |
| {{-1.f, 0.f, 0.f, -1.f}, HWC_TRANSFORM_ROT_180, {0, 0, 64, 64}}, |
| {{0.f, -1.f, 1.f, 0.f}, HWC_TRANSFORM_ROT_270, {64, 0, 128, 64}}, |
| {{0.f, 1.f, 1.f, 0.f}, HWC_TRANSFORM_FLIP_H_ROT_90, {64, 64, 128, 128}}, |
| {{0.f, 1.f, 1.f, 0.f}, HWC_TRANSFORM_FLIP_V_ROT_90, {64, 64, 128, 128}}}; |
| // clang-format on |
| constexpr int TEST_COUNT = sizeof(MATRIX_TESTS) / sizeof(matrixTestData); |
| |
| for (int i = 0; i < TEST_COUNT; i++) { |
| // TODO: How to leverage the HWC2 stringifiers? |
| const matrixTestData& xform = MATRIX_TESTS[i]; |
| SCOPED_TRACE(i); |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setMatrix(mFGSurfaceControl, xform.matrix[0], xform.matrix[1], |
| xform.matrix[2], xform.matrix[3]); |
| } |
| |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mTransform = xform.expectedTransform; |
| referenceFrame[FG_LAYER].mDisplayFrame = xform.expectedDisplayFrame; |
| |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| } |
| |
| #if 0 |
| TEST_F(TransactionTest, LayerSetMatrix2) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| // TODO: PLEASE SPEC THE FUNCTION! |
| ts.setMatrix(mFGSurfaceControl, 0.11f, 0.123f, |
| -2.33f, 0.22f); |
| } |
| auto referenceFrame = mBaseFrame; |
| // TODO: Is this correct for sure? |
| //referenceFrame[FG_LAYER].mTransform = HWC_TRANSFORM_FLIP_V & HWC_TRANSFORM_ROT_90; |
| |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| #endif |
| |
| TEST_F(TransactionTest, DeferredTransaction) { |
| // Synchronization surface |
| constexpr static int SYNC_LAYER = 2; |
| auto syncSurfaceControl = mComposerClient->createSurface(String8("Sync Test Surface"), 1, 1, |
| PIXEL_FORMAT_RGBA_8888, 0); |
| ASSERT_TRUE(syncSurfaceControl != nullptr); |
| ASSERT_TRUE(syncSurfaceControl->isValid()); |
| |
| fillSurfaceRGBA8(syncSurfaceControl, DARK_GRAY); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setLayer(syncSurfaceControl, INT32_MAX - 1); |
| ts.setPosition(syncSurfaceControl, mDisplayWidth - 2, mDisplayHeight - 2); |
| ts.show(syncSurfaceControl); |
| } |
| auto referenceFrame = mBaseFrame; |
| referenceFrame.push_back(makeSimpleRect(mDisplayWidth - 2, mDisplayHeight - 2, |
| mDisplayWidth - 1, mDisplayHeight - 1)); |
| referenceFrame[SYNC_LAYER].mSwapCount = 1; |
| EXPECT_EQ(2, sFakeComposer->getFrameCount()); |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| // set up two deferred transactions on different frames - these should not yield composited |
| // frames |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setAlpha(mFGSurfaceControl, 0.75); |
| ts.deferTransactionUntil(mFGSurfaceControl, |
| syncSurfaceControl->getHandle(), |
| syncSurfaceControl->getSurface()->getNextFrameNumber()); |
| } |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setPosition(mFGSurfaceControl, 128, 128); |
| ts.deferTransactionUntil(mFGSurfaceControl, |
| syncSurfaceControl->getHandle(), |
| syncSurfaceControl->getSurface()->getNextFrameNumber() + 1); |
| } |
| EXPECT_EQ(4, sFakeComposer->getFrameCount()); |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| // should trigger the first deferred transaction, but not the second one |
| fillSurfaceRGBA8(syncSurfaceControl, DARK_GRAY); |
| sFakeComposer->runVSyncAndWait(); |
| EXPECT_EQ(5, sFakeComposer->getFrameCount()); |
| |
| referenceFrame[FG_LAYER].mPlaneAlpha = 0.75f; |
| referenceFrame[SYNC_LAYER].mSwapCount++; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| // should show up immediately since it's not deferred |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setAlpha(mFGSurfaceControl, 1.0); |
| } |
| referenceFrame[FG_LAYER].mPlaneAlpha = 1.f; |
| EXPECT_EQ(6, sFakeComposer->getFrameCount()); |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| // trigger the second deferred transaction |
| fillSurfaceRGBA8(syncSurfaceControl, DARK_GRAY); |
| sFakeComposer->runVSyncAndWait(); |
| // TODO: Compute from layer size? |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{128, 128, 128 + 64, 128 + 64}; |
| referenceFrame[SYNC_LAYER].mSwapCount++; |
| EXPECT_EQ(7, sFakeComposer->getFrameCount()); |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(TransactionTest, SetRelativeLayer) { |
| constexpr int RELATIVE_LAYER = 2; |
| auto relativeSurfaceControl = mComposerClient->createSurface(String8("Test Surface"), 64, 64, |
| PIXEL_FORMAT_RGBA_8888, 0); |
| fillSurfaceRGBA8(relativeSurfaceControl, LIGHT_RED); |
| |
| // Now we stack the surface above the foreground surface and make sure it is visible. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setPosition(relativeSurfaceControl, 64, 64); |
| ts.show(relativeSurfaceControl); |
| ts.setRelativeLayer(relativeSurfaceControl, mFGSurfaceControl->getHandle(), 1); |
| } |
| auto referenceFrame = mBaseFrame; |
| // NOTE: All three layers will be visible as the surfaces are |
| // transparent because of the RGBA format. |
| referenceFrame.push_back(makeSimpleRect(64, 64, 64 + 64, 64 + 64)); |
| referenceFrame[RELATIVE_LAYER].mSwapCount = 1; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| // A call to setLayer will override a call to setRelativeLayer |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setLayer(relativeSurfaceControl, 0); |
| } |
| |
| // Previous top layer will now appear at the bottom. |
| auto referenceFrame2 = mBaseFrame; |
| referenceFrame2.insert(referenceFrame2.begin(), referenceFrame[RELATIVE_LAYER]); |
| EXPECT_EQ(3, sFakeComposer->getFrameCount()); |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| } |
| |
| class ChildLayerTest : public TransactionTest { |
| protected: |
| constexpr static int CHILD_LAYER = 2; |
| |
| void SetUp() override { |
| TransactionTest::SetUp(); |
| mChild = mComposerClient->createSurface(String8("Child surface"), 10, 10, |
| PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get()); |
| fillSurfaceRGBA8(mChild, LIGHT_GRAY); |
| |
| sFakeComposer->runVSyncAndWait(); |
| mBaseFrame.push_back(makeSimpleRect(64, 64, 64 + 10, 64 + 10)); |
| mBaseFrame[CHILD_LAYER].mSwapCount = 1; |
| ASSERT_EQ(2, sFakeComposer->getFrameCount()); |
| ASSERT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); |
| } |
| void TearDown() override { |
| mChild = 0; |
| TransactionTest::TearDown(); |
| } |
| |
| sp<SurfaceControl> mChild; |
| }; |
| |
| TEST_F(ChildLayerTest, Positioning) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mChild, 10, 10); |
| // Move to the same position as in the original setup. |
| ts.setPosition(mFGSurfaceControl, 64, 64); |
| } |
| |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = |
| hwc_rect_t{64 + 10, 64 + 10, 64 + 10 + 10, 64 + 10 + 10}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setPosition(mFGSurfaceControl, 0, 0); |
| } |
| |
| auto referenceFrame2 = mBaseFrame; |
| referenceFrame2[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 64, 0 + 64}; |
| referenceFrame2[CHILD_LAYER].mDisplayFrame = |
| hwc_rect_t{0 + 10, 0 + 10, 0 + 10 + 10, 0 + 10 + 10}; |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, Cropping) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mChild, 0, 0); |
| ts.setPosition(mFGSurfaceControl, 0, 0); |
| ts.setCrop(mFGSurfaceControl, Rect(0, 0, 5, 5)); |
| } |
| // NOTE: The foreground surface would be occluded by the child |
| // now, but is included in the stack because the child is |
| // transparent. |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 5, 0 + 5}; |
| referenceFrame[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 5.f, 5.f}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 5, 0 + 5}; |
| referenceFrame[CHILD_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 5.f, 5.f}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, FinalCropping) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mChild, 0, 0); |
| ts.setPosition(mFGSurfaceControl, 0, 0); |
| ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, 5, 5)); |
| } |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 5, 0 + 5}; |
| referenceFrame[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 5.f, 5.f}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 5, 0 + 5}; |
| referenceFrame[CHILD_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 5.f, 5.f}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, Constraints) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mFGSurfaceControl, 0, 0); |
| ts.setPosition(mChild, 63, 63); |
| } |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{63, 63, 64, 64}; |
| referenceFrame[CHILD_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 1.f, 1.f}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, Scaling) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setPosition(mFGSurfaceControl, 0, 0); |
| } |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 10, 10}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setMatrix(mFGSurfaceControl, 2.0, 0, 0, 2.0); |
| } |
| |
| auto referenceFrame2 = mBaseFrame; |
| referenceFrame2[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 128, 128}; |
| referenceFrame2[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 20, 20}; |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, LayerAlpha) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mChild, 0, 0); |
| ts.setPosition(mFGSurfaceControl, 0, 0); |
| ts.setAlpha(mChild, 0.5); |
| } |
| |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 10, 10}; |
| referenceFrame[CHILD_LAYER].mPlaneAlpha = 0.5f; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setAlpha(mFGSurfaceControl, 0.5); |
| } |
| |
| auto referenceFrame2 = referenceFrame; |
| referenceFrame2[FG_LAYER].mPlaneAlpha = 0.5f; |
| referenceFrame2[CHILD_LAYER].mPlaneAlpha = 0.25f; |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, ReparentChildren) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mChild, 10, 10); |
| ts.setPosition(mFGSurfaceControl, 64, 64); |
| } |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = |
| hwc_rect_t{64 + 10, 64 + 10, 64 + 10 + 10, 64 + 10 + 10}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.reparentChildren(mFGSurfaceControl, mBGSurfaceControl->getHandle()); |
| } |
| |
| auto referenceFrame2 = referenceFrame; |
| referenceFrame2[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64}; |
| referenceFrame2[CHILD_LAYER].mDisplayFrame = hwc_rect_t{10, 10, 10 + 10, 10 + 10}; |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, DetachChildren) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mChild, 10, 10); |
| ts.setPosition(mFGSurfaceControl, 64, 64); |
| } |
| |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = |
| hwc_rect_t{64 + 10, 64 + 10, 64 + 10 + 10, 64 + 10 + 10}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.detachChildren(mFGSurfaceControl); |
| } |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.hide(mChild); |
| } |
| |
| // Nothing should have changed. The child control becomes a no-op |
| // zombie on detach. See comments for detachChildren in the |
| // SurfaceControl.h file. |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, InheritNonTransformScalingFromParent) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mChild, 0, 0); |
| ts.setPosition(mFGSurfaceControl, 0, 0); |
| } |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setOverrideScalingMode(mFGSurfaceControl, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); |
| // We cause scaling by 2. |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| } |
| |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 128, 128}; |
| referenceFrame[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 64.f, 64.f}; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 20, 20}; |
| referenceFrame[CHILD_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 10.f, 10.f}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| // Regression test for b/37673612 |
| TEST_F(ChildLayerTest, ChildrenWithParentBufferTransform) { |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.show(mChild); |
| ts.setPosition(mChild, 0, 0); |
| ts.setPosition(mFGSurfaceControl, 0, 0); |
| } |
| |
| // We set things up as in b/37673612 so that there is a mismatch between the buffer size and |
| // the WM specified state size. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 64); |
| } |
| |
| sp<Surface> s = mFGSurfaceControl->getSurface(); |
| auto anw = static_cast<ANativeWindow*>(s.get()); |
| native_window_set_buffers_transform(anw, NATIVE_WINDOW_TRANSFORM_ROT_90); |
| native_window_set_buffers_dimensions(anw, 64, 128); |
| fillSurfaceRGBA8(mFGSurfaceControl, RED); |
| sFakeComposer->runVSyncAndWait(); |
| |
| // The child should still be in the same place and not have any strange scaling as in |
| // b/37673612. |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 128, 64}; |
| referenceFrame[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 64.f, 128.f}; |
| referenceFrame[FG_LAYER].mSwapCount++; |
| referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 10, 10}; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(ChildLayerTest, Bug36858924) { |
| // Destroy the child layer |
| mChild.clear(); |
| |
| // Now recreate it as hidden |
| mChild = mComposerClient->createSurface(String8("Child surface"), 10, 10, |
| PIXEL_FORMAT_RGBA_8888, ISurfaceComposerClient::eHidden, |
| mFGSurfaceControl.get()); |
| |
| // Show the child layer in a deferred transaction |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.deferTransactionUntil(mChild, mFGSurfaceControl->getHandle(), |
| mFGSurfaceControl->getSurface()->getNextFrameNumber()); |
| ts.show(mChild); |
| } |
| |
| // Render the foreground surface a few times |
| // |
| // Prior to the bugfix for b/36858924, this would usually hang while trying to fill the third |
| // frame because SurfaceFlinger would never process the deferred transaction and would therefore |
| // never acquire/release the first buffer |
| ALOGI("Filling 1"); |
| fillSurfaceRGBA8(mFGSurfaceControl, GREEN); |
| sFakeComposer->runVSyncAndWait(); |
| ALOGI("Filling 2"); |
| fillSurfaceRGBA8(mFGSurfaceControl, BLUE); |
| sFakeComposer->runVSyncAndWait(); |
| ALOGI("Filling 3"); |
| fillSurfaceRGBA8(mFGSurfaceControl, RED); |
| sFakeComposer->runVSyncAndWait(); |
| ALOGI("Filling 4"); |
| fillSurfaceRGBA8(mFGSurfaceControl, GREEN); |
| sFakeComposer->runVSyncAndWait(); |
| } |
| |
| class LatchingTest : public TransactionTest { |
| protected: |
| void lockAndFillFGBuffer() { fillSurfaceRGBA8(mFGSurfaceControl, RED, false); } |
| |
| void unlockFGBuffer() { |
| sp<Surface> s = mFGSurfaceControl->getSurface(); |
| ASSERT_EQ(NO_ERROR, s->unlockAndPost()); |
| sFakeComposer->runVSyncAndWait(); |
| } |
| |
| void completeFGResize() { |
| fillSurfaceRGBA8(mFGSurfaceControl, RED); |
| sFakeComposer->runVSyncAndWait(); |
| } |
| void restoreInitialState() { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 64, 64); |
| ts.setPosition(mFGSurfaceControl, 64, 64); |
| ts.setCrop(mFGSurfaceControl, Rect(0, 0, 64, 64)); |
| ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1)); |
| } |
| }; |
| |
| TEST_F(LatchingTest, SurfacePositionLatching) { |
| // By default position can be updated even while |
| // a resize is pending. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 32, 32); |
| ts.setPosition(mFGSurfaceControl, 100, 100); |
| } |
| |
| // The size should not have updated as we have not provided a new buffer. |
| auto referenceFrame1 = mBaseFrame; |
| referenceFrame1[FG_LAYER].mDisplayFrame = hwc_rect_t{100, 100, 100 + 64, 100 + 64}; |
| EXPECT_TRUE(framesAreSame(referenceFrame1, sFakeComposer->getLatestFrame())); |
| |
| restoreInitialState(); |
| |
| // Now we repeat with setGeometryAppliesWithResize |
| // and verify the position DOESN'T latch. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setGeometryAppliesWithResize(mFGSurfaceControl); |
| ts.setSize(mFGSurfaceControl, 32, 32); |
| ts.setPosition(mFGSurfaceControl, 100, 100); |
| } |
| EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); |
| |
| completeFGResize(); |
| |
| auto referenceFrame2 = mBaseFrame; |
| referenceFrame2[FG_LAYER].mDisplayFrame = hwc_rect_t{100, 100, 100 + 32, 100 + 32}; |
| referenceFrame2[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 32.f, 32.f}; |
| referenceFrame2[FG_LAYER].mSwapCount++; |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(LatchingTest, CropLatching) { |
| // Normally the crop applies immediately even while a resize is pending. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| ts.setCrop(mFGSurfaceControl, Rect(0, 0, 63, 63)); |
| } |
| |
| auto referenceFrame1 = mBaseFrame; |
| referenceFrame1[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 63, 64 + 63}; |
| referenceFrame1[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 63.f, 63.f}; |
| EXPECT_TRUE(framesAreSame(referenceFrame1, sFakeComposer->getLatestFrame())); |
| |
| restoreInitialState(); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| ts.setGeometryAppliesWithResize(mFGSurfaceControl); |
| ts.setCrop(mFGSurfaceControl, Rect(0, 0, 63, 63)); |
| } |
| EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); |
| |
| completeFGResize(); |
| |
| auto referenceFrame2 = mBaseFrame; |
| referenceFrame2[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 63, 64 + 63}; |
| referenceFrame2[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 63.f, 63.f}; |
| referenceFrame2[FG_LAYER].mSwapCount++; |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(LatchingTest, FinalCropLatching) { |
| // Normally the crop applies immediately even while a resize is pending. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); |
| } |
| |
| auto referenceFrame1 = mBaseFrame; |
| referenceFrame1[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 127, 127}; |
| referenceFrame1[FG_LAYER].mSourceCrop = |
| hwc_frect_t{0.f, 0.f, static_cast<float>(127 - 64), static_cast<float>(127 - 64)}; |
| EXPECT_TRUE(framesAreSame(referenceFrame1, sFakeComposer->getLatestFrame())); |
| |
| restoreInitialState(); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| ts.setGeometryAppliesWithResize(mFGSurfaceControl); |
| ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); |
| } |
| EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); |
| |
| completeFGResize(); |
| |
| auto referenceFrame2 = mBaseFrame; |
| referenceFrame2[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 127, 127}; |
| referenceFrame2[FG_LAYER].mSourceCrop = |
| hwc_frect_t{0.f, 0.f, static_cast<float>(127 - 64), static_cast<float>(127 - 64)}; |
| referenceFrame2[FG_LAYER].mSwapCount++; |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| } |
| |
| // In this test we ensure that setGeometryAppliesWithResize actually demands |
| // a buffer of the new size, and not just any size. |
| TEST_F(LatchingTest, FinalCropLatchingBufferOldSize) { |
| // Normally the crop applies immediately even while a resize is pending. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); |
| } |
| |
| auto referenceFrame1 = mBaseFrame; |
| referenceFrame1[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 127, 127}; |
| referenceFrame1[FG_LAYER].mSourceCrop = |
| hwc_frect_t{0.f, 0.f, static_cast<float>(127 - 64), static_cast<float>(127 - 64)}; |
| EXPECT_TRUE(framesAreSame(referenceFrame1, sFakeComposer->getLatestFrame())); |
| |
| restoreInitialState(); |
| |
| // In order to prepare to submit a buffer at the wrong size, we acquire it prior to |
| // initiating the resize. |
| lockAndFillFGBuffer(); |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| ts.setGeometryAppliesWithResize(mFGSurfaceControl); |
| ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); |
| } |
| EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); |
| |
| // We now submit our old buffer, at the old size, and ensure it doesn't |
| // trigger geometry latching. |
| unlockFGBuffer(); |
| |
| auto referenceFrame2 = mBaseFrame; |
| referenceFrame2[FG_LAYER].mSwapCount++; |
| EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame())); |
| |
| completeFGResize(); |
| auto referenceFrame3 = referenceFrame2; |
| referenceFrame3[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 127, 127}; |
| referenceFrame3[FG_LAYER].mSourceCrop = |
| hwc_frect_t{0.f, 0.f, static_cast<float>(127 - 64), static_cast<float>(127 - 64)}; |
| referenceFrame3[FG_LAYER].mSwapCount++; |
| EXPECT_TRUE(framesAreSame(referenceFrame3, sFakeComposer->getLatestFrame())); |
| } |
| |
| TEST_F(LatchingTest, FinalCropLatchingRegressionForb37531386) { |
| // In this scenario, we attempt to set the final crop a second time while the resize |
| // is still pending, and ensure we are successful. Success meaning the second crop |
| // is the one which eventually latches and not the first. |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setSize(mFGSurfaceControl, 128, 128); |
| ts.setGeometryAppliesWithResize(mFGSurfaceControl); |
| ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); |
| } |
| |
| { |
| TransactionScope ts(*sFakeComposer); |
| ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1)); |
| } |
| EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); |
| |
| completeFGResize(); |
| |
| auto referenceFrame = mBaseFrame; |
| referenceFrame[FG_LAYER].mSwapCount++; |
| EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); |
| } |
| |
| } // namespace |
| |
| int main(int argc, char** argv) { |
| ::testing::InitGoogleTest(&argc, argv); |
| |
| sftest::FakeHwcEnvironment* fakeEnvironment = new sftest::FakeHwcEnvironment; |
| ::testing::AddGlobalTestEnvironment(fakeEnvironment); |
| ::testing::InitGoogleMock(&argc, argv); |
| return RUN_ALL_TESTS(); |
| } |
