blob: beb2147c98d56e69971a10b8ec08edf5a98c518d [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/RenderEngine.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070035#include <system/window.h>
36#include <utils/String8.h>
37
Marin Shalamanovf6b5d182020-06-12 02:08:51 +020038#include "DisplayRenderArea.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070039#include "Layer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070040#include "TestableSurfaceFlinger.h"
41#include "mock/DisplayHardware/MockComposer.h"
Lloyd Pique9370a482019-10-03 17:58:30 -070042#include "mock/DisplayHardware/MockPowerAdvisor.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070043#include "mock/MockEventThread.h"
Alec Mourie4034bb2019-11-19 12:45:54 -080044#include "mock/MockTimeStats.h"
Ady Abraham8cb21882020-08-26 18:22:05 -070045#include "mock/MockVsyncController.h"
Alec Mouriba013fa2018-10-16 12:43:11 -070046#include "mock/system/window/MockNativeWindow.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070047
48namespace android {
49namespace {
50
Peiyong Line9d809e2020-04-14 13:10:48 -070051namespace hal = android::hardware::graphics::composer::hal;
52
Peiyong Lin65248e02020-04-18 21:15:07 -070053using hal::Error;
54using hal::IComposer;
55using hal::IComposerClient;
56using hal::PowerMode;
57using hal::Transform;
58
Ady Abrahamde549d42022-01-26 19:19:17 -080059using aidl::android::hardware::graphics::composer3::Capability;
60
Lloyd Piqued6b579f2018-04-06 15:29:10 -070061using testing::_;
David Sodman15094112018-10-11 09:39:37 -070062using testing::AtLeast;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070063using testing::DoAll;
64using testing::IsNull;
65using testing::Mock;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070066using testing::Return;
67using testing::ReturnRef;
68using testing::SetArgPointee;
69
Lloyd Piqued6b579f2018-04-06 15:29:10 -070070using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
71using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;
72
Peiyong Line9d809e2020-04-14 13:10:48 -070073constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DISPLAY_ID;
74constexpr hal::HWLayerId HWC_LAYER = 5000;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070075constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0);
76
Dominik Laskowskif1833852021-03-23 15:06:50 -070077constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(42u);
Lloyd Piqued6b579f2018-04-06 15:29:10 -070078constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
79constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
80
Lloyd Piqued6b579f2018-04-06 15:29:10 -070081constexpr int DEFAULT_TEXTURE_ID = 6000;
Dominik Laskowski29fa1462021-04-27 15:51:50 -070082constexpr ui::LayerStack LAYER_STACK{7000u};
Lloyd Piqued6b579f2018-04-06 15:29:10 -070083
84constexpr int DEFAULT_DISPLAY_MAX_LUMINANCE = 500;
85
86constexpr int DEFAULT_SIDEBAND_STREAM = 51;
87
Ady Abrahamdc011a92021-12-21 14:06:44 -080088MATCHER(IsIdentityMatrix, "") {
89 constexpr auto kIdentity = mat4();
90 return (mat4(arg) == kIdentity);
91}
92
Lloyd Piqued6b579f2018-04-06 15:29:10 -070093class CompositionTest : public testing::Test {
94public:
95 CompositionTest() {
96 const ::testing::TestInfo* const test_info =
97 ::testing::UnitTest::GetInstance()->current_test_info();
98 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
99
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500100 mFlinger.setupMockScheduler({.displayId = DEFAULT_DISPLAY_ID});
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700101
Alec Mourif6fd29e2018-11-17 04:56:41 +0000102 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
103 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
104 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
105 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700106
107 mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
Alec Mourie4034bb2019-11-19 12:45:54 -0800108 mFlinger.setupTimeStats(std::shared_ptr<TimeStats>(mTimeStats));
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800109
110 mComposer = new Hwc2::mock::Composer();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000111 mPowerAdvisor = new Hwc2::mock::PowerAdvisor();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800112 mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
Xiang Wang839fe5b2022-04-04 17:39:38 +0000113 mFlinger.setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor>(mPowerAdvisor));
Garfield Tan9c9c1912021-07-19 12:02:16 -0700114 mFlinger.mutableMaxRenderTargetSize() = 16384;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700115 }
116
117 ~CompositionTest() {
118 const ::testing::TestInfo* const test_info =
119 ::testing::UnitTest::GetInstance()->current_test_info();
120 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
121 }
122
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700123 void setupForceGeometryDirty() {
124 // TODO: This requires the visible region and other related
125 // state to be set, and is problematic for BufferLayers since they are
126 // not visible without a buffer (and setting up a buffer looks like a
127 // pain)
128 // mFlinger.mutableVisibleRegionsDirty() = true;
129
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700130 mFlinger.mutableGeometryDirty() = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700131 }
132
133 template <typename Case>
134 void displayRefreshCompositionDirtyGeometry();
135
136 template <typename Case>
137 void displayRefreshCompositionDirtyFrame();
138
139 template <typename Case>
140 void captureScreenComposition();
141
Ady Abrahamde549d42022-01-26 19:19:17 -0800142 std::unordered_set<Capability> mDefaultCapabilities = {Capability::SIDEBAND_STREAM};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700143
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800144 bool mDisplayOff = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700145 TestableSurfaceFlinger mFlinger;
146 sp<DisplayDevice> mDisplay;
Lloyd Pique542307f2018-10-19 13:24:08 -0700147 sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
Ady Abrahamd11bade2022-08-01 16:18:03 -0700148 sp<compositionengine::mock::DisplaySurface>::make();
149 sp<mock::NativeWindow> mNativeWindow = sp<mock::NativeWindow>::make();
Garfield Tande619fa2020-10-02 17:13:53 -0700150 std::vector<sp<Layer>> mAuxiliaryLayers;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700151
Brian Lindahlf5ab5ae2022-12-21 14:27:15 -0700152 sp<GraphicBuffer> mBuffer =
153 sp<GraphicBuffer>::make(1u, 1u, PIXEL_FORMAT_RGBA_8888,
154 GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN);
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800155 ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();
156
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700157 Hwc2::mock::Composer* mComposer = nullptr;
158 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
Alec Mourie4034bb2019-11-19 12:45:54 -0800159 mock::TimeStats* mTimeStats = new mock::TimeStats();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000160 Hwc2::mock::PowerAdvisor* mPowerAdvisor = nullptr;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700161
162 sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;
163
Alec Mouria90a5702021-04-16 16:36:21 +0000164 std::shared_ptr<renderengine::ExternalTexture> mCaptureScreenBuffer;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700165};
166
167template <typename LayerCase>
168void CompositionTest::displayRefreshCompositionDirtyGeometry() {
169 setupForceGeometryDirty();
170 LayerCase::setupForDirtyGeometry(this);
171
172 // --------------------------------------------------------------------
173 // Invocation
174
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700175 mFlinger.commitAndComposite();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700176
177 LayerCase::cleanup(this);
178}
179
180template <typename LayerCase>
181void CompositionTest::displayRefreshCompositionDirtyFrame() {
182 LayerCase::setupForDirtyFrame(this);
183
184 // --------------------------------------------------------------------
185 // Invocation
186
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700187 mFlinger.commitAndComposite();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700188
189 LayerCase::cleanup(this);
190}
191
192template <typename LayerCase>
193void CompositionTest::captureScreenComposition() {
194 LayerCase::setupForScreenCapture(this);
195
196 const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
Lucas Dupin9d763b72020-04-20 18:42:31 -0700197 constexpr bool regionSampling = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700198
Marin Shalamanov1c434292020-06-12 01:47:29 +0200199 auto renderArea = DisplayRenderArea::create(mDisplay, sourceCrop, sourceCrop.getSize(),
Alec Mouri3e5965f2023-04-07 18:00:58 +0000200 ui::Dataspace::V0_SRGB, true, true);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700201
202 auto traverseLayers = [this](const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700203 return mFlinger.traverseLayersInLayerStack(mDisplay->getLayerStack(),
Ajinkya Chalke02844632023-03-01 12:10:14 +0000204 CaptureArgs::UNSET_UID, {}, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700205 };
206
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000207 auto getLayerSnapshots = RenderArea::fromTraverseLayersLambda(traverseLayers);
208
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700209 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
210 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800211 mCaptureScreenBuffer =
212 std::make_shared<renderengine::mock::FakeExternalTexture>(renderArea->getReqWidth(),
213 renderArea->getReqHeight(),
214 HAL_PIXEL_FORMAT_RGBA_8888, 1,
215 usage);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700216
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000217 auto future = mFlinger.renderScreenImpl(std::move(renderArea), getLayerSnapshots,
Chavi Weingartenf5fb5b02023-11-30 17:27:52 +0000218 mCaptureScreenBuffer, regionSampling);
Dominik Laskowskibb448ce2022-05-07 15:52:55 -0700219 ASSERT_TRUE(future.valid());
220 const auto fenceResult = future.get();
Sally Qi59a9f502021-10-12 18:53:23 +0000221
Dominik Laskowskibb448ce2022-05-07 15:52:55 -0700222 EXPECT_EQ(NO_ERROR, fenceStatus(fenceResult));
223 if (fenceResult.ok()) {
224 fenceResult.value()->waitForever(LOG_TAG);
Sally Qi59a9f502021-10-12 18:53:23 +0000225 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700226
227 LayerCase::cleanup(this);
228}
229
Sally Qi4cabdd02021-08-05 16:45:57 -0700230template <class T>
231std::future<T> futureOf(T obj) {
232 std::promise<T> resultPromise;
233 std::future<T> resultFuture = resultPromise.get_future();
234 resultPromise.set_value(std::move(obj));
235 return resultFuture;
236}
237
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700238/* ------------------------------------------------------------------------
239 * Variants for each display configuration which can be tested
240 */
241
242template <typename Derived>
243struct BaseDisplayVariant {
244 static constexpr bool IS_SECURE = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700245 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700246
247 static void setupPreconditions(CompositionTest* test) {
Peiyong Lin65248e02020-04-18 21:15:07 -0700248 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700249 .WillOnce(Return(Error::NONE));
Alec Mouriba013fa2018-10-16 12:43:11 -0700250
Peiyong Line9d809e2020-04-14 13:10:48 -0700251 FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700252 .setCapabilities(&test->mDefaultCapabilities)
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700253 .setPowerMode(Derived::INIT_POWER_MODE)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700254 .inject(&test->mFlinger, test->mComposer);
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800255 Mock::VerifyAndClear(test->mComposer);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700256
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800257 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
258 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
259 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
260 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
261 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
262 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
263 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
Lloyd Pique9370a482019-10-03 17:58:30 -0700264
265 const ::testing::TestInfo* const test_info =
266 ::testing::UnitTest::GetInstance()->current_test_info();
267
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800268 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
269 .setId(DEFAULT_DISPLAY_ID)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800270 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
271 .setIsSecure(Derived::IS_SECURE)
Xiang Wang839fe5b2022-04-04 17:39:38 +0000272 .setPowerAdvisor(test->mPowerAdvisor)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800273 .setName(std::string("Injected display for ") +
274 test_info->test_case_name() + "." + test_info->name())
275 .build();
Lloyd Pique9370a482019-10-03 17:58:30 -0700276
277 auto compositionDisplay =
278 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
279 ceDisplayArgs);
280
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700281 constexpr auto kDisplayConnectionType = ui::DisplayConnectionType::Internal;
282 constexpr bool kIsPrimary = true;
283
Leon Scroggins IIIba9323a2023-02-22 10:40:20 -0500284 test->mDisplay =
285 FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
286 kDisplayConnectionType, HWC_DISPLAY, kIsPrimary)
287 .setDisplaySurface(test->mDisplaySurface)
288 .setNativeWindow(test->mNativeWindow)
289 .setSecure(Derived::IS_SECURE)
290 .setPowerMode(Derived::INIT_POWER_MODE)
291 .setRefreshRateSelector(test->mFlinger.scheduler()->refreshRateSelector())
292 .skipRegisterDisplay()
293 .inject();
Ady Abrahamd11bade2022-08-01 16:18:03 -0700294 Mock::VerifyAndClear(test->mNativeWindow.get());
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700295
296 constexpr bool kIsInternal = kDisplayConnectionType == ui::DisplayConnectionType::Internal;
297 test->mDisplay->setLayerFilter({LAYER_STACK, kIsInternal});
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700298 }
299
300 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700301 static void setupPreconditionCallExpectations(CompositionTest* test) {
302 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500303 .WillOnce(DoAll(SetArgPointee<1>(
304 std::vector<aidl::android::hardware::graphics::composer3::
305 DisplayCapability>({})),
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700306 Return(Error::NONE)));
307 }
308
309 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700310 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
Ady Abrahamdc011a92021-12-21 14:06:44 -0800311 EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700312 EXPECT_CALL(*test->mComposer, getDisplayRequests(HWC_DISPLAY, _, _, _)).Times(1);
313 EXPECT_CALL(*test->mComposer, acceptDisplayChanges(HWC_DISPLAY)).Times(1);
314 EXPECT_CALL(*test->mComposer, presentDisplay(HWC_DISPLAY, _)).Times(1);
315 EXPECT_CALL(*test->mComposer, getReleaseFences(HWC_DISPLAY, _, _)).Times(1);
316
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700317 EXPECT_CALL(*test->mDisplaySurface, onFrameCommitted()).Times(1);
Alec Mourif97df4d2023-09-06 02:10:05 +0000318 EXPECT_CALL(*test->mDisplaySurface, advanceFrame(_)).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700319
320 Case::CompositionType::setupHwcSetCallExpectations(test);
321 Case::CompositionType::setupHwcGetCallExpectations(test);
322 }
323
324 template <typename Case>
325 static void setupCommonScreensCaptureCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000326 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700327 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000328 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -0700329 const std::shared_ptr<renderengine::ExternalTexture>&,
Alec Mourif29700f2023-08-17 21:53:31 +0000330 base::unique_fd&&) -> std::future<FenceResult> {
Lloyd Pique9370a482019-10-03 17:58:30 -0700331 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
332 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
333 displaySettings.physicalDisplay);
334 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
335 displaySettings.clip);
Patrick Williams2e9748f2022-08-09 22:48:18 +0000336 return futureOf<FenceResult>(Fence::NO_FENCE);
Lloyd Pique9370a482019-10-03 17:58:30 -0700337 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700338 }
339
340 static void setupNonEmptyFrameCompositionCallExpectations(CompositionTest* test) {
341 EXPECT_CALL(*test->mDisplaySurface, beginFrame(true)).Times(1);
342 }
343
344 static void setupEmptyFrameCompositionCallExpectations(CompositionTest* test) {
345 EXPECT_CALL(*test->mDisplaySurface, beginFrame(false)).Times(1);
346 }
347
348 static void setupHwcCompositionCallExpectations(CompositionTest* test) {
ramindani4aac32c2023-10-30 14:13:30 -0700349 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _, _))
Ady Abraham43065bd2021-12-10 17:22:15 -0800350 .Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800351
Lloyd Pique542307f2018-10-19 13:24:08 -0700352 EXPECT_CALL(*test->mDisplaySurface,
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700353 prepareFrame(compositionengine::DisplaySurface::CompositionType::Hwc))
Lloyd Pique542307f2018-10-19 13:24:08 -0700354 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700355 }
356
Lloyd Pique66d68602019-02-13 14:23:31 -0800357 static void setupHwcClientCompositionCallExpectations(CompositionTest* test) {
ramindani4aac32c2023-10-30 14:13:30 -0700358 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _, _))
Ady Abraham43065bd2021-12-10 17:22:15 -0800359 .Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800360 }
361
362 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
ramindani09acbb82023-11-03 09:02:38 -0700363 EXPECT_CALL(*test->mComposer, validateDisplay(HWC_DISPLAY, _, _, _, _)).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800364 }
365
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700366 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Pique542307f2018-10-19 13:24:08 -0700367 EXPECT_CALL(*test->mDisplaySurface,
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700368 prepareFrame(compositionengine::DisplaySurface::CompositionType::Gpu))
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700369 .Times(1);
370 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
371 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
372
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800373 EXPECT_CALL(*test->mNativeWindow, queueBuffer(_, _)).WillOnce(Return(0));
374 EXPECT_CALL(*test->mNativeWindow, dequeueBuffer(_, _))
375 .WillOnce(DoAll(SetArgPointee<0>(test->mNativeWindowBuffer), SetArgPointee<1>(-1),
376 Return(0)));
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000377 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700378 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000379 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -0700380 const std::shared_ptr<renderengine::ExternalTexture>&,
Alec Mourif29700f2023-08-17 21:53:31 +0000381 base::unique_fd&&) -> std::future<FenceResult> {
Lloyd Pique9370a482019-10-03 17:58:30 -0700382 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
383 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
384 displaySettings.physicalDisplay);
385 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
386 displaySettings.clip);
387 EXPECT_EQ(ui::Dataspace::UNKNOWN, displaySettings.outputDataspace);
Patrick Williams2e9748f2022-08-09 22:48:18 +0000388 return futureOf<FenceResult>(Fence::NO_FENCE);
Lloyd Pique9370a482019-10-03 17:58:30 -0700389 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700390 }
391
392 template <typename Case>
393 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
394 Case::Layer::setupRECompositionCallExpectations(test);
395 }
396
397 template <typename Case>
398 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
399 Case::Layer::setupREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700400 }
401};
402
403struct DefaultDisplaySetupVariant : public BaseDisplayVariant<DefaultDisplaySetupVariant> {};
404
405struct InsecureDisplaySetupVariant : public BaseDisplayVariant<InsecureDisplaySetupVariant> {
406 static constexpr bool IS_SECURE = false;
407
408 template <typename Case>
409 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
410 Case::Layer::setupInsecureRECompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700411 }
412
413 template <typename Case>
414 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
415 Case::Layer::setupInsecureREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700416 }
417};
418
419struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDisplaySetupVariant> {
Peiyong Lin65248e02020-04-18 21:15:07 -0700420 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::OFF;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700421
422 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700423 static void setupPreconditionCallExpectations(CompositionTest*) {}
424
425 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700426 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
427 // TODO: This seems like an unnecessary call if display is powered off.
Ady Abrahamdc011a92021-12-21 14:06:44 -0800428 EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700429
430 // TODO: This seems like an unnecessary call if display is powered off.
431 Case::CompositionType::setupHwcSetCallExpectations(test);
432 }
433
434 static void setupHwcCompositionCallExpectations(CompositionTest*) {}
Lloyd Pique66d68602019-02-13 14:23:31 -0800435 static void setupHwcClientCompositionCallExpectations(CompositionTest*) {}
436 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest*) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700437
438 static void setupRECompositionCallExpectations(CompositionTest* test) {
439 // TODO: This seems like an unnecessary call if display is powered off.
440 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
441 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
442 }
443
444 template <typename Case>
445 static void setupRELayerCompositionCallExpectations(CompositionTest*) {}
446};
447
448/* ------------------------------------------------------------------------
449 * Variants for each layer configuration which can be tested
450 */
451
452template <typename LayerProperties>
453struct BaseLayerProperties {
454 static constexpr uint32_t WIDTH = 100;
455 static constexpr uint32_t HEIGHT = 100;
456 static constexpr PixelFormat FORMAT = PIXEL_FORMAT_RGBA_8888;
457 static constexpr uint64_t USAGE =
458 GraphicBuffer::USAGE_SW_READ_NEVER | GraphicBuffer::USAGE_SW_WRITE_NEVER;
459 static constexpr android_dataspace DATASPACE = HAL_DATASPACE_UNKNOWN;
460 static constexpr uint32_t SCALING_MODE = 0;
461 static constexpr uint32_t TRANSFORM = 0;
462 static constexpr uint32_t LAYER_FLAGS = 0;
463 static constexpr float COLOR[] = {1.f, 1.f, 1.f, 1.f};
464 static constexpr IComposerClient::BlendMode BLENDMODE =
465 IComposerClient::BlendMode::PREMULTIPLIED;
466
Patrick Williams83f36b22022-09-14 17:57:35 +0000467 static void setupLatchedBuffer(CompositionTest* test, sp<Layer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700468 Mock::VerifyAndClear(test->mRenderEngine);
469
Vishnu Nairf8a873a2022-06-15 17:34:34 +0000470 const auto buffer = std::make_shared<
471 renderengine::mock::FakeExternalTexture>(LayerProperties::WIDTH,
472 LayerProperties::HEIGHT,
473 DEFAULT_TEXTURE_ID,
474 LayerProperties::FORMAT,
475 LayerProperties::USAGE |
476 GraphicBuffer::USAGE_HW_TEXTURE);
477
478 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
479 layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
480 layerDrawingState.buffer = buffer;
481 layerDrawingState.acquireFence = Fence::NO_FENCE;
482 layerDrawingState.dataspace = ui::Dataspace::UNKNOWN;
483 layer->setSurfaceDamageRegion(
484 Region(Rect(LayerProperties::HEIGHT, LayerProperties::WIDTH)));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700485
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700486 bool ignoredRecomputeVisibleRegions;
Vishnu Nair397a0e32022-07-26 00:01:48 +0000487 layer->latchBuffer(ignoredRecomputeVisibleRegions, 0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700488 Mock::VerifyAndClear(test->mRenderEngine);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700489 }
490
Patrick Williams83f36b22022-09-14 17:57:35 +0000491 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700492 setupLatchedBuffer(test, layer);
493 }
494
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700495 static void setupHwcSetGeometryCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800496 if (!test->mDisplayOff) {
497 // TODO: Coverage of other values
498 EXPECT_CALL(*test->mComposer,
499 setLayerBlendMode(HWC_DISPLAY, HWC_LAYER, LayerProperties::BLENDMODE))
500 .Times(1);
501 // TODO: Coverage of other values for origin
502 EXPECT_CALL(*test->mComposer,
503 setLayerDisplayFrame(HWC_DISPLAY, HWC_LAYER,
504 IComposerClient::Rect({0, 0, LayerProperties::WIDTH,
505 LayerProperties::HEIGHT})))
506 .Times(1);
507 EXPECT_CALL(*test->mComposer,
508 setLayerPlaneAlpha(HWC_DISPLAY, HWC_LAYER, LayerProperties::COLOR[3]))
509 .Times(1);
510 // TODO: Coverage of other values
511 EXPECT_CALL(*test->mComposer, setLayerZOrder(HWC_DISPLAY, HWC_LAYER, 0u)).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700512
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800513 // These expectations retire on saturation as the code path these
514 // expectations are for appears to make an extra call to them.
515 // TODO: Investigate this extra call
516 EXPECT_CALL(*test->mComposer,
517 setLayerTransform(HWC_DISPLAY, HWC_LAYER, DEFAULT_TRANSFORM))
518 .Times(AtLeast(1))
519 .RetiresOnSaturation();
520 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700521 }
522
523 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800524 if (!test->mDisplayOff) {
525 EXPECT_CALL(*test->mComposer,
526 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
527 IComposerClient::FRect({0.f, 0.f, LayerProperties::WIDTH,
528 LayerProperties::HEIGHT})))
529 .Times(1);
530 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700531 }
532
533 static void setupHwcSetSourceCropColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800534 if (!test->mDisplayOff) {
535 EXPECT_CALL(*test->mComposer,
536 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
537 IComposerClient::FRect({0.f, 0.f, 0.f, 0.f})))
538 .Times(1);
539 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700540 }
541
542 static void setupHwcSetPerFrameCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800543 if (!test->mDisplayOff) {
544 EXPECT_CALL(*test->mComposer,
545 setLayerVisibleRegion(HWC_DISPLAY, HWC_LAYER,
546 std::vector<IComposerClient::Rect>(
547 {IComposerClient::Rect(
548 {0, 0, LayerProperties::WIDTH,
549 LayerProperties::HEIGHT})})))
550 .Times(1);
551 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700552 }
553
554 static void setupHwcSetPerFrameColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800555 if (!test->mDisplayOff) {
556 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
557 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700558
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800559 // TODO: use COLOR
560 EXPECT_CALL(*test->mComposer,
561 setLayerColor(HWC_DISPLAY, HWC_LAYER,
Ady Abraham6e60b142022-01-06 18:10:35 -0800562 aidl::android::hardware::graphics::composer3::Color(
563 {1.0f, 1.0f, 1.0f, 1.0f})))
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800564 .Times(1);
565 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700566 }
567
568 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800569 if (!test->mDisplayOff) {
570 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
571 .Times(1);
572 EXPECT_CALL(*test->mComposer, setLayerBuffer(HWC_DISPLAY, HWC_LAYER, _, _, _)).Times(1);
573 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700574 }
575
576 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000577 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700578 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000579 const std::vector<renderengine::LayerSettings>& layerSettings,
Alec Mourif29700f2023-08-17 21:53:31 +0000580 const std::shared_ptr<renderengine::ExternalTexture>&,
Patrick Williams2e9748f2022-08-09 22:48:18 +0000581 base::unique_fd&&) -> std::future<FenceResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000582 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
583 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
584 displaySettings.physicalDisplay);
585 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
586 displaySettings.clip);
587 // screen capture adds an additional color layer as an alpha
588 // prefill, so gtet the back layer.
Patrick Williams2e9748f2022-08-09 22:48:18 +0000589 std::future<FenceResult> resultFuture = futureOf<FenceResult>(Fence::NO_FENCE);
Lloyd Piquea2468662019-03-07 21:31:06 -0800590 if (layerSettings.empty()) {
591 ADD_FAILURE() << "layerSettings was not expected to be empty in "
592 "setupREBufferCompositionCommonCallExpectations "
593 "verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700594 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800595 }
Sally Qi59a9f502021-10-12 18:53:23 +0000596 const renderengine::LayerSettings layer = layerSettings.back();
597 EXPECT_THAT(layer.source.buffer.buffer, Not(IsNull()));
598 EXPECT_THAT(layer.source.buffer.fence, Not(IsNull()));
Sally Qi59a9f502021-10-12 18:53:23 +0000599 EXPECT_EQ(true, layer.source.buffer.usePremultipliedAlpha);
600 EXPECT_EQ(false, layer.source.buffer.isOpaque);
Vishnu Nair50c0afe2022-07-11 15:04:07 -0700601 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
602 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
Alec Mouri74c7ae12023-03-26 02:57:47 +0000603 EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
Sally Qi59a9f502021-10-12 18:53:23 +0000604 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700605 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000606 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700607 }
608
609 static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
610 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700611 }
612
613 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
614 setupREBufferCompositionCallExpectations(test);
615 }
616
617 static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
618 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
619 }
620
621 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
622 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
623 }
624
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700625 static void setupREColorCompositionCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000626 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700627 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000628 const std::vector<renderengine::LayerSettings>& layerSettings,
Alec Mourif29700f2023-08-17 21:53:31 +0000629 const std::shared_ptr<renderengine::ExternalTexture>&,
Patrick Williams2e9748f2022-08-09 22:48:18 +0000630 base::unique_fd&&) -> std::future<FenceResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000631 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
632 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
633 displaySettings.physicalDisplay);
634 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
635 displaySettings.clip);
636 // screen capture adds an additional color layer as an alpha
637 // prefill, so get the back layer.
Patrick Williams2e9748f2022-08-09 22:48:18 +0000638 std::future<FenceResult> resultFuture = futureOf<FenceResult>(Fence::NO_FENCE);
Lloyd Piquea2468662019-03-07 21:31:06 -0800639 if (layerSettings.empty()) {
640 ADD_FAILURE()
641 << "layerSettings was not expected to be empty in "
642 "setupREColorCompositionCallExpectations verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700643 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800644 }
Sally Qi59a9f502021-10-12 18:53:23 +0000645 const renderengine::LayerSettings layer = layerSettings.back();
646 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000647 EXPECT_EQ(half3(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
648 LayerProperties::COLOR[2]),
Sally Qi59a9f502021-10-12 18:53:23 +0000649 layer.source.solidColor);
Vishnu Nair50c0afe2022-07-11 15:04:07 -0700650 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
651 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
Alec Mouri74c7ae12023-03-26 02:57:47 +0000652 EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
Sally Qi59a9f502021-10-12 18:53:23 +0000653 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700654 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000655 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700656 }
657
658 static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
659 setupREColorCompositionCallExpectations(test);
660 }
661};
662
663struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
664
Vishnu Nairfa247b12020-02-11 08:58:26 -0800665struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
Alec Mourida8a9d12020-01-30 20:00:31 -0800666 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
667};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700668
669struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
670 using Base = BaseLayerProperties<SidebandLayerProperties>;
671 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
672
Patrick Williams83f36b22022-09-14 17:57:35 +0000673 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700674 sp<NativeHandle> stream =
675 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
676 false);
677 test->mFlinger.setLayerSidebandStream(layer, stream);
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700678 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
679 layerDrawingState.crop =
680 Rect(0, 0, SidebandLayerProperties::HEIGHT, SidebandLayerProperties::WIDTH);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700681 }
682
683 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
684 EXPECT_CALL(*test->mComposer,
685 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
686 IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
687 .Times(1);
688 }
689
690 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
691 EXPECT_CALL(*test->mComposer,
692 setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
693 reinterpret_cast<native_handle_t*>(
694 DEFAULT_SIDEBAND_STREAM)))
695 .WillOnce(Return(Error::NONE));
696
697 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
698 }
699
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000700 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700701};
702
Garfield Tande619fa2020-10-02 17:13:53 -0700703template <typename LayerProperties>
704struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
705 using Base = BaseLayerProperties<LayerProperties>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700706
707 static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000708 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700709 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000710 const std::vector<renderengine::LayerSettings>& layerSettings,
Alec Mourif29700f2023-08-17 21:53:31 +0000711 const std::shared_ptr<renderengine::ExternalTexture>&,
Patrick Williams2e9748f2022-08-09 22:48:18 +0000712 base::unique_fd&&) -> std::future<FenceResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000713 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
714 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
715 displaySettings.physicalDisplay);
716 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
717 displaySettings.clip);
718 // screen capture adds an additional color layer as an alpha
719 // prefill, so get the back layer.
Patrick Williams2e9748f2022-08-09 22:48:18 +0000720 std::future<FenceResult> resultFuture = futureOf<FenceResult>(Fence::NO_FENCE);
Lloyd Piquea2468662019-03-07 21:31:06 -0800721 if (layerSettings.empty()) {
722 ADD_FAILURE() << "layerSettings was not expected to be empty in "
723 "setupInsecureREBufferCompositionCommonCallExpectations "
724 "verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700725 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800726 }
Sally Qi59a9f502021-10-12 18:53:23 +0000727 const renderengine::LayerSettings layer = layerSettings.back();
728 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
729 EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer.source.solidColor);
Vishnu Nair50c0afe2022-07-11 15:04:07 -0700730 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
731 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
Alec Mouri74c7ae12023-03-26 02:57:47 +0000732 EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
Sally Qi59a9f502021-10-12 18:53:23 +0000733 EXPECT_EQ(1.0f, layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700734 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000735 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700736 }
737
738 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
739 setupInsecureREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700740 }
741
742 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
743 setupInsecureREBufferCompositionCommonCallExpectations(test);
744 }
745};
746
Garfield Tande619fa2020-10-02 17:13:53 -0700747struct ParentSecureLayerProperties
748 : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
749
750struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
751 static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
752};
753
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700754struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
755 using Base = BaseLayerProperties<CursorLayerProperties>;
756
Patrick Williams83f36b22022-09-14 17:57:35 +0000757 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700758 Base::setupLayerState(test, layer);
759 test->mFlinger.setLayerPotentialCursor(layer, true);
760 }
761};
762
763struct NoLayerVariant {
Patrick Williams83f36b22022-09-14 17:57:35 +0000764 using FlingerLayerType = sp<Layer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700765
766 static FlingerLayerType createLayer(CompositionTest*) { return FlingerLayerType(); }
767 static void injectLayer(CompositionTest*, FlingerLayerType) {}
768 static void cleanupInjectedLayers(CompositionTest*) {}
769
770 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
771 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
772};
773
774template <typename LayerProperties>
775struct BaseLayerVariant {
776 template <typename L, typename F>
777 static sp<L> createLayerWithFactory(CompositionTest* test, F factory) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700778 EXPECT_CALL(*test->mFlinger.scheduler(), postMessage(_)).Times(0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700779
780 sp<L> layer = factory();
781
Dominik Laskowski49cea512019-11-12 14:13:23 -0800782 // Layer should be registered with scheduler.
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700783 EXPECT_EQ(1u, test->mFlinger.scheduler()->layerHistorySize());
Dominik Laskowski49cea512019-11-12 14:13:23 -0800784
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700785 Mock::VerifyAndClear(test->mComposer);
786 Mock::VerifyAndClear(test->mRenderEngine);
Dominik Laskowski756b7892021-08-04 12:53:59 -0700787 Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700788
Garfield Tande619fa2020-10-02 17:13:53 -0700789 initLayerDrawingStateAndComputeBounds(test, layer);
790
791 return layer;
792 }
793
794 template <typename L>
795 static void initLayerDrawingStateAndComputeBounds(CompositionTest* test, sp<L> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700796 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700797 layerDrawingState.layerStack = LAYER_STACK;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700798 layerDrawingState.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
799 LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700800 layer->computeBounds(FloatRect(0, 0, 100, 100), ui::Transform(), 0.f /* shadowRadius */);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700801 }
802
803 static void injectLayer(CompositionTest* test, sp<Layer> layer) {
804 EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
805 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
806
Lloyd Piquede196652020-01-22 17:29:58 -0800807 auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
808 layer->getCompositionEngineLayerFE());
Lloyd Pique01c77c12019-04-17 12:48:32 -0700809 outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
810 outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700811
812 Mock::VerifyAndClear(test->mComposer);
813
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700814 test->mFlinger.mutableDrawingState().layersSortedByZ.add(layer);
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700815 test->mFlinger.mutableVisibleRegionsDirty() = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700816 }
817
818 static void cleanupInjectedLayers(CompositionTest* test) {
819 EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
820 .WillOnce(Return(Error::NONE));
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800821
Lloyd Pique01c77c12019-04-17 12:48:32 -0700822 test->mDisplay->getCompositionDisplay()->clearOutputLayers();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700823 test->mFlinger.mutableDrawingState().layersSortedByZ.clear();
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700824 test->mFlinger.mutablePreviouslyComposedLayers().clear();
Dominik Laskowski49cea512019-11-12 14:13:23 -0800825
826 // Layer should be unregistered with scheduler.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700827 test->mFlinger.commit();
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700828 EXPECT_EQ(0u, test->mFlinger.scheduler()->layerHistorySize());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700829 }
830};
831
832template <typename LayerProperties>
Vishnu Nairfa247b12020-02-11 08:58:26 -0800833struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700834 using Base = BaseLayerVariant<LayerProperties>;
Patrick Williams46b61b92022-09-01 17:25:49 +0000835 using FlingerLayerType = sp<Layer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700836
837 static FlingerLayerType createLayer(CompositionTest* test) {
Patrick Williams46b61b92022-09-01 17:25:49 +0000838 FlingerLayerType layer = Base::template createLayerWithFactory<Layer>(test, [test]() {
839 return sp<Layer>::make(LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(),
840 "test-layer", LayerProperties::LAYER_FLAGS,
841 LayerMetadata()));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700842 });
Vishnu Nair60356342018-11-13 13:00:45 -0800843
844 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
chaviw25714502021-02-11 10:01:08 -0800845 layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700846 return layer;
847 }
848
849 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700850 LayerProperties::setupREColorCompositionCallExpectations(test);
851 }
852
853 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
854 LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
855 }
856
857 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
858 LayerProperties::setupHwcSetGeometryCallExpectations(test);
859 LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
860 }
861
862 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
863 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
864 LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
865 }
866};
867
868template <typename LayerProperties>
869struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
870 using Base = BaseLayerVariant<LayerProperties>;
Patrick Williams83f36b22022-09-14 17:57:35 +0000871 using FlingerLayerType = sp<Layer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700872
873 static FlingerLayerType createLayer(CompositionTest* test) {
Alec Mouric3a17822023-08-16 14:56:30 +0000874 FlingerLayerType layer = Base::template createLayerWithFactory<Layer>(test, [test]() {
875 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
876 LayerProperties::LAYER_FLAGS, LayerMetadata());
877 return sp<Layer>::make(args);
878 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700879
880 LayerProperties::setupLayerState(test, layer);
881
882 return layer;
883 }
884
885 static void cleanupInjectedLayers(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700886 Base::cleanupInjectedLayers(test);
887 }
888
889 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
890 LayerProperties::setupHwcSetGeometryCallExpectations(test);
891 LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
892 }
893
894 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
895 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
896 LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
897 }
898
899 static void setupRECompositionCallExpectations(CompositionTest* test) {
900 LayerProperties::setupREBufferCompositionCallExpectations(test);
901 }
902
903 static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
904 LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
905 }
906
907 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
908 LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
909 }
910
911 static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
912 LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
913 }
914};
915
Garfield Tande619fa2020-10-02 17:13:53 -0700916template <typename LayerProperties>
917struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
918 using Base = BaseLayerVariant<LayerProperties>;
Patrick Williams46b61b92022-09-01 17:25:49 +0000919 using FlingerLayerType = sp<Layer>;
Garfield Tande619fa2020-10-02 17:13:53 -0700920
921 static FlingerLayerType createLayer(CompositionTest* test) {
922 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
Garfield Tande619fa2020-10-02 17:13:53 -0700923 LayerProperties::LAYER_FLAGS, LayerMetadata());
Patrick Williams46b61b92022-09-01 17:25:49 +0000924 FlingerLayerType layer = sp<Layer>::make(args);
Garfield Tande619fa2020-10-02 17:13:53 -0700925 Base::template initLayerDrawingStateAndComputeBounds(test, layer);
926 return layer;
927 }
928};
929
930template <typename LayerVariant, typename ParentLayerVariant>
931struct ChildLayerVariant : public LayerVariant {
932 using Base = LayerVariant;
933 using FlingerLayerType = typename LayerVariant::FlingerLayerType;
934 using ParentBase = ParentLayerVariant;
935
936 static FlingerLayerType createLayer(CompositionTest* test) {
937 // Need to create child layer first. Otherwise layer history size will be 2.
938 FlingerLayerType layer = Base::createLayer(test);
939
940 typename ParentBase::FlingerLayerType parentLayer = ParentBase::createLayer(test);
941 parentLayer->addChild(layer);
942 test->mFlinger.setLayerDrawingParent(layer, parentLayer);
943
944 test->mAuxiliaryLayers.push_back(parentLayer);
945
946 return layer;
947 }
948
949 static void cleanupInjectedLayers(CompositionTest* test) {
950 // Clear auxiliary layers first so that child layer can be successfully destroyed in the
951 // following call.
952 test->mAuxiliaryLayers.clear();
953
954 Base::cleanupInjectedLayers(test);
955 }
956};
957
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700958/* ------------------------------------------------------------------------
959 * Variants to control how the composition type is changed
960 */
961
962struct NoCompositionTypeVariant {
963 static void setupHwcSetCallExpectations(CompositionTest*) {}
964
965 static void setupHwcGetCallExpectations(CompositionTest* test) {
966 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
967 }
968};
969
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500970template <aidl::android::hardware::graphics::composer3::Composition CompositionType>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700971struct KeepCompositionTypeVariant {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500972 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
973 CompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700974
975 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800976 if (!test->mDisplayOff) {
977 EXPECT_CALL(*test->mComposer,
978 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
979 .Times(1);
980 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700981 }
982
983 static void setupHwcGetCallExpectations(CompositionTest* test) {
984 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
985 }
986};
987
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500988template <aidl::android::hardware::graphics::composer3::Composition InitialCompositionType,
989 aidl::android::hardware::graphics::composer3::Composition FinalCompositionType>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700990struct ChangeCompositionTypeVariant {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500991 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
992 FinalCompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700993
994 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800995 if (!test->mDisplayOff) {
996 EXPECT_CALL(*test->mComposer,
997 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
998 .Times(1);
999 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001000 }
1001
1002 static void setupHwcGetCallExpectations(CompositionTest* test) {
1003 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
1004 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
1005 static_cast<Hwc2::Layer>(HWC_LAYER)}),
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001006 SetArgPointee<2>(
1007 std::vector<aidl::android::hardware::graphics::composer3::
1008 Composition>{FinalCompositionType}),
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001009 Return(Error::NONE)));
1010 }
1011};
1012
1013/* ------------------------------------------------------------------------
1014 * Variants to select how the composition is expected to be handled
1015 */
1016
1017struct CompositionResultBaseVariant {
1018 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1019
1020 template <typename Case>
1021 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
1022 Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1023 }
1024
1025 template <typename Case>
1026 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1027 Case::Layer::setupCallExpectationsForDirtyFrame(test);
1028 }
1029};
1030
1031struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1032 template <typename Case>
1033 static void setupCallExpectations(CompositionTest* test) {
1034 Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1035 Case::Display::setupHwcCompositionCallExpectations(test);
1036 }
1037};
1038
1039struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1040 template <typename Case>
1041 static void setupCallExpectations(CompositionTest* test) {
1042 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1043 Case::Display::setupHwcCompositionCallExpectations(test);
1044 }
1045};
1046
1047struct RECompositionResultVariant : public CompositionResultBaseVariant {
1048 template <typename Case>
1049 static void setupCallExpectations(CompositionTest* test) {
1050 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
Lloyd Pique66d68602019-02-13 14:23:31 -08001051 Case::Display::setupHwcClientCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001052 Case::Display::setupRECompositionCallExpectations(test);
1053 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1054 }
1055};
1056
Lloyd Pique66d68602019-02-13 14:23:31 -08001057struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001058 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001059 const auto outputLayer =
1060 TestableSurfaceFlinger::findOutputLayerForDisplay(layer, test->mDisplay);
Lloyd Piquef5275482019-01-29 18:42:42 -08001061 LOG_FATAL_IF(!outputLayer);
1062 outputLayer->editState().forceClientComposition = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001063 }
1064
1065 template <typename Case>
Lloyd Pique66d68602019-02-13 14:23:31 -08001066 static void setupCallExpectations(CompositionTest* test) {
1067 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1068 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1069 Case::Display::setupRECompositionCallExpectations(test);
1070 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1071 }
1072
1073 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001074 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1075
1076 template <typename Case>
1077 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1078};
1079
Lloyd Pique4fe29402019-08-12 16:51:24 -07001080struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
1081 static void setupLayerState(CompositionTest* test, sp<Layer>) {
1082 test->mFlinger.mutableDebugDisableHWC() = true;
1083 }
1084
1085 template <typename Case>
1086 static void setupCallExpectations(CompositionTest* test) {
1087 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1088 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1089 Case::Display::setupRECompositionCallExpectations(test);
1090 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1091 }
1092
1093 template <typename Case>
1094 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1095
1096 template <typename Case>
1097 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1098};
1099
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001100struct EmptyScreenshotResultVariant {
1101 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1102
1103 template <typename Case>
1104 static void setupCallExpectations(CompositionTest*) {}
1105};
1106
1107struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1108 using Base = EmptyScreenshotResultVariant;
1109
1110 template <typename Case>
1111 static void setupCallExpectations(CompositionTest* test) {
1112 Base::template setupCallExpectations<Case>(test);
1113 Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1114 }
1115};
1116
1117/* ------------------------------------------------------------------------
1118 * Composition test case, containing all the variants being tested
1119 */
1120
1121template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1122 typename CompositionResultCase>
1123struct CompositionCase {
1124 using ThisCase =
1125 CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1126 using Display = DisplayCase;
1127 using Layer = LayerCase;
1128 using CompositionType = CompositionTypeCase;
1129 using CompositionResult = CompositionResultCase;
1130
1131 static void setupCommon(CompositionTest* test) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -07001132 Display::template setupPreconditionCallExpectations<ThisCase>(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001133 Display::setupPreconditions(test);
1134
1135 auto layer = Layer::createLayer(test);
1136 Layer::injectLayer(test, layer);
1137 CompositionResult::setupLayerState(test, layer);
1138 }
1139
1140 static void setupForDirtyGeometry(CompositionTest* test) {
1141 setupCommon(test);
1142
1143 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1144 CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1145 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1146 CompositionResult::template setupCallExpectations<ThisCase>(test);
1147 }
1148
1149 static void setupForDirtyFrame(CompositionTest* test) {
1150 setupCommon(test);
1151
1152 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1153 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1154 CompositionResult::template setupCallExpectations<ThisCase>(test);
1155 }
1156
1157 static void setupForScreenCapture(CompositionTest* test) {
1158 setupCommon(test);
1159
1160 Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1161 CompositionResult::template setupCallExpectations<ThisCase>(test);
1162 }
1163
1164 static void cleanup(CompositionTest* test) {
1165 Layer::cleanupInjectedLayers(test);
1166
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001167 for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1168 static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1169 ->mutableLayers()
1170 .clear();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001171 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001172 }
1173};
1174
1175/* ------------------------------------------------------------------------
1176 * Composition cases to test
1177 */
1178
1179TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1180 displayRefreshCompositionDirtyGeometry<
1181 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1182 NoCompositionResultVariant>>();
1183}
1184
1185TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1186 displayRefreshCompositionDirtyFrame<
1187 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1188 NoCompositionResultVariant>>();
1189}
1190
1191TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1192 captureScreenComposition<
1193 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1194 EmptyScreenshotResultVariant>>();
1195}
1196
1197/* ------------------------------------------------------------------------
1198 * Simple buffer layers
1199 */
1200
1201TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001202 displayRefreshCompositionDirtyGeometry<CompositionCase<
1203 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1204 KeepCompositionTypeVariant<
1205 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1206 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001207}
1208
1209TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001210 displayRefreshCompositionDirtyFrame<CompositionCase<
1211 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1212 KeepCompositionTypeVariant<
1213 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1214 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001215}
1216
1217TEST_F(CompositionTest, REComposedNormalBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001218 displayRefreshCompositionDirtyFrame<CompositionCase<
1219 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1220 ChangeCompositionTypeVariant<
1221 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1222 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1223 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001224}
1225
1226TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1227 captureScreenComposition<
1228 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1229 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1230}
1231
1232/* ------------------------------------------------------------------------
1233 * Single-color layers
1234 */
1235
Vishnu Nairfa247b12020-02-11 08:58:26 -08001236TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001237 displayRefreshCompositionDirtyGeometry<CompositionCase<
1238 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1239 KeepCompositionTypeVariant<
1240 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1241 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001242}
1243
Vishnu Nairfa247b12020-02-11 08:58:26 -08001244TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001245 displayRefreshCompositionDirtyFrame<CompositionCase<
1246 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1247 KeepCompositionTypeVariant<
1248 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1249 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001250}
1251
Vishnu Nairfa247b12020-02-11 08:58:26 -08001252TEST_F(CompositionTest, REComposedEffectLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001253 displayRefreshCompositionDirtyFrame<CompositionCase<
1254 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1255 ChangeCompositionTypeVariant<
1256 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR,
1257 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1258 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001259}
1260
Vishnu Nairfa247b12020-02-11 08:58:26 -08001261TEST_F(CompositionTest, captureScreenEffectLayer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001262 captureScreenComposition<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001263 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001264 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1265}
1266
1267/* ------------------------------------------------------------------------
1268 * Layers with sideband buffers
1269 */
1270
1271TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001272 displayRefreshCompositionDirtyGeometry<CompositionCase<
1273 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1274 KeepCompositionTypeVariant<
1275 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1276 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001277}
1278
1279TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001280 displayRefreshCompositionDirtyFrame<CompositionCase<
1281 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1282 KeepCompositionTypeVariant<
1283 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1284 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001285}
1286
1287TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001288 displayRefreshCompositionDirtyFrame<CompositionCase<
1289 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1290 ChangeCompositionTypeVariant<
1291 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND,
1292 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1293 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001294}
1295
1296TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1297 captureScreenComposition<
1298 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1299 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1300}
1301
1302/* ------------------------------------------------------------------------
1303 * Layers with ISurfaceComposerClient::eSecure, on a secure display
1304 */
1305
1306TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001307 displayRefreshCompositionDirtyGeometry<CompositionCase<
1308 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1309 KeepCompositionTypeVariant<
1310 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1311 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001312}
1313
1314TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001315 displayRefreshCompositionDirtyFrame<CompositionCase<
1316 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1317 KeepCompositionTypeVariant<
1318 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1319 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001320}
1321
1322TEST_F(CompositionTest, REComposedSecureBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001323 displayRefreshCompositionDirtyFrame<CompositionCase<
1324 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1325 ChangeCompositionTypeVariant<
1326 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1327 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1328 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001329}
1330
1331TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1332 captureScreenComposition<
1333 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1334 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1335}
1336
1337/* ------------------------------------------------------------------------
1338 * Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1339 */
1340
1341TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001342 displayRefreshCompositionDirtyGeometry<CompositionCase<
1343 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1344 KeepCompositionTypeVariant<
1345 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1346 ForcedClientCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001347}
1348
1349TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001350 displayRefreshCompositionDirtyFrame<CompositionCase<
1351 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1352 KeepCompositionTypeVariant<
1353 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1354 ForcedClientCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001355}
1356
1357TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1358 captureScreenComposition<
1359 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1360 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1361}
1362
1363/* ------------------------------------------------------------------------
Garfield Tande619fa2020-10-02 17:13:53 -07001364 * Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1365 */
1366
1367TEST_F(CompositionTest,
1368 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001369 displayRefreshCompositionDirtyGeometry<CompositionCase<
1370 InsecureDisplaySetupVariant,
1371 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1372 ContainerLayerVariant<SecureLayerProperties>>,
1373 KeepCompositionTypeVariant<
1374 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1375 ForcedClientCompositionResultVariant>>();
Garfield Tande619fa2020-10-02 17:13:53 -07001376}
1377
1378TEST_F(CompositionTest,
1379 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001380 displayRefreshCompositionDirtyFrame<CompositionCase<
1381 InsecureDisplaySetupVariant,
1382 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1383 ContainerLayerVariant<SecureLayerProperties>>,
1384 KeepCompositionTypeVariant<
1385 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1386 ForcedClientCompositionResultVariant>>();
Garfield Tande619fa2020-10-02 17:13:53 -07001387}
1388
1389TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1390 captureScreenComposition<
1391 CompositionCase<InsecureDisplaySetupVariant,
1392 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1393 ContainerLayerVariant<SecureLayerProperties>>,
1394 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1395}
1396
1397/* ------------------------------------------------------------------------
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001398 * Cursor layers
1399 */
1400
1401TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001402 displayRefreshCompositionDirtyGeometry<CompositionCase<
1403 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1404 KeepCompositionTypeVariant<
1405 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1406 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001407}
1408
1409TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001410 displayRefreshCompositionDirtyFrame<CompositionCase<
1411 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1412 KeepCompositionTypeVariant<
1413 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1414 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001415}
1416
1417TEST_F(CompositionTest, REComposedCursorLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001418 displayRefreshCompositionDirtyFrame<CompositionCase<
1419 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1420 ChangeCompositionTypeVariant<
1421 aidl::android::hardware::graphics::composer3::Composition::CURSOR,
1422 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1423 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001424}
1425
1426TEST_F(CompositionTest, captureScreenCursorLayer) {
1427 captureScreenComposition<
1428 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1429 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1430}
1431
1432/* ------------------------------------------------------------------------
1433 * Simple buffer layer on a display which is powered off.
1434 */
1435
1436TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001437 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001438 displayRefreshCompositionDirtyGeometry<CompositionCase<
1439 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001440 KeepCompositionTypeVariant<
1441 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001442 HwcCompositionResultVariant>>();
1443}
1444
1445TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001446 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001447 displayRefreshCompositionDirtyFrame<CompositionCase<
1448 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001449 KeepCompositionTypeVariant<
1450 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001451 HwcCompositionResultVariant>>();
1452}
1453
1454TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001455 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001456 displayRefreshCompositionDirtyFrame<CompositionCase<
1457 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001458 ChangeCompositionTypeVariant<
1459 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1460 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001461 RECompositionResultVariant>>();
1462}
1463
1464TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1465 captureScreenComposition<CompositionCase<
1466 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1467 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1468}
1469
Lloyd Pique4fe29402019-08-12 16:51:24 -07001470/* ------------------------------------------------------------------------
1471 * Client composition forced through debug/developer settings
1472 */
1473
1474TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001475 displayRefreshCompositionDirtyGeometry<CompositionCase<
1476 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1477 KeepCompositionTypeVariant<
1478 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1479 ForcedClientCompositionViaDebugOptionResultVariant>>();
Lloyd Pique4fe29402019-08-12 16:51:24 -07001480}
1481
1482TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001483 displayRefreshCompositionDirtyFrame<CompositionCase<
1484 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1485 KeepCompositionTypeVariant<
1486 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1487 ForcedClientCompositionViaDebugOptionResultVariant>>();
Lloyd Pique4fe29402019-08-12 16:51:24 -07001488}
1489
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001490} // namespace
1491} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001492
1493// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01001494#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"