blob: 19eaa198db42442fa6f9396f92b5da85b63a1008 [file] [log] [blame]
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001/*
2 * Copyright 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
Alec Mouria90a5702021-04-16 16:36:21 +000018#include "renderengine/ExternalTexture.h"
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080019#pragma clang diagnostic push
20#pragma clang diagnostic ignored "-Wconversion"
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010021#pragma clang diagnostic ignored "-Wextra"
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080022
Lloyd Piqued6b579f2018-04-06 15:29:10 -070023#undef LOG_TAG
24#define LOG_TAG "CompositionTest"
25
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080026#include <compositionengine/Display.h>
Lloyd Pique542307f2018-10-19 13:24:08 -070027#include <compositionengine/mock/DisplaySurface.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070028#include <gmock/gmock.h>
29#include <gtest/gtest.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070030#include <gui/IProducerListener.h>
Evan Roskya1f1e152019-01-24 16:17:46 -080031#include <gui/LayerMetadata.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070032#include <log/log.h>
Vishnu Nairdbbe3852022-01-12 20:22:11 -080033#include <renderengine/mock/FakeExternalTexture.h>
Lloyd Pique3823e7b2018-10-18 16:58:10 -070034#include <renderengine/mock/Framebuffer.h>
35#include <renderengine/mock/Image.h>
36#include <renderengine/mock/RenderEngine.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070037#include <system/window.h>
38#include <utils/String8.h>
39
Garfield Tande619fa2020-10-02 17:13:53 -070040#include "ContainerLayer.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +020041#include "DisplayRenderArea.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080042#include "EffectLayer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070043#include "Layer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070044#include "TestableSurfaceFlinger.h"
45#include "mock/DisplayHardware/MockComposer.h"
Lloyd Pique9370a482019-10-03 17:58:30 -070046#include "mock/DisplayHardware/MockPowerAdvisor.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070047#include "mock/MockEventThread.h"
Alec Mourie4034bb2019-11-19 12:45:54 -080048#include "mock/MockTimeStats.h"
Ady Abraham8cb21882020-08-26 18:22:05 -070049#include "mock/MockVsyncController.h"
Alec Mouriba013fa2018-10-16 12:43:11 -070050#include "mock/system/window/MockNativeWindow.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070051
52namespace android {
53namespace {
54
Peiyong Line9d809e2020-04-14 13:10:48 -070055namespace hal = android::hardware::graphics::composer::hal;
56
Peiyong Lin65248e02020-04-18 21:15:07 -070057using hal::Error;
58using hal::IComposer;
59using hal::IComposerClient;
60using hal::PowerMode;
61using hal::Transform;
62
Ady Abrahamde549d42022-01-26 19:19:17 -080063using aidl::android::hardware::graphics::composer3::Capability;
64
Lloyd Piqued6b579f2018-04-06 15:29:10 -070065using testing::_;
David Sodman15094112018-10-11 09:39:37 -070066using testing::AtLeast;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070067using testing::DoAll;
68using testing::IsNull;
69using testing::Mock;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070070using testing::Return;
71using testing::ReturnRef;
72using testing::SetArgPointee;
73
Lloyd Piqued6b579f2018-04-06 15:29:10 -070074using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
75using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;
76
Peiyong Line9d809e2020-04-14 13:10:48 -070077constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DISPLAY_ID;
78constexpr hal::HWLayerId HWC_LAYER = 5000;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070079constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0);
80
Dominik Laskowskif1833852021-03-23 15:06:50 -070081constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(42u);
Lloyd Piqued6b579f2018-04-06 15:29:10 -070082constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
83constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
84
Lloyd Piqued6b579f2018-04-06 15:29:10 -070085constexpr int DEFAULT_TEXTURE_ID = 6000;
Dominik Laskowski29fa1462021-04-27 15:51:50 -070086constexpr ui::LayerStack LAYER_STACK{7000u};
Lloyd Piqued6b579f2018-04-06 15:29:10 -070087
88constexpr int DEFAULT_DISPLAY_MAX_LUMINANCE = 500;
89
90constexpr int DEFAULT_SIDEBAND_STREAM = 51;
91
Ady Abrahamdc011a92021-12-21 14:06:44 -080092MATCHER(IsIdentityMatrix, "") {
93 constexpr auto kIdentity = mat4();
94 return (mat4(arg) == kIdentity);
95}
96
Lloyd Piqued6b579f2018-04-06 15:29:10 -070097class CompositionTest : public testing::Test {
98public:
99 CompositionTest() {
100 const ::testing::TestInfo* const test_info =
101 ::testing::UnitTest::GetInstance()->current_test_info();
102 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
103
Ana Krulecafb45842019-02-13 13:33:03 -0800104 setupScheduler();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700105
Alec Mourif6fd29e2018-11-17 04:56:41 +0000106 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
107 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
108 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
109 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700110
111 mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
Alec Mourie4034bb2019-11-19 12:45:54 -0800112 mFlinger.setupTimeStats(std::shared_ptr<TimeStats>(mTimeStats));
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800113
114 mComposer = new Hwc2::mock::Composer();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000115 mPowerAdvisor = new Hwc2::mock::PowerAdvisor();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800116 mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
Xiang Wang839fe5b2022-04-04 17:39:38 +0000117 mFlinger.setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor>(mPowerAdvisor));
Garfield Tan9c9c1912021-07-19 12:02:16 -0700118 mFlinger.mutableMaxRenderTargetSize() = 16384;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700119 }
120
121 ~CompositionTest() {
122 const ::testing::TestInfo* const test_info =
123 ::testing::UnitTest::GetInstance()->current_test_info();
124 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
125 }
126
Ana Krulecafb45842019-02-13 13:33:03 -0800127 void setupScheduler() {
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700128 auto eventThread = std::make_unique<mock::EventThread>();
129 auto sfEventThread = std::make_unique<mock::EventThread>();
Ana Krulecafb45842019-02-13 13:33:03 -0800130
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700131 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
Dominik Laskowski98041832019-08-01 18:35:59 -0700132 EXPECT_CALL(*eventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -0700133 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
134 ResyncCallback())));
Dominik Laskowski98041832019-08-01 18:35:59 -0700135
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700136 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
Dominik Laskowski98041832019-08-01 18:35:59 -0700137 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -0700138 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
139 ResyncCallback())));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700140
Ady Abraham8cb21882020-08-26 18:22:05 -0700141 auto vsyncController = std::make_unique<mock::VsyncController>();
142 auto vsyncTracker = std::make_unique<mock::VSyncTracker>();
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700143
Ady Abraham8cb21882020-08-26 18:22:05 -0700144 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
145 EXPECT_CALL(*vsyncTracker, currentPeriod())
Marin Shalamanov045b7002021-01-07 16:56:24 +0100146 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Ady Abraham8cb21882020-08-26 18:22:05 -0700147 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700148
Ady Abraham8cb21882020-08-26 18:22:05 -0700149 mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800150 std::move(eventThread), std::move(sfEventThread),
151 TestableSurfaceFlinger::SchedulerCallbackImpl::kNoOp,
152 TestableSurfaceFlinger::kTwoDisplayModes);
Ana Krulecafb45842019-02-13 13:33:03 -0800153 }
154
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700155 void setupForceGeometryDirty() {
156 // TODO: This requires the visible region and other related
157 // state to be set, and is problematic for BufferLayers since they are
158 // not visible without a buffer (and setting up a buffer looks like a
159 // pain)
160 // mFlinger.mutableVisibleRegionsDirty() = true;
161
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700162 mFlinger.mutableGeometryDirty() = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700163 }
164
165 template <typename Case>
166 void displayRefreshCompositionDirtyGeometry();
167
168 template <typename Case>
169 void displayRefreshCompositionDirtyFrame();
170
171 template <typename Case>
172 void captureScreenComposition();
173
Ady Abrahamde549d42022-01-26 19:19:17 -0800174 std::unordered_set<Capability> mDefaultCapabilities = {Capability::SIDEBAND_STREAM};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700175
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800176 bool mDisplayOff = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700177 TestableSurfaceFlinger mFlinger;
178 sp<DisplayDevice> mDisplay;
179 sp<DisplayDevice> mExternalDisplay;
Lloyd Pique542307f2018-10-19 13:24:08 -0700180 sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
181 new compositionengine::mock::DisplaySurface();
Alec Mouriba013fa2018-10-16 12:43:11 -0700182 mock::NativeWindow* mNativeWindow = new mock::NativeWindow();
Garfield Tande619fa2020-10-02 17:13:53 -0700183 std::vector<sp<Layer>> mAuxiliaryLayers;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700184
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800185 sp<GraphicBuffer> mBuffer = new GraphicBuffer();
186 ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();
187
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700188 Hwc2::mock::Composer* mComposer = nullptr;
189 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
Alec Mourie4034bb2019-11-19 12:45:54 -0800190 mock::TimeStats* mTimeStats = new mock::TimeStats();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000191 Hwc2::mock::PowerAdvisor* mPowerAdvisor = nullptr;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700192
193 sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;
194
Alec Mouria90a5702021-04-16 16:36:21 +0000195 std::shared_ptr<renderengine::ExternalTexture> mCaptureScreenBuffer;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700196};
197
198template <typename LayerCase>
199void CompositionTest::displayRefreshCompositionDirtyGeometry() {
200 setupForceGeometryDirty();
201 LayerCase::setupForDirtyGeometry(this);
202
203 // --------------------------------------------------------------------
204 // Invocation
205
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700206 mFlinger.commitAndComposite();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700207
208 LayerCase::cleanup(this);
209}
210
211template <typename LayerCase>
212void CompositionTest::displayRefreshCompositionDirtyFrame() {
213 LayerCase::setupForDirtyFrame(this);
214
215 // --------------------------------------------------------------------
216 // Invocation
217
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700218 mFlinger.commitAndComposite();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700219
220 LayerCase::cleanup(this);
221}
222
223template <typename LayerCase>
224void CompositionTest::captureScreenComposition() {
225 LayerCase::setupForScreenCapture(this);
226
227 const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700228 constexpr bool forSystem = true;
Lucas Dupin9d763b72020-04-20 18:42:31 -0700229 constexpr bool regionSampling = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700230
Marin Shalamanov1c434292020-06-12 01:47:29 +0200231 auto renderArea = DisplayRenderArea::create(mDisplay, sourceCrop, sourceCrop.getSize(),
232 ui::Dataspace::V0_SRGB, ui::Transform::ROT_0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700233
234 auto traverseLayers = [this](const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700235 return mFlinger.traverseLayersInLayerStack(mDisplay->getLayerStack(),
236 CaptureArgs::UNSET_UID, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700237 };
238
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700239 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
240 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800241 mCaptureScreenBuffer =
242 std::make_shared<renderengine::mock::FakeExternalTexture>(renderArea->getReqWidth(),
243 renderArea->getReqHeight(),
244 HAL_PIXEL_FORMAT_RGBA_8888, 1,
245 usage);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700246
Dominik Laskowskibb448ce2022-05-07 15:52:55 -0700247 auto future = mFlinger.renderScreenImpl(*renderArea, traverseLayers, mCaptureScreenBuffer,
Robert Carr12a3b9b2022-03-10 09:55:29 -0800248 forSystem, regionSampling);
Dominik Laskowskibb448ce2022-05-07 15:52:55 -0700249 ASSERT_TRUE(future.valid());
250 const auto fenceResult = future.get();
Sally Qi59a9f502021-10-12 18:53:23 +0000251
Dominik Laskowskibb448ce2022-05-07 15:52:55 -0700252 EXPECT_EQ(NO_ERROR, fenceStatus(fenceResult));
253 if (fenceResult.ok()) {
254 fenceResult.value()->waitForever(LOG_TAG);
Sally Qi59a9f502021-10-12 18:53:23 +0000255 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700256
257 LayerCase::cleanup(this);
258}
259
Sally Qi4cabdd02021-08-05 16:45:57 -0700260template <class T>
261std::future<T> futureOf(T obj) {
262 std::promise<T> resultPromise;
263 std::future<T> resultFuture = resultPromise.get_future();
264 resultPromise.set_value(std::move(obj));
265 return resultFuture;
266}
267
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700268/* ------------------------------------------------------------------------
269 * Variants for each display configuration which can be tested
270 */
271
272template <typename Derived>
273struct BaseDisplayVariant {
274 static constexpr bool IS_SECURE = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700275 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700276
277 static void setupPreconditions(CompositionTest* test) {
Peiyong Lin65248e02020-04-18 21:15:07 -0700278 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700279 .WillOnce(Return(Error::NONE));
Alec Mouriba013fa2018-10-16 12:43:11 -0700280
Peiyong Line9d809e2020-04-14 13:10:48 -0700281 FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700282 .setCapabilities(&test->mDefaultCapabilities)
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700283 .setPowerMode(Derived::INIT_POWER_MODE)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700284 .inject(&test->mFlinger, test->mComposer);
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800285 Mock::VerifyAndClear(test->mComposer);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700286
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800287 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
288 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
289 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
290 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
291 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
292 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
293 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
Lloyd Pique9370a482019-10-03 17:58:30 -0700294
295 const ::testing::TestInfo* const test_info =
296 ::testing::UnitTest::GetInstance()->current_test_info();
297
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800298 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
299 .setId(DEFAULT_DISPLAY_ID)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800300 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
301 .setIsSecure(Derived::IS_SECURE)
Xiang Wang839fe5b2022-04-04 17:39:38 +0000302 .setPowerAdvisor(test->mPowerAdvisor)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800303 .setName(std::string("Injected display for ") +
304 test_info->test_case_name() + "." + test_info->name())
305 .build();
Lloyd Pique9370a482019-10-03 17:58:30 -0700306
307 auto compositionDisplay =
308 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
309 ceDisplayArgs);
310
Marin Shalamanov700e6392020-02-12 20:22:26 +0100311 test->mDisplay = FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100312 ui::DisplayConnectionType::Internal, HWC_DISPLAY,
Marin Shalamanov700e6392020-02-12 20:22:26 +0100313 true /* isPrimary */)
314 .setDisplaySurface(test->mDisplaySurface)
315 .setNativeWindow(test->mNativeWindow)
316 .setSecure(Derived::IS_SECURE)
317 .setPowerMode(Derived::INIT_POWER_MODE)
318 .inject();
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800319 Mock::VerifyAndClear(test->mNativeWindow);
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700320 test->mDisplay->setLayerStack(LAYER_STACK);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700321 }
322
323 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700324 static void setupPreconditionCallExpectations(CompositionTest* test) {
325 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500326 .WillOnce(DoAll(SetArgPointee<1>(
327 std::vector<aidl::android::hardware::graphics::composer3::
328 DisplayCapability>({})),
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700329 Return(Error::NONE)));
330 }
331
332 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700333 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
Ady Abrahamdc011a92021-12-21 14:06:44 -0800334 EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700335 EXPECT_CALL(*test->mComposer, getDisplayRequests(HWC_DISPLAY, _, _, _)).Times(1);
336 EXPECT_CALL(*test->mComposer, acceptDisplayChanges(HWC_DISPLAY)).Times(1);
337 EXPECT_CALL(*test->mComposer, presentDisplay(HWC_DISPLAY, _)).Times(1);
338 EXPECT_CALL(*test->mComposer, getReleaseFences(HWC_DISPLAY, _, _)).Times(1);
339
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700340 EXPECT_CALL(*test->mDisplaySurface, onFrameCommitted()).Times(1);
341 EXPECT_CALL(*test->mDisplaySurface, advanceFrame()).Times(1);
342
343 Case::CompositionType::setupHwcSetCallExpectations(test);
344 Case::CompositionType::setupHwcGetCallExpectations(test);
345 }
346
347 template <typename Case>
348 static void setupCommonScreensCaptureCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000349 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700350 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000351 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -0700352 const std::shared_ptr<renderengine::ExternalTexture>&,
Sally Qi59a9f502021-10-12 18:53:23 +0000353 const bool, base::unique_fd&&)
Sally Qi4cabdd02021-08-05 16:45:57 -0700354 -> std::future<renderengine::RenderEngineResult> {
Lloyd Pique9370a482019-10-03 17:58:30 -0700355 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
356 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
357 displaySettings.physicalDisplay);
358 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
359 displaySettings.clip);
Sally Qi4cabdd02021-08-05 16:45:57 -0700360 return futureOf<renderengine::RenderEngineResult>(
361 {NO_ERROR, base::unique_fd()});
Lloyd Pique9370a482019-10-03 17:58:30 -0700362 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700363 }
364
365 static void setupNonEmptyFrameCompositionCallExpectations(CompositionTest* test) {
366 EXPECT_CALL(*test->mDisplaySurface, beginFrame(true)).Times(1);
367 }
368
369 static void setupEmptyFrameCompositionCallExpectations(CompositionTest* test) {
370 EXPECT_CALL(*test->mDisplaySurface, beginFrame(false)).Times(1);
371 }
372
373 static void setupHwcCompositionCallExpectations(CompositionTest* test) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800374 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _))
375 .Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800376
Lloyd Pique542307f2018-10-19 13:24:08 -0700377 EXPECT_CALL(*test->mDisplaySurface,
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700378 prepareFrame(compositionengine::DisplaySurface::CompositionType::Hwc))
Lloyd Pique542307f2018-10-19 13:24:08 -0700379 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700380 }
381
Lloyd Pique66d68602019-02-13 14:23:31 -0800382 static void setupHwcClientCompositionCallExpectations(CompositionTest* test) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800383 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _))
384 .Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800385 }
386
387 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800388 EXPECT_CALL(*test->mComposer, validateDisplay(HWC_DISPLAY, _, _, _)).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800389 }
390
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700391 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Pique542307f2018-10-19 13:24:08 -0700392 EXPECT_CALL(*test->mDisplaySurface,
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700393 prepareFrame(compositionengine::DisplaySurface::CompositionType::Gpu))
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700394 .Times(1);
395 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
396 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
397
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800398 EXPECT_CALL(*test->mNativeWindow, queueBuffer(_, _)).WillOnce(Return(0));
399 EXPECT_CALL(*test->mNativeWindow, dequeueBuffer(_, _))
400 .WillOnce(DoAll(SetArgPointee<0>(test->mNativeWindowBuffer), SetArgPointee<1>(-1),
401 Return(0)));
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000402 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700403 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000404 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -0700405 const std::shared_ptr<renderengine::ExternalTexture>&,
Sally Qi59a9f502021-10-12 18:53:23 +0000406 const bool, base::unique_fd&&)
Sally Qi4cabdd02021-08-05 16:45:57 -0700407 -> std::future<renderengine::RenderEngineResult> {
Lloyd Pique9370a482019-10-03 17:58:30 -0700408 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
409 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
410 displaySettings.physicalDisplay);
411 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
412 displaySettings.clip);
413 EXPECT_EQ(ui::Dataspace::UNKNOWN, displaySettings.outputDataspace);
Sally Qi4cabdd02021-08-05 16:45:57 -0700414 return futureOf<renderengine::RenderEngineResult>(
415 {NO_ERROR, base::unique_fd()});
Lloyd Pique9370a482019-10-03 17:58:30 -0700416 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700417 }
418
419 template <typename Case>
420 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
421 Case::Layer::setupRECompositionCallExpectations(test);
422 }
423
424 template <typename Case>
425 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
426 Case::Layer::setupREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700427 }
428};
429
430struct DefaultDisplaySetupVariant : public BaseDisplayVariant<DefaultDisplaySetupVariant> {};
431
432struct InsecureDisplaySetupVariant : public BaseDisplayVariant<InsecureDisplaySetupVariant> {
433 static constexpr bool IS_SECURE = false;
434
435 template <typename Case>
436 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
437 Case::Layer::setupInsecureRECompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700438 }
439
440 template <typename Case>
441 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
442 Case::Layer::setupInsecureREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700443 }
444};
445
446struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDisplaySetupVariant> {
Peiyong Lin65248e02020-04-18 21:15:07 -0700447 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::OFF;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700448
449 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700450 static void setupPreconditionCallExpectations(CompositionTest*) {}
451
452 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700453 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
454 // TODO: This seems like an unnecessary call if display is powered off.
Ady Abrahamdc011a92021-12-21 14:06:44 -0800455 EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700456
457 // TODO: This seems like an unnecessary call if display is powered off.
458 Case::CompositionType::setupHwcSetCallExpectations(test);
459 }
460
461 static void setupHwcCompositionCallExpectations(CompositionTest*) {}
Lloyd Pique66d68602019-02-13 14:23:31 -0800462 static void setupHwcClientCompositionCallExpectations(CompositionTest*) {}
463 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest*) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700464
465 static void setupRECompositionCallExpectations(CompositionTest* test) {
466 // TODO: This seems like an unnecessary call if display is powered off.
467 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
468 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
469 }
470
471 template <typename Case>
472 static void setupRELayerCompositionCallExpectations(CompositionTest*) {}
473};
474
475/* ------------------------------------------------------------------------
476 * Variants for each layer configuration which can be tested
477 */
478
479template <typename LayerProperties>
480struct BaseLayerProperties {
481 static constexpr uint32_t WIDTH = 100;
482 static constexpr uint32_t HEIGHT = 100;
483 static constexpr PixelFormat FORMAT = PIXEL_FORMAT_RGBA_8888;
484 static constexpr uint64_t USAGE =
485 GraphicBuffer::USAGE_SW_READ_NEVER | GraphicBuffer::USAGE_SW_WRITE_NEVER;
486 static constexpr android_dataspace DATASPACE = HAL_DATASPACE_UNKNOWN;
487 static constexpr uint32_t SCALING_MODE = 0;
488 static constexpr uint32_t TRANSFORM = 0;
489 static constexpr uint32_t LAYER_FLAGS = 0;
490 static constexpr float COLOR[] = {1.f, 1.f, 1.f, 1.f};
491 static constexpr IComposerClient::BlendMode BLENDMODE =
492 IComposerClient::BlendMode::PREMULTIPLIED;
493
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000494 static void setupLatchedBuffer(CompositionTest* test, sp<BufferStateLayer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700495 Mock::VerifyAndClear(test->mRenderEngine);
496
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000497 const auto buffer = std::make_shared<
498 renderengine::mock::FakeExternalTexture>(LayerProperties::WIDTH,
499 LayerProperties::HEIGHT,
500 DEFAULT_TEXTURE_ID,
501 LayerProperties::FORMAT,
502 LayerProperties::USAGE |
503 GraphicBuffer::USAGE_HW_TEXTURE);
504
505 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
506 layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
507 layerDrawingState.buffer = buffer;
508 layerDrawingState.acquireFence = Fence::NO_FENCE;
509 layerDrawingState.dataspace = ui::Dataspace::UNKNOWN;
510 layer->setSurfaceDamageRegion(
511 Region(Rect(LayerProperties::HEIGHT, LayerProperties::WIDTH)));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700512
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700513 bool ignoredRecomputeVisibleRegions;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700514 layer->latchBuffer(ignoredRecomputeVisibleRegions, 0, 0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700515 Mock::VerifyAndClear(test->mRenderEngine);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700516 }
517
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000518 static void setupLayerState(CompositionTest* test, sp<BufferStateLayer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700519 setupLatchedBuffer(test, layer);
520 }
521
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700522 static void setupHwcSetGeometryCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800523 if (!test->mDisplayOff) {
524 // TODO: Coverage of other values
525 EXPECT_CALL(*test->mComposer,
526 setLayerBlendMode(HWC_DISPLAY, HWC_LAYER, LayerProperties::BLENDMODE))
527 .Times(1);
528 // TODO: Coverage of other values for origin
529 EXPECT_CALL(*test->mComposer,
530 setLayerDisplayFrame(HWC_DISPLAY, HWC_LAYER,
531 IComposerClient::Rect({0, 0, LayerProperties::WIDTH,
532 LayerProperties::HEIGHT})))
533 .Times(1);
534 EXPECT_CALL(*test->mComposer,
535 setLayerPlaneAlpha(HWC_DISPLAY, HWC_LAYER, LayerProperties::COLOR[3]))
536 .Times(1);
537 // TODO: Coverage of other values
538 EXPECT_CALL(*test->mComposer, setLayerZOrder(HWC_DISPLAY, HWC_LAYER, 0u)).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700539
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800540 // These expectations retire on saturation as the code path these
541 // expectations are for appears to make an extra call to them.
542 // TODO: Investigate this extra call
543 EXPECT_CALL(*test->mComposer,
544 setLayerTransform(HWC_DISPLAY, HWC_LAYER, DEFAULT_TRANSFORM))
545 .Times(AtLeast(1))
546 .RetiresOnSaturation();
547 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700548 }
549
550 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800551 if (!test->mDisplayOff) {
552 EXPECT_CALL(*test->mComposer,
553 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
554 IComposerClient::FRect({0.f, 0.f, LayerProperties::WIDTH,
555 LayerProperties::HEIGHT})))
556 .Times(1);
557 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700558 }
559
560 static void setupHwcSetSourceCropColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800561 if (!test->mDisplayOff) {
562 EXPECT_CALL(*test->mComposer,
563 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
564 IComposerClient::FRect({0.f, 0.f, 0.f, 0.f})))
565 .Times(1);
566 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700567 }
568
569 static void setupHwcSetPerFrameCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800570 if (!test->mDisplayOff) {
571 EXPECT_CALL(*test->mComposer,
572 setLayerVisibleRegion(HWC_DISPLAY, HWC_LAYER,
573 std::vector<IComposerClient::Rect>(
574 {IComposerClient::Rect(
575 {0, 0, LayerProperties::WIDTH,
576 LayerProperties::HEIGHT})})))
577 .Times(1);
578 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700579 }
580
581 static void setupHwcSetPerFrameColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800582 if (!test->mDisplayOff) {
583 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
584 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700585
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800586 // TODO: use COLOR
587 EXPECT_CALL(*test->mComposer,
588 setLayerColor(HWC_DISPLAY, HWC_LAYER,
Ady Abraham6e60b142022-01-06 18:10:35 -0800589 aidl::android::hardware::graphics::composer3::Color(
590 {1.0f, 1.0f, 1.0f, 1.0f})))
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800591 .Times(1);
592 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700593 }
594
595 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800596 if (!test->mDisplayOff) {
597 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
598 .Times(1);
599 EXPECT_CALL(*test->mComposer, setLayerBuffer(HWC_DISPLAY, HWC_LAYER, _, _, _)).Times(1);
600 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700601 }
602
603 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000604 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700605 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000606 const std::vector<renderengine::LayerSettings>& layerSettings,
Sally Qi4cabdd02021-08-05 16:45:57 -0700607 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +0000608 base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000609 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
610 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
611 displaySettings.physicalDisplay);
612 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
613 displaySettings.clip);
614 // screen capture adds an additional color layer as an alpha
615 // prefill, so gtet the back layer.
Sally Qi4cabdd02021-08-05 16:45:57 -0700616 std::future<renderengine::RenderEngineResult> resultFuture =
617 futureOf<renderengine::RenderEngineResult>(
618 {NO_ERROR, base::unique_fd()});
Lloyd Piquea2468662019-03-07 21:31:06 -0800619 if (layerSettings.empty()) {
620 ADD_FAILURE() << "layerSettings was not expected to be empty in "
621 "setupREBufferCompositionCommonCallExpectations "
622 "verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700623 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800624 }
Sally Qi59a9f502021-10-12 18:53:23 +0000625 const renderengine::LayerSettings layer = layerSettings.back();
626 EXPECT_THAT(layer.source.buffer.buffer, Not(IsNull()));
627 EXPECT_THAT(layer.source.buffer.fence, Not(IsNull()));
628 EXPECT_EQ(DEFAULT_TEXTURE_ID, layer.source.buffer.textureName);
629 EXPECT_EQ(false, layer.source.buffer.isY410BT2020);
630 EXPECT_EQ(true, layer.source.buffer.usePremultipliedAlpha);
631 EXPECT_EQ(false, layer.source.buffer.isOpaque);
632 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius);
633 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
634 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700635 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000636 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700637 }
638
639 static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
640 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700641 }
642
643 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
644 setupREBufferCompositionCallExpectations(test);
645 }
646
647 static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
648 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
649 }
650
651 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
652 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
653 }
654
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700655 static void setupREColorCompositionCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000656 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700657 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000658 const std::vector<renderengine::LayerSettings>& layerSettings,
Sally Qi4cabdd02021-08-05 16:45:57 -0700659 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +0000660 base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000661 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
662 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
663 displaySettings.physicalDisplay);
664 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
665 displaySettings.clip);
666 // screen capture adds an additional color layer as an alpha
667 // prefill, so get the back layer.
Sally Qi4cabdd02021-08-05 16:45:57 -0700668 std::future<renderengine::RenderEngineResult> resultFuture =
669 futureOf<renderengine::RenderEngineResult>(
670 {NO_ERROR, base::unique_fd()});
Lloyd Piquea2468662019-03-07 21:31:06 -0800671 if (layerSettings.empty()) {
672 ADD_FAILURE()
673 << "layerSettings was not expected to be empty in "
674 "setupREColorCompositionCallExpectations verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700675 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800676 }
Sally Qi59a9f502021-10-12 18:53:23 +0000677 const renderengine::LayerSettings layer = layerSettings.back();
678 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000679 EXPECT_EQ(half3(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
680 LayerProperties::COLOR[2]),
Sally Qi59a9f502021-10-12 18:53:23 +0000681 layer.source.solidColor);
682 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius);
683 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
684 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700685 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000686 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700687 }
688
689 static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
690 setupREColorCompositionCallExpectations(test);
691 }
692};
693
694struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
695
Vishnu Nairfa247b12020-02-11 08:58:26 -0800696struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
Alec Mourida8a9d12020-01-30 20:00:31 -0800697 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
698};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700699
700struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
701 using Base = BaseLayerProperties<SidebandLayerProperties>;
702 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
703
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000704 static void setupLayerState(CompositionTest* test, sp<BufferStateLayer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700705 sp<NativeHandle> stream =
706 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
707 false);
708 test->mFlinger.setLayerSidebandStream(layer, stream);
709 }
710
711 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
712 EXPECT_CALL(*test->mComposer,
713 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
714 IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
715 .Times(1);
716 }
717
718 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
719 EXPECT_CALL(*test->mComposer,
720 setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
721 reinterpret_cast<native_handle_t*>(
722 DEFAULT_SIDEBAND_STREAM)))
723 .WillOnce(Return(Error::NONE));
724
725 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
726 }
727
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000728 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700729};
730
Garfield Tande619fa2020-10-02 17:13:53 -0700731template <typename LayerProperties>
732struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
733 using Base = BaseLayerProperties<LayerProperties>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700734
735 static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000736 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700737 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000738 const std::vector<renderengine::LayerSettings>& layerSettings,
Sally Qi4cabdd02021-08-05 16:45:57 -0700739 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +0000740 base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000741 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
742 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
743 displaySettings.physicalDisplay);
744 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
745 displaySettings.clip);
746 // screen capture adds an additional color layer as an alpha
747 // prefill, so get the back layer.
Sally Qi4cabdd02021-08-05 16:45:57 -0700748 std::future<renderengine::RenderEngineResult> resultFuture =
749 futureOf<renderengine::RenderEngineResult>(
750 {NO_ERROR, base::unique_fd()});
Lloyd Piquea2468662019-03-07 21:31:06 -0800751 if (layerSettings.empty()) {
752 ADD_FAILURE() << "layerSettings was not expected to be empty in "
753 "setupInsecureREBufferCompositionCommonCallExpectations "
754 "verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700755 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800756 }
Sally Qi59a9f502021-10-12 18:53:23 +0000757 const renderengine::LayerSettings layer = layerSettings.back();
758 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
759 EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer.source.solidColor);
760 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius);
761 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
762 EXPECT_EQ(1.0f, layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700763 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000764 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700765 }
766
767 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
768 setupInsecureREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700769 }
770
771 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
772 setupInsecureREBufferCompositionCommonCallExpectations(test);
773 }
774};
775
Garfield Tande619fa2020-10-02 17:13:53 -0700776struct ParentSecureLayerProperties
777 : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
778
779struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
780 static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
781};
782
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700783struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
784 using Base = BaseLayerProperties<CursorLayerProperties>;
785
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000786 static void setupLayerState(CompositionTest* test, sp<BufferStateLayer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700787 Base::setupLayerState(test, layer);
788 test->mFlinger.setLayerPotentialCursor(layer, true);
789 }
790};
791
792struct NoLayerVariant {
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000793 using FlingerLayerType = sp<BufferStateLayer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700794
795 static FlingerLayerType createLayer(CompositionTest*) { return FlingerLayerType(); }
796 static void injectLayer(CompositionTest*, FlingerLayerType) {}
797 static void cleanupInjectedLayers(CompositionTest*) {}
798
799 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
800 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
801};
802
803template <typename LayerProperties>
804struct BaseLayerVariant {
805 template <typename L, typename F>
806 static sp<L> createLayerWithFactory(CompositionTest* test, F factory) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700807 EXPECT_CALL(*test->mFlinger.scheduler(), postMessage(_)).Times(0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700808
809 sp<L> layer = factory();
810
Dominik Laskowski49cea512019-11-12 14:13:23 -0800811 // Layer should be registered with scheduler.
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700812 EXPECT_EQ(1u, test->mFlinger.scheduler()->layerHistorySize());
Dominik Laskowski49cea512019-11-12 14:13:23 -0800813
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700814 Mock::VerifyAndClear(test->mComposer);
815 Mock::VerifyAndClear(test->mRenderEngine);
Dominik Laskowski756b7892021-08-04 12:53:59 -0700816 Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700817
Garfield Tande619fa2020-10-02 17:13:53 -0700818 initLayerDrawingStateAndComputeBounds(test, layer);
819
820 return layer;
821 }
822
823 template <typename L>
824 static void initLayerDrawingStateAndComputeBounds(CompositionTest* test, sp<L> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700825 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700826 layerDrawingState.layerStack = LAYER_STACK;
chaviw766c9c52021-02-10 17:36:47 -0800827 layerDrawingState.width = 100;
828 layerDrawingState.height = 100;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700829 layerDrawingState.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
830 LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700831 layer->computeBounds(FloatRect(0, 0, 100, 100), ui::Transform(), 0.f /* shadowRadius */);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700832 }
833
834 static void injectLayer(CompositionTest* test, sp<Layer> layer) {
835 EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
836 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
837
Lloyd Piquede196652020-01-22 17:29:58 -0800838 auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
839 layer->getCompositionEngineLayerFE());
Lloyd Pique01c77c12019-04-17 12:48:32 -0700840 outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
841 outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700842
843 Mock::VerifyAndClear(test->mComposer);
844
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700845 test->mFlinger.mutableDrawingState().layersSortedByZ.add(layer);
846 }
847
848 static void cleanupInjectedLayers(CompositionTest* test) {
849 EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
850 .WillOnce(Return(Error::NONE));
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800851
Lloyd Pique01c77c12019-04-17 12:48:32 -0700852 test->mDisplay->getCompositionDisplay()->clearOutputLayers();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700853 test->mFlinger.mutableDrawingState().layersSortedByZ.clear();
Dominik Laskowski49cea512019-11-12 14:13:23 -0800854
855 // Layer should be unregistered with scheduler.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700856 test->mFlinger.commit();
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700857 EXPECT_EQ(0u, test->mFlinger.scheduler()->layerHistorySize());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700858 }
859};
860
861template <typename LayerProperties>
Vishnu Nairfa247b12020-02-11 08:58:26 -0800862struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700863 using Base = BaseLayerVariant<LayerProperties>;
Vishnu Nairfa247b12020-02-11 08:58:26 -0800864 using FlingerLayerType = sp<EffectLayer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700865
866 static FlingerLayerType createLayer(CompositionTest* test) {
Vishnu Nairfa247b12020-02-11 08:58:26 -0800867 FlingerLayerType layer = Base::template createLayerWithFactory<EffectLayer>(test, [test]() {
868 return new EffectLayer(
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700869 LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Vishnu Nairfa247b12020-02-11 08:58:26 -0800870 LayerProperties::LAYER_FLAGS, LayerMetadata()));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700871 });
Vishnu Nair60356342018-11-13 13:00:45 -0800872
873 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
chaviw25714502021-02-11 10:01:08 -0800874 layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700875 return layer;
876 }
877
878 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700879 LayerProperties::setupREColorCompositionCallExpectations(test);
880 }
881
882 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
883 LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
884 }
885
886 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
887 LayerProperties::setupHwcSetGeometryCallExpectations(test);
888 LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
889 }
890
891 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
892 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
893 LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
894 }
895};
896
897template <typename LayerProperties>
898struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
899 using Base = BaseLayerVariant<LayerProperties>;
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000900 using FlingerLayerType = sp<BufferStateLayer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700901
902 static FlingerLayerType createLayer(CompositionTest* test) {
903 test->mFlinger.mutableTexturePool().push_back(DEFAULT_TEXTURE_ID);
904
905 FlingerLayerType layer =
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000906 Base::template createLayerWithFactory<BufferStateLayer>(test, [test]() {
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700907 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700908 LayerProperties::LAYER_FLAGS, LayerMetadata());
chaviwb4c6e582019-08-16 14:35:07 -0700909 args.textureName = test->mFlinger.mutableTexturePool().back();
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000910 return new BufferStateLayer(args);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700911 });
912
913 LayerProperties::setupLayerState(test, layer);
914
915 return layer;
916 }
917
918 static void cleanupInjectedLayers(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700919 Base::cleanupInjectedLayers(test);
920 }
921
922 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
923 LayerProperties::setupHwcSetGeometryCallExpectations(test);
924 LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
925 }
926
927 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
928 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
929 LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
930 }
931
932 static void setupRECompositionCallExpectations(CompositionTest* test) {
933 LayerProperties::setupREBufferCompositionCallExpectations(test);
934 }
935
936 static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
937 LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
938 }
939
940 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
941 LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
942 }
943
944 static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
945 LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
946 }
947};
948
Garfield Tande619fa2020-10-02 17:13:53 -0700949template <typename LayerProperties>
950struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
951 using Base = BaseLayerVariant<LayerProperties>;
952 using FlingerLayerType = sp<ContainerLayer>;
953
954 static FlingerLayerType createLayer(CompositionTest* test) {
955 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
Garfield Tande619fa2020-10-02 17:13:53 -0700956 LayerProperties::LAYER_FLAGS, LayerMetadata());
957 FlingerLayerType layer = new ContainerLayer(args);
958 Base::template initLayerDrawingStateAndComputeBounds(test, layer);
959 return layer;
960 }
961};
962
963template <typename LayerVariant, typename ParentLayerVariant>
964struct ChildLayerVariant : public LayerVariant {
965 using Base = LayerVariant;
966 using FlingerLayerType = typename LayerVariant::FlingerLayerType;
967 using ParentBase = ParentLayerVariant;
968
969 static FlingerLayerType createLayer(CompositionTest* test) {
970 // Need to create child layer first. Otherwise layer history size will be 2.
971 FlingerLayerType layer = Base::createLayer(test);
972
973 typename ParentBase::FlingerLayerType parentLayer = ParentBase::createLayer(test);
974 parentLayer->addChild(layer);
975 test->mFlinger.setLayerDrawingParent(layer, parentLayer);
976
977 test->mAuxiliaryLayers.push_back(parentLayer);
978
979 return layer;
980 }
981
982 static void cleanupInjectedLayers(CompositionTest* test) {
983 // Clear auxiliary layers first so that child layer can be successfully destroyed in the
984 // following call.
985 test->mAuxiliaryLayers.clear();
986
987 Base::cleanupInjectedLayers(test);
988 }
989};
990
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700991/* ------------------------------------------------------------------------
992 * Variants to control how the composition type is changed
993 */
994
995struct NoCompositionTypeVariant {
996 static void setupHwcSetCallExpectations(CompositionTest*) {}
997
998 static void setupHwcGetCallExpectations(CompositionTest* test) {
999 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1000 }
1001};
1002
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001003template <aidl::android::hardware::graphics::composer3::Composition CompositionType>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001004struct KeepCompositionTypeVariant {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001005 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
1006 CompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001007
1008 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001009 if (!test->mDisplayOff) {
1010 EXPECT_CALL(*test->mComposer,
1011 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
1012 .Times(1);
1013 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001014 }
1015
1016 static void setupHwcGetCallExpectations(CompositionTest* test) {
1017 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1018 }
1019};
1020
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001021template <aidl::android::hardware::graphics::composer3::Composition InitialCompositionType,
1022 aidl::android::hardware::graphics::composer3::Composition FinalCompositionType>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001023struct ChangeCompositionTypeVariant {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001024 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
1025 FinalCompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001026
1027 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001028 if (!test->mDisplayOff) {
1029 EXPECT_CALL(*test->mComposer,
1030 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
1031 .Times(1);
1032 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001033 }
1034
1035 static void setupHwcGetCallExpectations(CompositionTest* test) {
1036 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
1037 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
1038 static_cast<Hwc2::Layer>(HWC_LAYER)}),
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001039 SetArgPointee<2>(
1040 std::vector<aidl::android::hardware::graphics::composer3::
1041 Composition>{FinalCompositionType}),
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001042 Return(Error::NONE)));
1043 }
1044};
1045
1046/* ------------------------------------------------------------------------
1047 * Variants to select how the composition is expected to be handled
1048 */
1049
1050struct CompositionResultBaseVariant {
1051 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1052
1053 template <typename Case>
1054 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
1055 Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1056 }
1057
1058 template <typename Case>
1059 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1060 Case::Layer::setupCallExpectationsForDirtyFrame(test);
1061 }
1062};
1063
1064struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1065 template <typename Case>
1066 static void setupCallExpectations(CompositionTest* test) {
1067 Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1068 Case::Display::setupHwcCompositionCallExpectations(test);
1069 }
1070};
1071
1072struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1073 template <typename Case>
1074 static void setupCallExpectations(CompositionTest* test) {
1075 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1076 Case::Display::setupHwcCompositionCallExpectations(test);
1077 }
1078};
1079
1080struct RECompositionResultVariant : public CompositionResultBaseVariant {
1081 template <typename Case>
1082 static void setupCallExpectations(CompositionTest* test) {
1083 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
Lloyd Pique66d68602019-02-13 14:23:31 -08001084 Case::Display::setupHwcClientCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001085 Case::Display::setupRECompositionCallExpectations(test);
1086 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1087 }
1088};
1089
Lloyd Pique66d68602019-02-13 14:23:31 -08001090struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001091 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001092 const auto outputLayer =
1093 TestableSurfaceFlinger::findOutputLayerForDisplay(layer, test->mDisplay);
Lloyd Piquef5275482019-01-29 18:42:42 -08001094 LOG_FATAL_IF(!outputLayer);
1095 outputLayer->editState().forceClientComposition = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001096 }
1097
1098 template <typename Case>
Lloyd Pique66d68602019-02-13 14:23:31 -08001099 static void setupCallExpectations(CompositionTest* test) {
1100 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1101 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1102 Case::Display::setupRECompositionCallExpectations(test);
1103 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1104 }
1105
1106 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001107 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1108
1109 template <typename Case>
1110 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1111};
1112
Lloyd Pique4fe29402019-08-12 16:51:24 -07001113struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
1114 static void setupLayerState(CompositionTest* test, sp<Layer>) {
1115 test->mFlinger.mutableDebugDisableHWC() = true;
1116 }
1117
1118 template <typename Case>
1119 static void setupCallExpectations(CompositionTest* test) {
1120 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1121 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1122 Case::Display::setupRECompositionCallExpectations(test);
1123 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1124 }
1125
1126 template <typename Case>
1127 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1128
1129 template <typename Case>
1130 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1131};
1132
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001133struct EmptyScreenshotResultVariant {
1134 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1135
1136 template <typename Case>
1137 static void setupCallExpectations(CompositionTest*) {}
1138};
1139
1140struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1141 using Base = EmptyScreenshotResultVariant;
1142
1143 template <typename Case>
1144 static void setupCallExpectations(CompositionTest* test) {
1145 Base::template setupCallExpectations<Case>(test);
1146 Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1147 }
1148};
1149
1150/* ------------------------------------------------------------------------
1151 * Composition test case, containing all the variants being tested
1152 */
1153
1154template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1155 typename CompositionResultCase>
1156struct CompositionCase {
1157 using ThisCase =
1158 CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1159 using Display = DisplayCase;
1160 using Layer = LayerCase;
1161 using CompositionType = CompositionTypeCase;
1162 using CompositionResult = CompositionResultCase;
1163
1164 static void setupCommon(CompositionTest* test) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -07001165 Display::template setupPreconditionCallExpectations<ThisCase>(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001166 Display::setupPreconditions(test);
1167
1168 auto layer = Layer::createLayer(test);
1169 Layer::injectLayer(test, layer);
1170 CompositionResult::setupLayerState(test, layer);
1171 }
1172
1173 static void setupForDirtyGeometry(CompositionTest* test) {
1174 setupCommon(test);
1175
1176 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1177 CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1178 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1179 CompositionResult::template setupCallExpectations<ThisCase>(test);
1180 }
1181
1182 static void setupForDirtyFrame(CompositionTest* test) {
1183 setupCommon(test);
1184
1185 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1186 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1187 CompositionResult::template setupCallExpectations<ThisCase>(test);
1188 }
1189
1190 static void setupForScreenCapture(CompositionTest* test) {
1191 setupCommon(test);
1192
1193 Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1194 CompositionResult::template setupCallExpectations<ThisCase>(test);
1195 }
1196
1197 static void cleanup(CompositionTest* test) {
1198 Layer::cleanupInjectedLayers(test);
1199
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001200 for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1201 static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1202 ->mutableLayers()
1203 .clear();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001204 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001205 }
1206};
1207
1208/* ------------------------------------------------------------------------
1209 * Composition cases to test
1210 */
1211
1212TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1213 displayRefreshCompositionDirtyGeometry<
1214 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1215 NoCompositionResultVariant>>();
1216}
1217
1218TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1219 displayRefreshCompositionDirtyFrame<
1220 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1221 NoCompositionResultVariant>>();
1222}
1223
1224TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1225 captureScreenComposition<
1226 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1227 EmptyScreenshotResultVariant>>();
1228}
1229
1230/* ------------------------------------------------------------------------
1231 * Simple buffer layers
1232 */
1233
1234TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001235 displayRefreshCompositionDirtyGeometry<CompositionCase<
1236 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1237 KeepCompositionTypeVariant<
1238 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1239 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001240}
1241
1242TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001243 displayRefreshCompositionDirtyFrame<CompositionCase<
1244 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1245 KeepCompositionTypeVariant<
1246 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1247 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001248}
1249
1250TEST_F(CompositionTest, REComposedNormalBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001251 displayRefreshCompositionDirtyFrame<CompositionCase<
1252 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1253 ChangeCompositionTypeVariant<
1254 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1255 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1256 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001257}
1258
1259TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1260 captureScreenComposition<
1261 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1262 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1263}
1264
1265/* ------------------------------------------------------------------------
1266 * Single-color layers
1267 */
1268
Vishnu Nairfa247b12020-02-11 08:58:26 -08001269TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001270 displayRefreshCompositionDirtyGeometry<CompositionCase<
1271 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1272 KeepCompositionTypeVariant<
1273 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1274 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001275}
1276
Vishnu Nairfa247b12020-02-11 08:58:26 -08001277TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001278 displayRefreshCompositionDirtyFrame<CompositionCase<
1279 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1280 KeepCompositionTypeVariant<
1281 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1282 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001283}
1284
Vishnu Nairfa247b12020-02-11 08:58:26 -08001285TEST_F(CompositionTest, REComposedEffectLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001286 displayRefreshCompositionDirtyFrame<CompositionCase<
1287 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1288 ChangeCompositionTypeVariant<
1289 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR,
1290 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1291 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001292}
1293
Vishnu Nairfa247b12020-02-11 08:58:26 -08001294TEST_F(CompositionTest, captureScreenEffectLayer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001295 captureScreenComposition<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001296 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001297 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1298}
1299
1300/* ------------------------------------------------------------------------
1301 * Layers with sideband buffers
1302 */
1303
1304TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001305 displayRefreshCompositionDirtyGeometry<CompositionCase<
1306 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1307 KeepCompositionTypeVariant<
1308 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1309 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001310}
1311
1312TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001313 displayRefreshCompositionDirtyFrame<CompositionCase<
1314 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1315 KeepCompositionTypeVariant<
1316 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1317 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001318}
1319
1320TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001321 displayRefreshCompositionDirtyFrame<CompositionCase<
1322 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1323 ChangeCompositionTypeVariant<
1324 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND,
1325 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1326 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001327}
1328
1329TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1330 captureScreenComposition<
1331 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1332 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1333}
1334
1335/* ------------------------------------------------------------------------
1336 * Layers with ISurfaceComposerClient::eSecure, on a secure display
1337 */
1338
1339TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001340 displayRefreshCompositionDirtyGeometry<CompositionCase<
1341 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1342 KeepCompositionTypeVariant<
1343 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1344 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001345}
1346
1347TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001348 displayRefreshCompositionDirtyFrame<CompositionCase<
1349 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1350 KeepCompositionTypeVariant<
1351 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1352 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001353}
1354
1355TEST_F(CompositionTest, REComposedSecureBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001356 displayRefreshCompositionDirtyFrame<CompositionCase<
1357 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1358 ChangeCompositionTypeVariant<
1359 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1360 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1361 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001362}
1363
1364TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1365 captureScreenComposition<
1366 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1367 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1368}
1369
1370/* ------------------------------------------------------------------------
1371 * Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1372 */
1373
1374TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001375 displayRefreshCompositionDirtyGeometry<CompositionCase<
1376 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1377 KeepCompositionTypeVariant<
1378 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1379 ForcedClientCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001380}
1381
1382TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001383 displayRefreshCompositionDirtyFrame<CompositionCase<
1384 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1385 KeepCompositionTypeVariant<
1386 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1387 ForcedClientCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001388}
1389
1390TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1391 captureScreenComposition<
1392 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1393 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1394}
1395
1396/* ------------------------------------------------------------------------
Garfield Tande619fa2020-10-02 17:13:53 -07001397 * Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1398 */
1399
1400TEST_F(CompositionTest,
1401 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001402 displayRefreshCompositionDirtyGeometry<CompositionCase<
1403 InsecureDisplaySetupVariant,
1404 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1405 ContainerLayerVariant<SecureLayerProperties>>,
1406 KeepCompositionTypeVariant<
1407 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1408 ForcedClientCompositionResultVariant>>();
Garfield Tande619fa2020-10-02 17:13:53 -07001409}
1410
1411TEST_F(CompositionTest,
1412 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001413 displayRefreshCompositionDirtyFrame<CompositionCase<
1414 InsecureDisplaySetupVariant,
1415 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1416 ContainerLayerVariant<SecureLayerProperties>>,
1417 KeepCompositionTypeVariant<
1418 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1419 ForcedClientCompositionResultVariant>>();
Garfield Tande619fa2020-10-02 17:13:53 -07001420}
1421
1422TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1423 captureScreenComposition<
1424 CompositionCase<InsecureDisplaySetupVariant,
1425 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1426 ContainerLayerVariant<SecureLayerProperties>>,
1427 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1428}
1429
1430/* ------------------------------------------------------------------------
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001431 * Cursor layers
1432 */
1433
1434TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001435 displayRefreshCompositionDirtyGeometry<CompositionCase<
1436 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1437 KeepCompositionTypeVariant<
1438 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1439 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001440}
1441
1442TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001443 displayRefreshCompositionDirtyFrame<CompositionCase<
1444 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1445 KeepCompositionTypeVariant<
1446 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1447 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001448}
1449
1450TEST_F(CompositionTest, REComposedCursorLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001451 displayRefreshCompositionDirtyFrame<CompositionCase<
1452 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1453 ChangeCompositionTypeVariant<
1454 aidl::android::hardware::graphics::composer3::Composition::CURSOR,
1455 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1456 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001457}
1458
1459TEST_F(CompositionTest, captureScreenCursorLayer) {
1460 captureScreenComposition<
1461 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1462 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1463}
1464
1465/* ------------------------------------------------------------------------
1466 * Simple buffer layer on a display which is powered off.
1467 */
1468
1469TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001470 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001471 displayRefreshCompositionDirtyGeometry<CompositionCase<
1472 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001473 KeepCompositionTypeVariant<
1474 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001475 HwcCompositionResultVariant>>();
1476}
1477
1478TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001479 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001480 displayRefreshCompositionDirtyFrame<CompositionCase<
1481 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001482 KeepCompositionTypeVariant<
1483 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001484 HwcCompositionResultVariant>>();
1485}
1486
1487TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001488 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001489 displayRefreshCompositionDirtyFrame<CompositionCase<
1490 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001491 ChangeCompositionTypeVariant<
1492 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1493 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001494 RECompositionResultVariant>>();
1495}
1496
1497TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1498 captureScreenComposition<CompositionCase<
1499 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1500 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1501}
1502
Lloyd Pique4fe29402019-08-12 16:51:24 -07001503/* ------------------------------------------------------------------------
1504 * Client composition forced through debug/developer settings
1505 */
1506
1507TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001508 displayRefreshCompositionDirtyGeometry<CompositionCase<
1509 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1510 KeepCompositionTypeVariant<
1511 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1512 ForcedClientCompositionViaDebugOptionResultVariant>>();
Lloyd Pique4fe29402019-08-12 16:51:24 -07001513}
1514
1515TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001516 displayRefreshCompositionDirtyFrame<CompositionCase<
1517 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1518 KeepCompositionTypeVariant<
1519 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1520 ForcedClientCompositionViaDebugOptionResultVariant>>();
Lloyd Pique4fe29402019-08-12 16:51:24 -07001521}
1522
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001523} // namespace
1524} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001525
1526// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01001527#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"