blob: c541b9291fe9639d506f5673da49bef04fb78c75 [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
40#include "BufferQueueLayer.h"
Garfield Tande619fa2020-10-02 17:13:53 -070041#include "ContainerLayer.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +020042#include "DisplayRenderArea.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080043#include "EffectLayer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070044#include "Layer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070045#include "TestableSurfaceFlinger.h"
46#include "mock/DisplayHardware/MockComposer.h"
Lloyd Pique9370a482019-10-03 17:58:30 -070047#include "mock/DisplayHardware/MockPowerAdvisor.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070048#include "mock/MockEventThread.h"
Alec Mourie4034bb2019-11-19 12:45:54 -080049#include "mock/MockTimeStats.h"
Ady Abraham8cb21882020-08-26 18:22:05 -070050#include "mock/MockVsyncController.h"
Alec Mouriba013fa2018-10-16 12:43:11 -070051#include "mock/system/window/MockNativeWindow.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070052
53namespace android {
54namespace {
55
Peiyong Line9d809e2020-04-14 13:10:48 -070056namespace hal = android::hardware::graphics::composer::hal;
57
Peiyong Lin65248e02020-04-18 21:15:07 -070058using hal::Error;
59using hal::IComposer;
60using hal::IComposerClient;
61using hal::PowerMode;
62using hal::Transform;
63
Ady Abrahamde549d42022-01-26 19:19:17 -080064using aidl::android::hardware::graphics::composer3::Capability;
65
Lloyd Piqued6b579f2018-04-06 15:29:10 -070066using testing::_;
David Sodman15094112018-10-11 09:39:37 -070067using testing::AtLeast;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070068using testing::DoAll;
69using testing::IsNull;
70using testing::Mock;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070071using testing::Return;
72using testing::ReturnRef;
73using testing::SetArgPointee;
74
Lloyd Piqued6b579f2018-04-06 15:29:10 -070075using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
76using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;
77
Peiyong Line9d809e2020-04-14 13:10:48 -070078constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DISPLAY_ID;
79constexpr hal::HWLayerId HWC_LAYER = 5000;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070080constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0);
81
Dominik Laskowskif1833852021-03-23 15:06:50 -070082constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(42u);
Lloyd Piqued6b579f2018-04-06 15:29:10 -070083constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
84constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
85
Lloyd Piqued6b579f2018-04-06 15:29:10 -070086constexpr int DEFAULT_TEXTURE_ID = 6000;
Dominik Laskowski29fa1462021-04-27 15:51:50 -070087constexpr ui::LayerStack LAYER_STACK{7000u};
Lloyd Piqued6b579f2018-04-06 15:29:10 -070088
89constexpr int DEFAULT_DISPLAY_MAX_LUMINANCE = 500;
90
91constexpr int DEFAULT_SIDEBAND_STREAM = 51;
92
Ady Abrahamdc011a92021-12-21 14:06:44 -080093MATCHER(IsIdentityMatrix, "") {
94 constexpr auto kIdentity = mat4();
95 return (mat4(arg) == kIdentity);
96}
97
Lloyd Piqued6b579f2018-04-06 15:29:10 -070098class CompositionTest : public testing::Test {
99public:
100 CompositionTest() {
101 const ::testing::TestInfo* const test_info =
102 ::testing::UnitTest::GetInstance()->current_test_info();
103 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
104
Ana Krulecafb45842019-02-13 13:33:03 -0800105 setupScheduler();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700106
Alec Mourif6fd29e2018-11-17 04:56:41 +0000107 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
108 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
109 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
110 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700111
112 mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
Alec Mourie4034bb2019-11-19 12:45:54 -0800113 mFlinger.setupTimeStats(std::shared_ptr<TimeStats>(mTimeStats));
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800114
115 mComposer = new Hwc2::mock::Composer();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000116 mPowerAdvisor = new Hwc2::mock::PowerAdvisor();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800117 mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
Xiang Wang839fe5b2022-04-04 17:39:38 +0000118 mFlinger.setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor>(mPowerAdvisor));
Garfield Tan9c9c1912021-07-19 12:02:16 -0700119 mFlinger.mutableMaxRenderTargetSize() = 16384;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700120 }
121
122 ~CompositionTest() {
123 const ::testing::TestInfo* const test_info =
124 ::testing::UnitTest::GetInstance()->current_test_info();
125 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
126 }
127
Ana Krulecafb45842019-02-13 13:33:03 -0800128 void setupScheduler() {
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700129 auto eventThread = std::make_unique<mock::EventThread>();
130 auto sfEventThread = std::make_unique<mock::EventThread>();
Ana Krulecafb45842019-02-13 13:33:03 -0800131
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700132 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
Dominik Laskowski98041832019-08-01 18:35:59 -0700133 EXPECT_CALL(*eventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -0700134 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
135 ResyncCallback())));
Dominik Laskowski98041832019-08-01 18:35:59 -0700136
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700137 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
Dominik Laskowski98041832019-08-01 18:35:59 -0700138 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -0700139 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
140 ResyncCallback())));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700141
Ady Abraham8cb21882020-08-26 18:22:05 -0700142 auto vsyncController = std::make_unique<mock::VsyncController>();
143 auto vsyncTracker = std::make_unique<mock::VSyncTracker>();
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700144
Ady Abraham8cb21882020-08-26 18:22:05 -0700145 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
146 EXPECT_CALL(*vsyncTracker, currentPeriod())
Marin Shalamanov045b7002021-01-07 16:56:24 +0100147 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Ady Abraham8cb21882020-08-26 18:22:05 -0700148 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700149
Ady Abraham8cb21882020-08-26 18:22:05 -0700150 mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800151 std::move(eventThread), std::move(sfEventThread),
152 TestableSurfaceFlinger::SchedulerCallbackImpl::kNoOp,
153 TestableSurfaceFlinger::kTwoDisplayModes);
Ana Krulecafb45842019-02-13 13:33:03 -0800154 }
155
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700156 void setupForceGeometryDirty() {
157 // TODO: This requires the visible region and other related
158 // state to be set, and is problematic for BufferLayers since they are
159 // not visible without a buffer (and setting up a buffer looks like a
160 // pain)
161 // mFlinger.mutableVisibleRegionsDirty() = true;
162
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700163 mFlinger.mutableGeometryDirty() = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700164 }
165
166 template <typename Case>
167 void displayRefreshCompositionDirtyGeometry();
168
169 template <typename Case>
170 void displayRefreshCompositionDirtyFrame();
171
172 template <typename Case>
173 void captureScreenComposition();
174
Ady Abrahamde549d42022-01-26 19:19:17 -0800175 std::unordered_set<Capability> mDefaultCapabilities = {Capability::SIDEBAND_STREAM};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700176
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800177 bool mDisplayOff = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700178 TestableSurfaceFlinger mFlinger;
179 sp<DisplayDevice> mDisplay;
180 sp<DisplayDevice> mExternalDisplay;
Lloyd Pique542307f2018-10-19 13:24:08 -0700181 sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
182 new compositionengine::mock::DisplaySurface();
Alec Mouriba013fa2018-10-16 12:43:11 -0700183 mock::NativeWindow* mNativeWindow = new mock::NativeWindow();
Garfield Tande619fa2020-10-02 17:13:53 -0700184 std::vector<sp<Layer>> mAuxiliaryLayers;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700185
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800186 sp<GraphicBuffer> mBuffer = new GraphicBuffer();
187 ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();
188
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700189 Hwc2::mock::Composer* mComposer = nullptr;
190 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
Alec Mourie4034bb2019-11-19 12:45:54 -0800191 mock::TimeStats* mTimeStats = new mock::TimeStats();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000192 Hwc2::mock::PowerAdvisor* mPowerAdvisor = nullptr;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700193
194 sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;
195
Alec Mouria90a5702021-04-16 16:36:21 +0000196 std::shared_ptr<renderengine::ExternalTexture> mCaptureScreenBuffer;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700197};
198
199template <typename LayerCase>
200void CompositionTest::displayRefreshCompositionDirtyGeometry() {
201 setupForceGeometryDirty();
202 LayerCase::setupForDirtyGeometry(this);
203
204 // --------------------------------------------------------------------
205 // Invocation
206
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700207 mFlinger.commitAndComposite();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700208
209 LayerCase::cleanup(this);
210}
211
212template <typename LayerCase>
213void CompositionTest::displayRefreshCompositionDirtyFrame() {
214 LayerCase::setupForDirtyFrame(this);
215
216 // --------------------------------------------------------------------
217 // Invocation
218
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700219 mFlinger.commitAndComposite();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700220
221 LayerCase::cleanup(this);
222}
223
224template <typename LayerCase>
225void CompositionTest::captureScreenComposition() {
226 LayerCase::setupForScreenCapture(this);
227
228 const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700229 constexpr bool forSystem = true;
Lucas Dupin9d763b72020-04-20 18:42:31 -0700230 constexpr bool regionSampling = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700231
Marin Shalamanov1c434292020-06-12 01:47:29 +0200232 auto renderArea = DisplayRenderArea::create(mDisplay, sourceCrop, sourceCrop.getSize(),
233 ui::Dataspace::V0_SRGB, ui::Transform::ROT_0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700234
235 auto traverseLayers = [this](const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700236 return mFlinger.traverseLayersInLayerStack(mDisplay->getLayerStack(),
237 CaptureArgs::UNSET_UID, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700238 };
239
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700240 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
241 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800242 mCaptureScreenBuffer =
243 std::make_shared<renderengine::mock::FakeExternalTexture>(renderArea->getReqWidth(),
244 renderArea->getReqHeight(),
245 HAL_PIXEL_FORMAT_RGBA_8888, 1,
246 usage);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700247
Robert Carr12a3b9b2022-03-10 09:55:29 -0800248 auto result = mFlinger.renderScreenImpl(*renderArea, traverseLayers, mCaptureScreenBuffer,
249 forSystem, regionSampling);
Sally Qi59a9f502021-10-12 18:53:23 +0000250 EXPECT_TRUE(result.valid());
251
252 auto& [status, drawFence] = result.get();
253
254 EXPECT_EQ(NO_ERROR, status);
255 if (drawFence.ok()) {
256 sync_wait(drawFence.get(), -1);
257 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700258
259 LayerCase::cleanup(this);
260}
261
Sally Qi4cabdd02021-08-05 16:45:57 -0700262template <class T>
263std::future<T> futureOf(T obj) {
264 std::promise<T> resultPromise;
265 std::future<T> resultFuture = resultPromise.get_future();
266 resultPromise.set_value(std::move(obj));
267 return resultFuture;
268}
269
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700270/* ------------------------------------------------------------------------
271 * Variants for each display configuration which can be tested
272 */
273
274template <typename Derived>
275struct BaseDisplayVariant {
276 static constexpr bool IS_SECURE = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700277 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700278
279 static void setupPreconditions(CompositionTest* test) {
Peiyong Lin65248e02020-04-18 21:15:07 -0700280 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700281 .WillOnce(Return(Error::NONE));
Alec Mouriba013fa2018-10-16 12:43:11 -0700282
Peiyong Line9d809e2020-04-14 13:10:48 -0700283 FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700284 .setCapabilities(&test->mDefaultCapabilities)
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700285 .setPowerMode(Derived::INIT_POWER_MODE)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700286 .inject(&test->mFlinger, test->mComposer);
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800287 Mock::VerifyAndClear(test->mComposer);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700288
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800289 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
290 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
291 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
292 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
293 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
294 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
295 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
Lloyd Pique9370a482019-10-03 17:58:30 -0700296
297 const ::testing::TestInfo* const test_info =
298 ::testing::UnitTest::GetInstance()->current_test_info();
299
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800300 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
301 .setId(DEFAULT_DISPLAY_ID)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800302 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
303 .setIsSecure(Derived::IS_SECURE)
Xiang Wang839fe5b2022-04-04 17:39:38 +0000304 .setPowerAdvisor(test->mPowerAdvisor)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800305 .setName(std::string("Injected display for ") +
306 test_info->test_case_name() + "." + test_info->name())
307 .build();
Lloyd Pique9370a482019-10-03 17:58:30 -0700308
309 auto compositionDisplay =
310 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
311 ceDisplayArgs);
312
Marin Shalamanov700e6392020-02-12 20:22:26 +0100313 test->mDisplay = FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100314 ui::DisplayConnectionType::Internal, HWC_DISPLAY,
Marin Shalamanov700e6392020-02-12 20:22:26 +0100315 true /* isPrimary */)
316 .setDisplaySurface(test->mDisplaySurface)
317 .setNativeWindow(test->mNativeWindow)
318 .setSecure(Derived::IS_SECURE)
319 .setPowerMode(Derived::INIT_POWER_MODE)
320 .inject();
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800321 Mock::VerifyAndClear(test->mNativeWindow);
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700322 test->mDisplay->setLayerStack(LAYER_STACK);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700323 }
324
325 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700326 static void setupPreconditionCallExpectations(CompositionTest* test) {
327 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500328 .WillOnce(DoAll(SetArgPointee<1>(
329 std::vector<aidl::android::hardware::graphics::composer3::
330 DisplayCapability>({})),
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700331 Return(Error::NONE)));
332 }
333
334 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700335 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
Ady Abrahamdc011a92021-12-21 14:06:44 -0800336 EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700337 EXPECT_CALL(*test->mComposer, getDisplayRequests(HWC_DISPLAY, _, _, _)).Times(1);
338 EXPECT_CALL(*test->mComposer, acceptDisplayChanges(HWC_DISPLAY)).Times(1);
339 EXPECT_CALL(*test->mComposer, presentDisplay(HWC_DISPLAY, _)).Times(1);
340 EXPECT_CALL(*test->mComposer, getReleaseFences(HWC_DISPLAY, _, _)).Times(1);
341
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700342 EXPECT_CALL(*test->mDisplaySurface, onFrameCommitted()).Times(1);
343 EXPECT_CALL(*test->mDisplaySurface, advanceFrame()).Times(1);
344
345 Case::CompositionType::setupHwcSetCallExpectations(test);
346 Case::CompositionType::setupHwcGetCallExpectations(test);
347 }
348
349 template <typename Case>
350 static void setupCommonScreensCaptureCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000351 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700352 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000353 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -0700354 const std::shared_ptr<renderengine::ExternalTexture>&,
Sally Qi59a9f502021-10-12 18:53:23 +0000355 const bool, base::unique_fd&&)
Sally Qi4cabdd02021-08-05 16:45:57 -0700356 -> std::future<renderengine::RenderEngineResult> {
Lloyd Pique9370a482019-10-03 17:58:30 -0700357 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
358 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
359 displaySettings.physicalDisplay);
360 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
361 displaySettings.clip);
Sally Qi4cabdd02021-08-05 16:45:57 -0700362 return futureOf<renderengine::RenderEngineResult>(
363 {NO_ERROR, base::unique_fd()});
Lloyd Pique9370a482019-10-03 17:58:30 -0700364 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700365 }
366
367 static void setupNonEmptyFrameCompositionCallExpectations(CompositionTest* test) {
368 EXPECT_CALL(*test->mDisplaySurface, beginFrame(true)).Times(1);
369 }
370
371 static void setupEmptyFrameCompositionCallExpectations(CompositionTest* test) {
372 EXPECT_CALL(*test->mDisplaySurface, beginFrame(false)).Times(1);
373 }
374
375 static void setupHwcCompositionCallExpectations(CompositionTest* test) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800376 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _))
377 .Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800378
Lloyd Pique542307f2018-10-19 13:24:08 -0700379 EXPECT_CALL(*test->mDisplaySurface,
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700380 prepareFrame(compositionengine::DisplaySurface::CompositionType::Hwc))
Lloyd Pique542307f2018-10-19 13:24:08 -0700381 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700382 }
383
Lloyd Pique66d68602019-02-13 14:23:31 -0800384 static void setupHwcClientCompositionCallExpectations(CompositionTest* test) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800385 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _))
386 .Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800387 }
388
389 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800390 EXPECT_CALL(*test->mComposer, validateDisplay(HWC_DISPLAY, _, _, _)).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800391 }
392
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700393 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Pique542307f2018-10-19 13:24:08 -0700394 EXPECT_CALL(*test->mDisplaySurface,
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700395 prepareFrame(compositionengine::DisplaySurface::CompositionType::Gpu))
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700396 .Times(1);
397 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
398 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
399
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800400 EXPECT_CALL(*test->mNativeWindow, queueBuffer(_, _)).WillOnce(Return(0));
401 EXPECT_CALL(*test->mNativeWindow, dequeueBuffer(_, _))
402 .WillOnce(DoAll(SetArgPointee<0>(test->mNativeWindowBuffer), SetArgPointee<1>(-1),
403 Return(0)));
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000404 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700405 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000406 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -0700407 const std::shared_ptr<renderengine::ExternalTexture>&,
Sally Qi59a9f502021-10-12 18:53:23 +0000408 const bool, base::unique_fd&&)
Sally Qi4cabdd02021-08-05 16:45:57 -0700409 -> std::future<renderengine::RenderEngineResult> {
Lloyd Pique9370a482019-10-03 17:58:30 -0700410 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
411 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
412 displaySettings.physicalDisplay);
413 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
414 displaySettings.clip);
415 EXPECT_EQ(ui::Dataspace::UNKNOWN, displaySettings.outputDataspace);
Sally Qi4cabdd02021-08-05 16:45:57 -0700416 return futureOf<renderengine::RenderEngineResult>(
417 {NO_ERROR, base::unique_fd()});
Lloyd Pique9370a482019-10-03 17:58:30 -0700418 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700419 }
420
421 template <typename Case>
422 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
423 Case::Layer::setupRECompositionCallExpectations(test);
424 }
425
426 template <typename Case>
427 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
428 Case::Layer::setupREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700429 }
430};
431
432struct DefaultDisplaySetupVariant : public BaseDisplayVariant<DefaultDisplaySetupVariant> {};
433
434struct InsecureDisplaySetupVariant : public BaseDisplayVariant<InsecureDisplaySetupVariant> {
435 static constexpr bool IS_SECURE = false;
436
437 template <typename Case>
438 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
439 Case::Layer::setupInsecureRECompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700440 }
441
442 template <typename Case>
443 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
444 Case::Layer::setupInsecureREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700445 }
446};
447
448struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDisplaySetupVariant> {
Peiyong Lin65248e02020-04-18 21:15:07 -0700449 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::OFF;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700450
451 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700452 static void setupPreconditionCallExpectations(CompositionTest*) {}
453
454 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700455 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
456 // TODO: This seems like an unnecessary call if display is powered off.
Ady Abrahamdc011a92021-12-21 14:06:44 -0800457 EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700458
459 // TODO: This seems like an unnecessary call if display is powered off.
460 Case::CompositionType::setupHwcSetCallExpectations(test);
461 }
462
463 static void setupHwcCompositionCallExpectations(CompositionTest*) {}
Lloyd Pique66d68602019-02-13 14:23:31 -0800464 static void setupHwcClientCompositionCallExpectations(CompositionTest*) {}
465 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest*) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700466
467 static void setupRECompositionCallExpectations(CompositionTest* test) {
468 // TODO: This seems like an unnecessary call if display is powered off.
469 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
470 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
471 }
472
473 template <typename Case>
474 static void setupRELayerCompositionCallExpectations(CompositionTest*) {}
475};
476
477/* ------------------------------------------------------------------------
478 * Variants for each layer configuration which can be tested
479 */
480
481template <typename LayerProperties>
482struct BaseLayerProperties {
483 static constexpr uint32_t WIDTH = 100;
484 static constexpr uint32_t HEIGHT = 100;
485 static constexpr PixelFormat FORMAT = PIXEL_FORMAT_RGBA_8888;
486 static constexpr uint64_t USAGE =
487 GraphicBuffer::USAGE_SW_READ_NEVER | GraphicBuffer::USAGE_SW_WRITE_NEVER;
488 static constexpr android_dataspace DATASPACE = HAL_DATASPACE_UNKNOWN;
489 static constexpr uint32_t SCALING_MODE = 0;
490 static constexpr uint32_t TRANSFORM = 0;
491 static constexpr uint32_t LAYER_FLAGS = 0;
492 static constexpr float COLOR[] = {1.f, 1.f, 1.f, 1.f};
493 static constexpr IComposerClient::BlendMode BLENDMODE =
494 IComposerClient::BlendMode::PREMULTIPLIED;
495
496 static void enqueueBuffer(CompositionTest*, sp<BufferQueueLayer> layer) {
497 auto producer = layer->getProducer();
498
499 IGraphicBufferProducer::QueueBufferOutput qbo;
500 status_t result = producer->connect(nullptr, NATIVE_WINDOW_API_EGL, false, &qbo);
501 if (result != NO_ERROR) {
502 ALOGE("Failed to connect() (%d)", result);
503 return;
504 }
505
506 int slot;
507 sp<Fence> fence;
508 result = producer->dequeueBuffer(&slot, &fence, LayerProperties::WIDTH,
509 LayerProperties::HEIGHT, LayerProperties::FORMAT,
510 LayerProperties::USAGE, nullptr, nullptr);
511 if (result != IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) {
512 ALOGE("Failed to dequeueBuffer() (%d)", result);
513 return;
514 }
515
516 sp<GraphicBuffer> buffer;
517 result = producer->requestBuffer(slot, &buffer);
518 if (result != NO_ERROR) {
519 ALOGE("Failed to requestBuffer() (%d)", result);
520 return;
521 }
522
523 IGraphicBufferProducer::QueueBufferInput qbi(systemTime(), false /* isAutoTimestamp */,
524 LayerProperties::DATASPACE,
525 Rect(LayerProperties::WIDTH,
526 LayerProperties::HEIGHT),
527 LayerProperties::SCALING_MODE,
528 LayerProperties::TRANSFORM, Fence::NO_FENCE);
529 result = producer->queueBuffer(slot, qbi, &qbo);
530 if (result != NO_ERROR) {
531 ALOGE("Failed to queueBuffer (%d)", result);
532 return;
533 }
534 }
535
536 static void setupLatchedBuffer(CompositionTest* test, sp<BufferQueueLayer> layer) {
537 // TODO: Eliminate the complexity of actually creating a buffer
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800538 layer->setSizeForTest(LayerProperties::WIDTH, LayerProperties::HEIGHT);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700539 status_t err =
540 layer->setDefaultBufferProperties(LayerProperties::WIDTH, LayerProperties::HEIGHT,
541 LayerProperties::FORMAT);
542 ASSERT_EQ(NO_ERROR, err);
543 Mock::VerifyAndClear(test->mRenderEngine);
544
Dominik Laskowski46f3e3b2021-08-10 11:44:24 -0700545 EXPECT_CALL(*test->mFlinger.scheduler(), scheduleFrame()).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700546 enqueueBuffer(test, layer);
Dominik Laskowski756b7892021-08-04 12:53:59 -0700547 Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700548
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700549 bool ignoredRecomputeVisibleRegions;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700550 layer->latchBuffer(ignoredRecomputeVisibleRegions, 0, 0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700551 Mock::VerifyAndClear(test->mRenderEngine);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700552 }
553
554 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
555 setupLatchedBuffer(test, layer);
556 }
557
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700558 static void setupHwcSetGeometryCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800559 if (!test->mDisplayOff) {
560 // TODO: Coverage of other values
561 EXPECT_CALL(*test->mComposer,
562 setLayerBlendMode(HWC_DISPLAY, HWC_LAYER, LayerProperties::BLENDMODE))
563 .Times(1);
564 // TODO: Coverage of other values for origin
565 EXPECT_CALL(*test->mComposer,
566 setLayerDisplayFrame(HWC_DISPLAY, HWC_LAYER,
567 IComposerClient::Rect({0, 0, LayerProperties::WIDTH,
568 LayerProperties::HEIGHT})))
569 .Times(1);
570 EXPECT_CALL(*test->mComposer,
571 setLayerPlaneAlpha(HWC_DISPLAY, HWC_LAYER, LayerProperties::COLOR[3]))
572 .Times(1);
573 // TODO: Coverage of other values
574 EXPECT_CALL(*test->mComposer, setLayerZOrder(HWC_DISPLAY, HWC_LAYER, 0u)).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700575
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800576 // These expectations retire on saturation as the code path these
577 // expectations are for appears to make an extra call to them.
578 // TODO: Investigate this extra call
579 EXPECT_CALL(*test->mComposer,
580 setLayerTransform(HWC_DISPLAY, HWC_LAYER, DEFAULT_TRANSFORM))
581 .Times(AtLeast(1))
582 .RetiresOnSaturation();
583 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700584 }
585
586 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800587 if (!test->mDisplayOff) {
588 EXPECT_CALL(*test->mComposer,
589 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
590 IComposerClient::FRect({0.f, 0.f, LayerProperties::WIDTH,
591 LayerProperties::HEIGHT})))
592 .Times(1);
593 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700594 }
595
596 static void setupHwcSetSourceCropColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800597 if (!test->mDisplayOff) {
598 EXPECT_CALL(*test->mComposer,
599 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
600 IComposerClient::FRect({0.f, 0.f, 0.f, 0.f})))
601 .Times(1);
602 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700603 }
604
605 static void setupHwcSetPerFrameCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800606 if (!test->mDisplayOff) {
607 EXPECT_CALL(*test->mComposer,
608 setLayerVisibleRegion(HWC_DISPLAY, HWC_LAYER,
609 std::vector<IComposerClient::Rect>(
610 {IComposerClient::Rect(
611 {0, 0, LayerProperties::WIDTH,
612 LayerProperties::HEIGHT})})))
613 .Times(1);
614 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700615 }
616
617 static void setupHwcSetPerFrameColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800618 if (!test->mDisplayOff) {
619 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
620 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700621
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800622 // TODO: use COLOR
623 EXPECT_CALL(*test->mComposer,
624 setLayerColor(HWC_DISPLAY, HWC_LAYER,
Ady Abraham6e60b142022-01-06 18:10:35 -0800625 aidl::android::hardware::graphics::composer3::Color(
626 {1.0f, 1.0f, 1.0f, 1.0f})))
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800627 .Times(1);
628 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700629 }
630
631 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800632 if (!test->mDisplayOff) {
633 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
634 .Times(1);
635 EXPECT_CALL(*test->mComposer, setLayerBuffer(HWC_DISPLAY, HWC_LAYER, _, _, _)).Times(1);
636 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700637 }
638
639 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000640 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700641 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000642 const std::vector<renderengine::LayerSettings>& layerSettings,
Sally Qi4cabdd02021-08-05 16:45:57 -0700643 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +0000644 base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000645 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
646 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
647 displaySettings.physicalDisplay);
648 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
649 displaySettings.clip);
650 // screen capture adds an additional color layer as an alpha
651 // prefill, so gtet the back layer.
Sally Qi4cabdd02021-08-05 16:45:57 -0700652 std::future<renderengine::RenderEngineResult> resultFuture =
653 futureOf<renderengine::RenderEngineResult>(
654 {NO_ERROR, base::unique_fd()});
Lloyd Piquea2468662019-03-07 21:31:06 -0800655 if (layerSettings.empty()) {
656 ADD_FAILURE() << "layerSettings was not expected to be empty in "
657 "setupREBufferCompositionCommonCallExpectations "
658 "verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700659 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800660 }
Sally Qi59a9f502021-10-12 18:53:23 +0000661 const renderengine::LayerSettings layer = layerSettings.back();
662 EXPECT_THAT(layer.source.buffer.buffer, Not(IsNull()));
663 EXPECT_THAT(layer.source.buffer.fence, Not(IsNull()));
664 EXPECT_EQ(DEFAULT_TEXTURE_ID, layer.source.buffer.textureName);
665 EXPECT_EQ(false, layer.source.buffer.isY410BT2020);
666 EXPECT_EQ(true, layer.source.buffer.usePremultipliedAlpha);
667 EXPECT_EQ(false, layer.source.buffer.isOpaque);
668 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius);
669 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
670 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700671 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000672 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700673 }
674
675 static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
676 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700677 }
678
679 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
680 setupREBufferCompositionCallExpectations(test);
681 }
682
683 static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
684 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
685 }
686
687 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
688 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
689 }
690
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700691 static void setupREColorCompositionCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000692 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700693 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000694 const std::vector<renderengine::LayerSettings>& layerSettings,
Sally Qi4cabdd02021-08-05 16:45:57 -0700695 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +0000696 base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000697 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
698 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
699 displaySettings.physicalDisplay);
700 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
701 displaySettings.clip);
702 // screen capture adds an additional color layer as an alpha
703 // prefill, so get the back layer.
Sally Qi4cabdd02021-08-05 16:45:57 -0700704 std::future<renderengine::RenderEngineResult> resultFuture =
705 futureOf<renderengine::RenderEngineResult>(
706 {NO_ERROR, base::unique_fd()});
Lloyd Piquea2468662019-03-07 21:31:06 -0800707 if (layerSettings.empty()) {
708 ADD_FAILURE()
709 << "layerSettings was not expected to be empty in "
710 "setupREColorCompositionCallExpectations verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700711 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800712 }
Sally Qi59a9f502021-10-12 18:53:23 +0000713 const renderengine::LayerSettings layer = layerSettings.back();
714 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000715 EXPECT_EQ(half3(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
716 LayerProperties::COLOR[2]),
Sally Qi59a9f502021-10-12 18:53:23 +0000717 layer.source.solidColor);
718 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius);
719 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
720 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700721 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000722 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700723 }
724
725 static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
726 setupREColorCompositionCallExpectations(test);
727 }
728};
729
730struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
731
Vishnu Nairfa247b12020-02-11 08:58:26 -0800732struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
Alec Mourida8a9d12020-01-30 20:00:31 -0800733 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
734};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700735
736struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
737 using Base = BaseLayerProperties<SidebandLayerProperties>;
738 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
739
740 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
741 sp<NativeHandle> stream =
742 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
743 false);
744 test->mFlinger.setLayerSidebandStream(layer, stream);
745 }
746
747 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
748 EXPECT_CALL(*test->mComposer,
749 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
750 IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
751 .Times(1);
752 }
753
754 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
755 EXPECT_CALL(*test->mComposer,
756 setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
757 reinterpret_cast<native_handle_t*>(
758 DEFAULT_SIDEBAND_STREAM)))
759 .WillOnce(Return(Error::NONE));
760
761 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
762 }
763
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000764 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700765};
766
Garfield Tande619fa2020-10-02 17:13:53 -0700767template <typename LayerProperties>
768struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
769 using Base = BaseLayerProperties<LayerProperties>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700770
771 static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000772 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700773 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000774 const std::vector<renderengine::LayerSettings>& layerSettings,
Sally Qi4cabdd02021-08-05 16:45:57 -0700775 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +0000776 base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000777 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
778 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
779 displaySettings.physicalDisplay);
780 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
781 displaySettings.clip);
782 // screen capture adds an additional color layer as an alpha
783 // prefill, so get the back layer.
Sally Qi4cabdd02021-08-05 16:45:57 -0700784 std::future<renderengine::RenderEngineResult> resultFuture =
785 futureOf<renderengine::RenderEngineResult>(
786 {NO_ERROR, base::unique_fd()});
Lloyd Piquea2468662019-03-07 21:31:06 -0800787 if (layerSettings.empty()) {
788 ADD_FAILURE() << "layerSettings was not expected to be empty in "
789 "setupInsecureREBufferCompositionCommonCallExpectations "
790 "verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700791 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800792 }
Sally Qi59a9f502021-10-12 18:53:23 +0000793 const renderengine::LayerSettings layer = layerSettings.back();
794 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
795 EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer.source.solidColor);
796 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius);
797 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
798 EXPECT_EQ(1.0f, layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700799 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000800 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700801 }
802
803 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
804 setupInsecureREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700805 }
806
807 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
808 setupInsecureREBufferCompositionCommonCallExpectations(test);
809 }
810};
811
Garfield Tande619fa2020-10-02 17:13:53 -0700812struct ParentSecureLayerProperties
813 : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
814
815struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
816 static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
817};
818
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700819struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
820 using Base = BaseLayerProperties<CursorLayerProperties>;
821
822 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
823 Base::setupLayerState(test, layer);
824 test->mFlinger.setLayerPotentialCursor(layer, true);
825 }
826};
827
828struct NoLayerVariant {
829 using FlingerLayerType = sp<BufferQueueLayer>;
830
831 static FlingerLayerType createLayer(CompositionTest*) { return FlingerLayerType(); }
832 static void injectLayer(CompositionTest*, FlingerLayerType) {}
833 static void cleanupInjectedLayers(CompositionTest*) {}
834
835 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
836 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
837};
838
839template <typename LayerProperties>
840struct BaseLayerVariant {
841 template <typename L, typename F>
842 static sp<L> createLayerWithFactory(CompositionTest* test, F factory) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700843 EXPECT_CALL(*test->mFlinger.scheduler(), postMessage(_)).Times(0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700844
845 sp<L> layer = factory();
846
Dominik Laskowski49cea512019-11-12 14:13:23 -0800847 // Layer should be registered with scheduler.
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700848 EXPECT_EQ(1u, test->mFlinger.scheduler()->layerHistorySize());
Dominik Laskowski49cea512019-11-12 14:13:23 -0800849
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700850 Mock::VerifyAndClear(test->mComposer);
851 Mock::VerifyAndClear(test->mRenderEngine);
Dominik Laskowski756b7892021-08-04 12:53:59 -0700852 Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700853
Garfield Tande619fa2020-10-02 17:13:53 -0700854 initLayerDrawingStateAndComputeBounds(test, layer);
855
856 return layer;
857 }
858
859 template <typename L>
860 static void initLayerDrawingStateAndComputeBounds(CompositionTest* test, sp<L> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700861 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700862 layerDrawingState.layerStack = LAYER_STACK;
chaviw766c9c52021-02-10 17:36:47 -0800863 layerDrawingState.width = 100;
864 layerDrawingState.height = 100;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700865 layerDrawingState.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
866 LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700867 layer->computeBounds(FloatRect(0, 0, 100, 100), ui::Transform(), 0.f /* shadowRadius */);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700868 }
869
870 static void injectLayer(CompositionTest* test, sp<Layer> layer) {
871 EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
872 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
873
Lloyd Piquede196652020-01-22 17:29:58 -0800874 auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
875 layer->getCompositionEngineLayerFE());
Lloyd Pique01c77c12019-04-17 12:48:32 -0700876 outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
877 outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700878
879 Mock::VerifyAndClear(test->mComposer);
880
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700881 test->mFlinger.mutableDrawingState().layersSortedByZ.add(layer);
882 }
883
884 static void cleanupInjectedLayers(CompositionTest* test) {
885 EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
886 .WillOnce(Return(Error::NONE));
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800887
Lloyd Pique01c77c12019-04-17 12:48:32 -0700888 test->mDisplay->getCompositionDisplay()->clearOutputLayers();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700889 test->mFlinger.mutableDrawingState().layersSortedByZ.clear();
Dominik Laskowski49cea512019-11-12 14:13:23 -0800890
891 // Layer should be unregistered with scheduler.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700892 test->mFlinger.commit();
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700893 EXPECT_EQ(0u, test->mFlinger.scheduler()->layerHistorySize());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700894 }
895};
896
897template <typename LayerProperties>
Vishnu Nairfa247b12020-02-11 08:58:26 -0800898struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700899 using Base = BaseLayerVariant<LayerProperties>;
Vishnu Nairfa247b12020-02-11 08:58:26 -0800900 using FlingerLayerType = sp<EffectLayer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700901
902 static FlingerLayerType createLayer(CompositionTest* test) {
Vishnu Nairfa247b12020-02-11 08:58:26 -0800903 FlingerLayerType layer = Base::template createLayerWithFactory<EffectLayer>(test, [test]() {
904 return new EffectLayer(
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700905 LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Vishnu Nairfa247b12020-02-11 08:58:26 -0800906 LayerProperties::LAYER_FLAGS, LayerMetadata()));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700907 });
Vishnu Nair60356342018-11-13 13:00:45 -0800908
909 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
chaviw25714502021-02-11 10:01:08 -0800910 layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700911 return layer;
912 }
913
914 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700915 LayerProperties::setupREColorCompositionCallExpectations(test);
916 }
917
918 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
919 LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
920 }
921
922 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
923 LayerProperties::setupHwcSetGeometryCallExpectations(test);
924 LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
925 }
926
927 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
928 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
929 LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
930 }
931};
932
933template <typename LayerProperties>
934struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
935 using Base = BaseLayerVariant<LayerProperties>;
936 using FlingerLayerType = sp<BufferQueueLayer>;
937
938 static FlingerLayerType createLayer(CompositionTest* test) {
939 test->mFlinger.mutableTexturePool().push_back(DEFAULT_TEXTURE_ID);
940
941 FlingerLayerType layer =
942 Base::template createLayerWithFactory<BufferQueueLayer>(test, [test]() {
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700943 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700944 LayerProperties::LAYER_FLAGS, LayerMetadata());
chaviwb4c6e582019-08-16 14:35:07 -0700945 args.textureName = test->mFlinger.mutableTexturePool().back();
946 return new BufferQueueLayer(args);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700947 });
948
949 LayerProperties::setupLayerState(test, layer);
950
951 return layer;
952 }
953
954 static void cleanupInjectedLayers(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700955 Base::cleanupInjectedLayers(test);
956 }
957
958 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
959 LayerProperties::setupHwcSetGeometryCallExpectations(test);
960 LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
961 }
962
963 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
964 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
965 LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
966 }
967
968 static void setupRECompositionCallExpectations(CompositionTest* test) {
969 LayerProperties::setupREBufferCompositionCallExpectations(test);
970 }
971
972 static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
973 LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
974 }
975
976 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
977 LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
978 }
979
980 static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
981 LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
982 }
983};
984
Garfield Tande619fa2020-10-02 17:13:53 -0700985template <typename LayerProperties>
986struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
987 using Base = BaseLayerVariant<LayerProperties>;
988 using FlingerLayerType = sp<ContainerLayer>;
989
990 static FlingerLayerType createLayer(CompositionTest* test) {
991 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
Garfield Tande619fa2020-10-02 17:13:53 -0700992 LayerProperties::LAYER_FLAGS, LayerMetadata());
993 FlingerLayerType layer = new ContainerLayer(args);
994 Base::template initLayerDrawingStateAndComputeBounds(test, layer);
995 return layer;
996 }
997};
998
999template <typename LayerVariant, typename ParentLayerVariant>
1000struct ChildLayerVariant : public LayerVariant {
1001 using Base = LayerVariant;
1002 using FlingerLayerType = typename LayerVariant::FlingerLayerType;
1003 using ParentBase = ParentLayerVariant;
1004
1005 static FlingerLayerType createLayer(CompositionTest* test) {
1006 // Need to create child layer first. Otherwise layer history size will be 2.
1007 FlingerLayerType layer = Base::createLayer(test);
1008
1009 typename ParentBase::FlingerLayerType parentLayer = ParentBase::createLayer(test);
1010 parentLayer->addChild(layer);
1011 test->mFlinger.setLayerDrawingParent(layer, parentLayer);
1012
1013 test->mAuxiliaryLayers.push_back(parentLayer);
1014
1015 return layer;
1016 }
1017
1018 static void cleanupInjectedLayers(CompositionTest* test) {
1019 // Clear auxiliary layers first so that child layer can be successfully destroyed in the
1020 // following call.
1021 test->mAuxiliaryLayers.clear();
1022
1023 Base::cleanupInjectedLayers(test);
1024 }
1025};
1026
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001027/* ------------------------------------------------------------------------
1028 * Variants to control how the composition type is changed
1029 */
1030
1031struct NoCompositionTypeVariant {
1032 static void setupHwcSetCallExpectations(CompositionTest*) {}
1033
1034 static void setupHwcGetCallExpectations(CompositionTest* test) {
1035 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1036 }
1037};
1038
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001039template <aidl::android::hardware::graphics::composer3::Composition CompositionType>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001040struct KeepCompositionTypeVariant {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001041 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
1042 CompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001043
1044 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001045 if (!test->mDisplayOff) {
1046 EXPECT_CALL(*test->mComposer,
1047 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
1048 .Times(1);
1049 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001050 }
1051
1052 static void setupHwcGetCallExpectations(CompositionTest* test) {
1053 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1054 }
1055};
1056
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001057template <aidl::android::hardware::graphics::composer3::Composition InitialCompositionType,
1058 aidl::android::hardware::graphics::composer3::Composition FinalCompositionType>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001059struct ChangeCompositionTypeVariant {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001060 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
1061 FinalCompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001062
1063 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001064 if (!test->mDisplayOff) {
1065 EXPECT_CALL(*test->mComposer,
1066 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
1067 .Times(1);
1068 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001069 }
1070
1071 static void setupHwcGetCallExpectations(CompositionTest* test) {
1072 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
1073 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
1074 static_cast<Hwc2::Layer>(HWC_LAYER)}),
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001075 SetArgPointee<2>(
1076 std::vector<aidl::android::hardware::graphics::composer3::
1077 Composition>{FinalCompositionType}),
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001078 Return(Error::NONE)));
1079 }
1080};
1081
1082/* ------------------------------------------------------------------------
1083 * Variants to select how the composition is expected to be handled
1084 */
1085
1086struct CompositionResultBaseVariant {
1087 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1088
1089 template <typename Case>
1090 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
1091 Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1092 }
1093
1094 template <typename Case>
1095 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1096 Case::Layer::setupCallExpectationsForDirtyFrame(test);
1097 }
1098};
1099
1100struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1101 template <typename Case>
1102 static void setupCallExpectations(CompositionTest* test) {
1103 Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1104 Case::Display::setupHwcCompositionCallExpectations(test);
1105 }
1106};
1107
1108struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1109 template <typename Case>
1110 static void setupCallExpectations(CompositionTest* test) {
1111 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1112 Case::Display::setupHwcCompositionCallExpectations(test);
1113 }
1114};
1115
1116struct RECompositionResultVariant : public CompositionResultBaseVariant {
1117 template <typename Case>
1118 static void setupCallExpectations(CompositionTest* test) {
1119 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
Lloyd Pique66d68602019-02-13 14:23:31 -08001120 Case::Display::setupHwcClientCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001121 Case::Display::setupRECompositionCallExpectations(test);
1122 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1123 }
1124};
1125
Lloyd Pique66d68602019-02-13 14:23:31 -08001126struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001127 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001128 const auto outputLayer =
1129 TestableSurfaceFlinger::findOutputLayerForDisplay(layer, test->mDisplay);
Lloyd Piquef5275482019-01-29 18:42:42 -08001130 LOG_FATAL_IF(!outputLayer);
1131 outputLayer->editState().forceClientComposition = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001132 }
1133
1134 template <typename Case>
Lloyd Pique66d68602019-02-13 14:23:31 -08001135 static void setupCallExpectations(CompositionTest* test) {
1136 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1137 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1138 Case::Display::setupRECompositionCallExpectations(test);
1139 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1140 }
1141
1142 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001143 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1144
1145 template <typename Case>
1146 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1147};
1148
Lloyd Pique4fe29402019-08-12 16:51:24 -07001149struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
1150 static void setupLayerState(CompositionTest* test, sp<Layer>) {
1151 test->mFlinger.mutableDebugDisableHWC() = true;
1152 }
1153
1154 template <typename Case>
1155 static void setupCallExpectations(CompositionTest* test) {
1156 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1157 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1158 Case::Display::setupRECompositionCallExpectations(test);
1159 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1160 }
1161
1162 template <typename Case>
1163 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1164
1165 template <typename Case>
1166 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1167};
1168
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001169struct EmptyScreenshotResultVariant {
1170 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1171
1172 template <typename Case>
1173 static void setupCallExpectations(CompositionTest*) {}
1174};
1175
1176struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1177 using Base = EmptyScreenshotResultVariant;
1178
1179 template <typename Case>
1180 static void setupCallExpectations(CompositionTest* test) {
1181 Base::template setupCallExpectations<Case>(test);
1182 Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1183 }
1184};
1185
1186/* ------------------------------------------------------------------------
1187 * Composition test case, containing all the variants being tested
1188 */
1189
1190template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1191 typename CompositionResultCase>
1192struct CompositionCase {
1193 using ThisCase =
1194 CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1195 using Display = DisplayCase;
1196 using Layer = LayerCase;
1197 using CompositionType = CompositionTypeCase;
1198 using CompositionResult = CompositionResultCase;
1199
1200 static void setupCommon(CompositionTest* test) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -07001201 Display::template setupPreconditionCallExpectations<ThisCase>(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001202 Display::setupPreconditions(test);
1203
1204 auto layer = Layer::createLayer(test);
1205 Layer::injectLayer(test, layer);
1206 CompositionResult::setupLayerState(test, layer);
1207 }
1208
1209 static void setupForDirtyGeometry(CompositionTest* test) {
1210 setupCommon(test);
1211
1212 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1213 CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1214 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1215 CompositionResult::template setupCallExpectations<ThisCase>(test);
1216 }
1217
1218 static void setupForDirtyFrame(CompositionTest* test) {
1219 setupCommon(test);
1220
1221 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1222 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1223 CompositionResult::template setupCallExpectations<ThisCase>(test);
1224 }
1225
1226 static void setupForScreenCapture(CompositionTest* test) {
1227 setupCommon(test);
1228
1229 Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1230 CompositionResult::template setupCallExpectations<ThisCase>(test);
1231 }
1232
1233 static void cleanup(CompositionTest* test) {
1234 Layer::cleanupInjectedLayers(test);
1235
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001236 for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1237 static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1238 ->mutableLayers()
1239 .clear();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001240 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001241 }
1242};
1243
1244/* ------------------------------------------------------------------------
1245 * Composition cases to test
1246 */
1247
1248TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1249 displayRefreshCompositionDirtyGeometry<
1250 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1251 NoCompositionResultVariant>>();
1252}
1253
1254TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1255 displayRefreshCompositionDirtyFrame<
1256 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1257 NoCompositionResultVariant>>();
1258}
1259
1260TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1261 captureScreenComposition<
1262 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1263 EmptyScreenshotResultVariant>>();
1264}
1265
1266/* ------------------------------------------------------------------------
1267 * Simple buffer layers
1268 */
1269
1270TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001271 displayRefreshCompositionDirtyGeometry<CompositionCase<
1272 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1273 KeepCompositionTypeVariant<
1274 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1275 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001276}
1277
1278TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001279 displayRefreshCompositionDirtyFrame<CompositionCase<
1280 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1281 KeepCompositionTypeVariant<
1282 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1283 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001284}
1285
1286TEST_F(CompositionTest, REComposedNormalBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001287 displayRefreshCompositionDirtyFrame<CompositionCase<
1288 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1289 ChangeCompositionTypeVariant<
1290 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1291 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1292 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001293}
1294
1295TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1296 captureScreenComposition<
1297 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1298 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1299}
1300
1301/* ------------------------------------------------------------------------
1302 * Single-color layers
1303 */
1304
Vishnu Nairfa247b12020-02-11 08:58:26 -08001305TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001306 displayRefreshCompositionDirtyGeometry<CompositionCase<
1307 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1308 KeepCompositionTypeVariant<
1309 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1310 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001311}
1312
Vishnu Nairfa247b12020-02-11 08:58:26 -08001313TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001314 displayRefreshCompositionDirtyFrame<CompositionCase<
1315 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1316 KeepCompositionTypeVariant<
1317 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1318 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001319}
1320
Vishnu Nairfa247b12020-02-11 08:58:26 -08001321TEST_F(CompositionTest, REComposedEffectLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001322 displayRefreshCompositionDirtyFrame<CompositionCase<
1323 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1324 ChangeCompositionTypeVariant<
1325 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR,
1326 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1327 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001328}
1329
Vishnu Nairfa247b12020-02-11 08:58:26 -08001330TEST_F(CompositionTest, captureScreenEffectLayer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001331 captureScreenComposition<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001332 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001333 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1334}
1335
1336/* ------------------------------------------------------------------------
1337 * Layers with sideband buffers
1338 */
1339
1340TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001341 displayRefreshCompositionDirtyGeometry<CompositionCase<
1342 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1343 KeepCompositionTypeVariant<
1344 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1345 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001346}
1347
1348TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001349 displayRefreshCompositionDirtyFrame<CompositionCase<
1350 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1351 KeepCompositionTypeVariant<
1352 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1353 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001354}
1355
1356TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001357 displayRefreshCompositionDirtyFrame<CompositionCase<
1358 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1359 ChangeCompositionTypeVariant<
1360 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND,
1361 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1362 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001363}
1364
1365TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1366 captureScreenComposition<
1367 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1368 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1369}
1370
1371/* ------------------------------------------------------------------------
1372 * Layers with ISurfaceComposerClient::eSecure, on a secure display
1373 */
1374
1375TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001376 displayRefreshCompositionDirtyGeometry<CompositionCase<
1377 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1378 KeepCompositionTypeVariant<
1379 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1380 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001381}
1382
1383TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001384 displayRefreshCompositionDirtyFrame<CompositionCase<
1385 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1386 KeepCompositionTypeVariant<
1387 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1388 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001389}
1390
1391TEST_F(CompositionTest, REComposedSecureBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001392 displayRefreshCompositionDirtyFrame<CompositionCase<
1393 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1394 ChangeCompositionTypeVariant<
1395 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1396 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1397 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001398}
1399
1400TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1401 captureScreenComposition<
1402 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1403 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1404}
1405
1406/* ------------------------------------------------------------------------
1407 * Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1408 */
1409
1410TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001411 displayRefreshCompositionDirtyGeometry<CompositionCase<
1412 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1413 KeepCompositionTypeVariant<
1414 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1415 ForcedClientCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001416}
1417
1418TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001419 displayRefreshCompositionDirtyFrame<CompositionCase<
1420 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1421 KeepCompositionTypeVariant<
1422 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1423 ForcedClientCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001424}
1425
1426TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1427 captureScreenComposition<
1428 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1429 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1430}
1431
1432/* ------------------------------------------------------------------------
Garfield Tande619fa2020-10-02 17:13:53 -07001433 * Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1434 */
1435
1436TEST_F(CompositionTest,
1437 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001438 displayRefreshCompositionDirtyGeometry<CompositionCase<
1439 InsecureDisplaySetupVariant,
1440 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1441 ContainerLayerVariant<SecureLayerProperties>>,
1442 KeepCompositionTypeVariant<
1443 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1444 ForcedClientCompositionResultVariant>>();
Garfield Tande619fa2020-10-02 17:13:53 -07001445}
1446
1447TEST_F(CompositionTest,
1448 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001449 displayRefreshCompositionDirtyFrame<CompositionCase<
1450 InsecureDisplaySetupVariant,
1451 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1452 ContainerLayerVariant<SecureLayerProperties>>,
1453 KeepCompositionTypeVariant<
1454 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1455 ForcedClientCompositionResultVariant>>();
Garfield Tande619fa2020-10-02 17:13:53 -07001456}
1457
1458TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1459 captureScreenComposition<
1460 CompositionCase<InsecureDisplaySetupVariant,
1461 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1462 ContainerLayerVariant<SecureLayerProperties>>,
1463 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1464}
1465
1466/* ------------------------------------------------------------------------
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001467 * Cursor layers
1468 */
1469
1470TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001471 displayRefreshCompositionDirtyGeometry<CompositionCase<
1472 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1473 KeepCompositionTypeVariant<
1474 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1475 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001476}
1477
1478TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001479 displayRefreshCompositionDirtyFrame<CompositionCase<
1480 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1481 KeepCompositionTypeVariant<
1482 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1483 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001484}
1485
1486TEST_F(CompositionTest, REComposedCursorLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001487 displayRefreshCompositionDirtyFrame<CompositionCase<
1488 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1489 ChangeCompositionTypeVariant<
1490 aidl::android::hardware::graphics::composer3::Composition::CURSOR,
1491 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1492 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001493}
1494
1495TEST_F(CompositionTest, captureScreenCursorLayer) {
1496 captureScreenComposition<
1497 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1498 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1499}
1500
1501/* ------------------------------------------------------------------------
1502 * Simple buffer layer on a display which is powered off.
1503 */
1504
1505TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001506 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001507 displayRefreshCompositionDirtyGeometry<CompositionCase<
1508 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001509 KeepCompositionTypeVariant<
1510 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001511 HwcCompositionResultVariant>>();
1512}
1513
1514TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001515 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001516 displayRefreshCompositionDirtyFrame<CompositionCase<
1517 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001518 KeepCompositionTypeVariant<
1519 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001520 HwcCompositionResultVariant>>();
1521}
1522
1523TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001524 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001525 displayRefreshCompositionDirtyFrame<CompositionCase<
1526 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001527 ChangeCompositionTypeVariant<
1528 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1529 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001530 RECompositionResultVariant>>();
1531}
1532
1533TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1534 captureScreenComposition<CompositionCase<
1535 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1536 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1537}
1538
Lloyd Pique4fe29402019-08-12 16:51:24 -07001539/* ------------------------------------------------------------------------
1540 * Client composition forced through debug/developer settings
1541 */
1542
1543TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001544 displayRefreshCompositionDirtyGeometry<CompositionCase<
1545 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1546 KeepCompositionTypeVariant<
1547 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1548 ForcedClientCompositionViaDebugOptionResultVariant>>();
Lloyd Pique4fe29402019-08-12 16:51:24 -07001549}
1550
1551TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001552 displayRefreshCompositionDirtyFrame<CompositionCase<
1553 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1554 KeepCompositionTypeVariant<
1555 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1556 ForcedClientCompositionViaDebugOptionResultVariant>>();
Lloyd Pique4fe29402019-08-12 16:51:24 -07001557}
1558
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001559} // namespace
1560} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001561
1562// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01001563#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"