blob: 17ef6ff5e16879f60808fd7bd2a859a09d82db35 [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
Marin Shalamanovf6b5d182020-06-12 02:08:51 +020040#include "DisplayRenderArea.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070041#include "Layer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070042#include "TestableSurfaceFlinger.h"
43#include "mock/DisplayHardware/MockComposer.h"
Lloyd Pique9370a482019-10-03 17:58:30 -070044#include "mock/DisplayHardware/MockPowerAdvisor.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070045#include "mock/MockEventThread.h"
Alec Mourie4034bb2019-11-19 12:45:54 -080046#include "mock/MockTimeStats.h"
Ady Abraham8cb21882020-08-26 18:22:05 -070047#include "mock/MockVsyncController.h"
Alec Mouriba013fa2018-10-16 12:43:11 -070048#include "mock/system/window/MockNativeWindow.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070049
50namespace android {
51namespace {
52
Peiyong Line9d809e2020-04-14 13:10:48 -070053namespace hal = android::hardware::graphics::composer::hal;
54
Peiyong Lin65248e02020-04-18 21:15:07 -070055using hal::Error;
56using hal::IComposer;
57using hal::IComposerClient;
58using hal::PowerMode;
59using hal::Transform;
60
Ady Abrahamde549d42022-01-26 19:19:17 -080061using aidl::android::hardware::graphics::composer3::Capability;
62
Lloyd Piqued6b579f2018-04-06 15:29:10 -070063using testing::_;
David Sodman15094112018-10-11 09:39:37 -070064using testing::AtLeast;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070065using testing::DoAll;
66using testing::IsNull;
67using testing::Mock;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070068using testing::Return;
69using testing::ReturnRef;
70using testing::SetArgPointee;
71
Lloyd Piqued6b579f2018-04-06 15:29:10 -070072using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
73using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;
74
Peiyong Line9d809e2020-04-14 13:10:48 -070075constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DISPLAY_ID;
76constexpr hal::HWLayerId HWC_LAYER = 5000;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070077constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0);
78
Dominik Laskowskif1833852021-03-23 15:06:50 -070079constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(42u);
Lloyd Piqued6b579f2018-04-06 15:29:10 -070080constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
81constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
82
Lloyd Piqued6b579f2018-04-06 15:29:10 -070083constexpr int DEFAULT_TEXTURE_ID = 6000;
Dominik Laskowski29fa1462021-04-27 15:51:50 -070084constexpr ui::LayerStack LAYER_STACK{7000u};
Lloyd Piqued6b579f2018-04-06 15:29:10 -070085
86constexpr int DEFAULT_DISPLAY_MAX_LUMINANCE = 500;
87
88constexpr int DEFAULT_SIDEBAND_STREAM = 51;
89
Ady Abrahamdc011a92021-12-21 14:06:44 -080090MATCHER(IsIdentityMatrix, "") {
91 constexpr auto kIdentity = mat4();
92 return (mat4(arg) == kIdentity);
93}
94
Lloyd Piqued6b579f2018-04-06 15:29:10 -070095class CompositionTest : public testing::Test {
96public:
97 CompositionTest() {
98 const ::testing::TestInfo* const test_info =
99 ::testing::UnitTest::GetInstance()->current_test_info();
100 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
101
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500102 mFlinger.setupMockScheduler({.displayId = DEFAULT_DISPLAY_ID});
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700103
Alec Mourif6fd29e2018-11-17 04:56:41 +0000104 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
105 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
106 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
107 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700108
109 mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
Alec Mourie4034bb2019-11-19 12:45:54 -0800110 mFlinger.setupTimeStats(std::shared_ptr<TimeStats>(mTimeStats));
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800111
112 mComposer = new Hwc2::mock::Composer();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000113 mPowerAdvisor = new Hwc2::mock::PowerAdvisor();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800114 mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
Xiang Wang839fe5b2022-04-04 17:39:38 +0000115 mFlinger.setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor>(mPowerAdvisor));
Garfield Tan9c9c1912021-07-19 12:02:16 -0700116 mFlinger.mutableMaxRenderTargetSize() = 16384;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700117 }
118
119 ~CompositionTest() {
120 const ::testing::TestInfo* const test_info =
121 ::testing::UnitTest::GetInstance()->current_test_info();
122 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
123 }
124
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700125 void setupForceGeometryDirty() {
126 // TODO: This requires the visible region and other related
127 // state to be set, and is problematic for BufferLayers since they are
128 // not visible without a buffer (and setting up a buffer looks like a
129 // pain)
130 // mFlinger.mutableVisibleRegionsDirty() = true;
131
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700132 mFlinger.mutableGeometryDirty() = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700133 }
134
135 template <typename Case>
136 void displayRefreshCompositionDirtyGeometry();
137
138 template <typename Case>
139 void displayRefreshCompositionDirtyFrame();
140
141 template <typename Case>
142 void captureScreenComposition();
143
Ady Abrahamde549d42022-01-26 19:19:17 -0800144 std::unordered_set<Capability> mDefaultCapabilities = {Capability::SIDEBAND_STREAM};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700145
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800146 bool mDisplayOff = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700147 TestableSurfaceFlinger mFlinger;
148 sp<DisplayDevice> mDisplay;
Lloyd Pique542307f2018-10-19 13:24:08 -0700149 sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
Ady Abrahamd11bade2022-08-01 16:18:03 -0700150 sp<compositionengine::mock::DisplaySurface>::make();
151 sp<mock::NativeWindow> mNativeWindow = sp<mock::NativeWindow>::make();
Garfield Tande619fa2020-10-02 17:13:53 -0700152 std::vector<sp<Layer>> mAuxiliaryLayers;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700153
Brian Lindahlf5ab5ae2022-12-21 14:27:15 -0700154 sp<GraphicBuffer> mBuffer =
155 sp<GraphicBuffer>::make(1u, 1u, PIXEL_FORMAT_RGBA_8888,
156 GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN);
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800157 ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();
158
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700159 Hwc2::mock::Composer* mComposer = nullptr;
160 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
Alec Mourie4034bb2019-11-19 12:45:54 -0800161 mock::TimeStats* mTimeStats = new mock::TimeStats();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000162 Hwc2::mock::PowerAdvisor* mPowerAdvisor = nullptr;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700163
164 sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;
165
Alec Mouria90a5702021-04-16 16:36:21 +0000166 std::shared_ptr<renderengine::ExternalTexture> mCaptureScreenBuffer;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700167};
168
169template <typename LayerCase>
170void CompositionTest::displayRefreshCompositionDirtyGeometry() {
171 setupForceGeometryDirty();
172 LayerCase::setupForDirtyGeometry(this);
173
174 // --------------------------------------------------------------------
175 // Invocation
176
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700177 mFlinger.commitAndComposite();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700178
179 LayerCase::cleanup(this);
180}
181
182template <typename LayerCase>
183void CompositionTest::displayRefreshCompositionDirtyFrame() {
184 LayerCase::setupForDirtyFrame(this);
185
186 // --------------------------------------------------------------------
187 // Invocation
188
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700189 mFlinger.commitAndComposite();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700190
191 LayerCase::cleanup(this);
192}
193
194template <typename LayerCase>
195void CompositionTest::captureScreenComposition() {
196 LayerCase::setupForScreenCapture(this);
197
198 const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700199 constexpr bool forSystem = true;
Lucas Dupin9d763b72020-04-20 18:42:31 -0700200 constexpr bool regionSampling = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700201
Marin Shalamanov1c434292020-06-12 01:47:29 +0200202 auto renderArea = DisplayRenderArea::create(mDisplay, sourceCrop, sourceCrop.getSize(),
203 ui::Dataspace::V0_SRGB, ui::Transform::ROT_0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700204
205 auto traverseLayers = [this](const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700206 return mFlinger.traverseLayersInLayerStack(mDisplay->getLayerStack(),
207 CaptureArgs::UNSET_UID, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700208 };
209
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000210 auto getLayerSnapshots = RenderArea::fromTraverseLayersLambda(traverseLayers);
211
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700212 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
213 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800214 mCaptureScreenBuffer =
215 std::make_shared<renderengine::mock::FakeExternalTexture>(renderArea->getReqWidth(),
216 renderArea->getReqHeight(),
217 HAL_PIXEL_FORMAT_RGBA_8888, 1,
218 usage);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700219
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000220 auto future = mFlinger.renderScreenImpl(std::move(renderArea), getLayerSnapshots,
Patrick Williams7584c6a2022-10-29 02:10:58 +0000221 mCaptureScreenBuffer, forSystem, regionSampling);
Dominik Laskowskibb448ce2022-05-07 15:52:55 -0700222 ASSERT_TRUE(future.valid());
223 const auto fenceResult = future.get();
Sally Qi59a9f502021-10-12 18:53:23 +0000224
Dominik Laskowskibb448ce2022-05-07 15:52:55 -0700225 EXPECT_EQ(NO_ERROR, fenceStatus(fenceResult));
226 if (fenceResult.ok()) {
227 fenceResult.value()->waitForever(LOG_TAG);
Sally Qi59a9f502021-10-12 18:53:23 +0000228 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700229
230 LayerCase::cleanup(this);
231}
232
Sally Qi4cabdd02021-08-05 16:45:57 -0700233template <class T>
234std::future<T> futureOf(T obj) {
235 std::promise<T> resultPromise;
236 std::future<T> resultFuture = resultPromise.get_future();
237 resultPromise.set_value(std::move(obj));
238 return resultFuture;
239}
240
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700241/* ------------------------------------------------------------------------
242 * Variants for each display configuration which can be tested
243 */
244
245template <typename Derived>
246struct BaseDisplayVariant {
247 static constexpr bool IS_SECURE = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700248 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700249
250 static void setupPreconditions(CompositionTest* test) {
Peiyong Lin65248e02020-04-18 21:15:07 -0700251 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700252 .WillOnce(Return(Error::NONE));
Alec Mouriba013fa2018-10-16 12:43:11 -0700253
Peiyong Line9d809e2020-04-14 13:10:48 -0700254 FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700255 .setCapabilities(&test->mDefaultCapabilities)
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700256 .setPowerMode(Derived::INIT_POWER_MODE)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700257 .inject(&test->mFlinger, test->mComposer);
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800258 Mock::VerifyAndClear(test->mComposer);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700259
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800260 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
261 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
262 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
263 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
264 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
265 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
266 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
Lloyd Pique9370a482019-10-03 17:58:30 -0700267
268 const ::testing::TestInfo* const test_info =
269 ::testing::UnitTest::GetInstance()->current_test_info();
270
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800271 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
272 .setId(DEFAULT_DISPLAY_ID)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800273 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
274 .setIsSecure(Derived::IS_SECURE)
Xiang Wang839fe5b2022-04-04 17:39:38 +0000275 .setPowerAdvisor(test->mPowerAdvisor)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800276 .setName(std::string("Injected display for ") +
277 test_info->test_case_name() + "." + test_info->name())
278 .build();
Lloyd Pique9370a482019-10-03 17:58:30 -0700279
280 auto compositionDisplay =
281 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
282 ceDisplayArgs);
283
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700284 constexpr auto kDisplayConnectionType = ui::DisplayConnectionType::Internal;
285 constexpr bool kIsPrimary = true;
286
Marin Shalamanov700e6392020-02-12 20:22:26 +0100287 test->mDisplay = FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700288 kDisplayConnectionType, HWC_DISPLAY, kIsPrimary)
Marin Shalamanov700e6392020-02-12 20:22:26 +0100289 .setDisplaySurface(test->mDisplaySurface)
290 .setNativeWindow(test->mNativeWindow)
291 .setSecure(Derived::IS_SECURE)
292 .setPowerMode(Derived::INIT_POWER_MODE)
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);
318 EXPECT_CALL(*test->mDisplaySurface, advanceFrame()).Times(1);
319
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>&,
Patrick Williams2e9748f2022-08-09 22:48:18 +0000330 const bool, 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) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800349 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _))
350 .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) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800358 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _))
359 .Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800360 }
361
362 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
Ady Abraham43065bd2021-12-10 17:22:15 -0800363 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>&,
Patrick Williams2e9748f2022-08-09 22:48:18 +0000381 const bool, 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,
Sally Qi4cabdd02021-08-05 16:45:57 -0700580 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
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()));
599 EXPECT_EQ(DEFAULT_TEXTURE_ID, layer.source.buffer.textureName);
600 EXPECT_EQ(false, layer.source.buffer.isY410BT2020);
601 EXPECT_EQ(true, layer.source.buffer.usePremultipliedAlpha);
602 EXPECT_EQ(false, layer.source.buffer.isOpaque);
Vishnu Nair50c0afe2022-07-11 15:04:07 -0700603 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
604 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
Sally Qi59a9f502021-10-12 18:53:23 +0000605 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
606 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700607 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000608 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700609 }
610
611 static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
612 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700613 }
614
615 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
616 setupREBufferCompositionCallExpectations(test);
617 }
618
619 static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
620 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
621 }
622
623 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
624 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
625 }
626
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700627 static void setupREColorCompositionCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000628 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700629 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000630 const std::vector<renderengine::LayerSettings>& layerSettings,
Sally Qi4cabdd02021-08-05 16:45:57 -0700631 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Patrick Williams2e9748f2022-08-09 22:48:18 +0000632 base::unique_fd&&) -> std::future<FenceResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000633 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
634 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
635 displaySettings.physicalDisplay);
636 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
637 displaySettings.clip);
638 // screen capture adds an additional color layer as an alpha
639 // prefill, so get the back layer.
Patrick Williams2e9748f2022-08-09 22:48:18 +0000640 std::future<FenceResult> resultFuture = futureOf<FenceResult>(Fence::NO_FENCE);
Lloyd Piquea2468662019-03-07 21:31:06 -0800641 if (layerSettings.empty()) {
642 ADD_FAILURE()
643 << "layerSettings was not expected to be empty in "
644 "setupREColorCompositionCallExpectations verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700645 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800646 }
Sally Qi59a9f502021-10-12 18:53:23 +0000647 const renderengine::LayerSettings layer = layerSettings.back();
648 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000649 EXPECT_EQ(half3(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
650 LayerProperties::COLOR[2]),
Sally Qi59a9f502021-10-12 18:53:23 +0000651 layer.source.solidColor);
Vishnu Nair50c0afe2022-07-11 15:04:07 -0700652 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
653 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
Sally Qi59a9f502021-10-12 18:53:23 +0000654 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
655 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700656 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000657 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700658 }
659
660 static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
661 setupREColorCompositionCallExpectations(test);
662 }
663};
664
665struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
666
Vishnu Nairfa247b12020-02-11 08:58:26 -0800667struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
Alec Mourida8a9d12020-01-30 20:00:31 -0800668 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
669};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700670
671struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
672 using Base = BaseLayerProperties<SidebandLayerProperties>;
673 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
674
Patrick Williams83f36b22022-09-14 17:57:35 +0000675 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700676 sp<NativeHandle> stream =
677 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
678 false);
679 test->mFlinger.setLayerSidebandStream(layer, stream);
680 }
681
682 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
683 EXPECT_CALL(*test->mComposer,
684 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
685 IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
686 .Times(1);
687 }
688
689 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
690 EXPECT_CALL(*test->mComposer,
691 setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
692 reinterpret_cast<native_handle_t*>(
693 DEFAULT_SIDEBAND_STREAM)))
694 .WillOnce(Return(Error::NONE));
695
696 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
697 }
698
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000699 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700700};
701
Garfield Tande619fa2020-10-02 17:13:53 -0700702template <typename LayerProperties>
703struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
704 using Base = BaseLayerProperties<LayerProperties>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700705
706 static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000707 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Sally Qi4cabdd02021-08-05 16:45:57 -0700708 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
Sally Qi59a9f502021-10-12 18:53:23 +0000709 const std::vector<renderengine::LayerSettings>& layerSettings,
Sally Qi4cabdd02021-08-05 16:45:57 -0700710 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Patrick Williams2e9748f2022-08-09 22:48:18 +0000711 base::unique_fd&&) -> std::future<FenceResult> {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000712 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
713 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
714 displaySettings.physicalDisplay);
715 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
716 displaySettings.clip);
717 // screen capture adds an additional color layer as an alpha
718 // prefill, so get the back layer.
Patrick Williams2e9748f2022-08-09 22:48:18 +0000719 std::future<FenceResult> resultFuture = futureOf<FenceResult>(Fence::NO_FENCE);
Lloyd Piquea2468662019-03-07 21:31:06 -0800720 if (layerSettings.empty()) {
721 ADD_FAILURE() << "layerSettings was not expected to be empty in "
722 "setupInsecureREBufferCompositionCommonCallExpectations "
723 "verification lambda";
Sally Qi4cabdd02021-08-05 16:45:57 -0700724 return resultFuture;
Lloyd Piquea2468662019-03-07 21:31:06 -0800725 }
Sally Qi59a9f502021-10-12 18:53:23 +0000726 const renderengine::LayerSettings layer = layerSettings.back();
727 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
728 EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer.source.solidColor);
Vishnu Nair50c0afe2022-07-11 15:04:07 -0700729 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
730 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
Sally Qi59a9f502021-10-12 18:53:23 +0000731 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
732 EXPECT_EQ(1.0f, layer.alpha);
Sally Qi4cabdd02021-08-05 16:45:57 -0700733 return resultFuture;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000734 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700735 }
736
737 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
738 setupInsecureREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700739 }
740
741 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
742 setupInsecureREBufferCompositionCommonCallExpectations(test);
743 }
744};
745
Garfield Tande619fa2020-10-02 17:13:53 -0700746struct ParentSecureLayerProperties
747 : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
748
749struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
750 static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
751};
752
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700753struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
754 using Base = BaseLayerProperties<CursorLayerProperties>;
755
Patrick Williams83f36b22022-09-14 17:57:35 +0000756 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700757 Base::setupLayerState(test, layer);
758 test->mFlinger.setLayerPotentialCursor(layer, true);
759 }
760};
761
762struct NoLayerVariant {
Patrick Williams83f36b22022-09-14 17:57:35 +0000763 using FlingerLayerType = sp<Layer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700764
765 static FlingerLayerType createLayer(CompositionTest*) { return FlingerLayerType(); }
766 static void injectLayer(CompositionTest*, FlingerLayerType) {}
767 static void cleanupInjectedLayers(CompositionTest*) {}
768
769 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
770 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
771};
772
773template <typename LayerProperties>
774struct BaseLayerVariant {
775 template <typename L, typename F>
776 static sp<L> createLayerWithFactory(CompositionTest* test, F factory) {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700777 EXPECT_CALL(*test->mFlinger.scheduler(), postMessage(_)).Times(0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700778
779 sp<L> layer = factory();
780
Dominik Laskowski49cea512019-11-12 14:13:23 -0800781 // Layer should be registered with scheduler.
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700782 EXPECT_EQ(1u, test->mFlinger.scheduler()->layerHistorySize());
Dominik Laskowski49cea512019-11-12 14:13:23 -0800783
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700784 Mock::VerifyAndClear(test->mComposer);
785 Mock::VerifyAndClear(test->mRenderEngine);
Dominik Laskowski756b7892021-08-04 12:53:59 -0700786 Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700787
Garfield Tande619fa2020-10-02 17:13:53 -0700788 initLayerDrawingStateAndComputeBounds(test, layer);
789
790 return layer;
791 }
792
793 template <typename L>
794 static void initLayerDrawingStateAndComputeBounds(CompositionTest* test, sp<L> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700795 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700796 layerDrawingState.layerStack = LAYER_STACK;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700797 layerDrawingState.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
798 LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700799 layer->computeBounds(FloatRect(0, 0, 100, 100), ui::Transform(), 0.f /* shadowRadius */);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700800 }
801
802 static void injectLayer(CompositionTest* test, sp<Layer> layer) {
803 EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
804 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
805
Lloyd Piquede196652020-01-22 17:29:58 -0800806 auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
807 layer->getCompositionEngineLayerFE());
Lloyd Pique01c77c12019-04-17 12:48:32 -0700808 outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
809 outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700810
811 Mock::VerifyAndClear(test->mComposer);
812
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700813 test->mFlinger.mutableDrawingState().layersSortedByZ.add(layer);
814 }
815
816 static void cleanupInjectedLayers(CompositionTest* test) {
817 EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
818 .WillOnce(Return(Error::NONE));
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800819
Lloyd Pique01c77c12019-04-17 12:48:32 -0700820 test->mDisplay->getCompositionDisplay()->clearOutputLayers();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700821 test->mFlinger.mutableDrawingState().layersSortedByZ.clear();
Dominik Laskowski49cea512019-11-12 14:13:23 -0800822
823 // Layer should be unregistered with scheduler.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700824 test->mFlinger.commit();
Dominik Laskowski9c93d602021-10-07 19:38:26 -0700825 EXPECT_EQ(0u, test->mFlinger.scheduler()->layerHistorySize());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700826 }
827};
828
829template <typename LayerProperties>
Vishnu Nairfa247b12020-02-11 08:58:26 -0800830struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700831 using Base = BaseLayerVariant<LayerProperties>;
Patrick Williams46b61b92022-09-01 17:25:49 +0000832 using FlingerLayerType = sp<Layer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700833
834 static FlingerLayerType createLayer(CompositionTest* test) {
Patrick Williams46b61b92022-09-01 17:25:49 +0000835 FlingerLayerType layer = Base::template createLayerWithFactory<Layer>(test, [test]() {
836 return sp<Layer>::make(LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(),
837 "test-layer", LayerProperties::LAYER_FLAGS,
838 LayerMetadata()));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700839 });
Vishnu Nair60356342018-11-13 13:00:45 -0800840
841 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
chaviw25714502021-02-11 10:01:08 -0800842 layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700843 return layer;
844 }
845
846 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700847 LayerProperties::setupREColorCompositionCallExpectations(test);
848 }
849
850 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
851 LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
852 }
853
854 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
855 LayerProperties::setupHwcSetGeometryCallExpectations(test);
856 LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
857 }
858
859 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
860 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
861 LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
862 }
863};
864
865template <typename LayerProperties>
866struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
867 using Base = BaseLayerVariant<LayerProperties>;
Patrick Williams83f36b22022-09-14 17:57:35 +0000868 using FlingerLayerType = sp<Layer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700869
870 static FlingerLayerType createLayer(CompositionTest* test) {
871 test->mFlinger.mutableTexturePool().push_back(DEFAULT_TEXTURE_ID);
872
873 FlingerLayerType layer =
Patrick Williams83f36b22022-09-14 17:57:35 +0000874 Base::template createLayerWithFactory<Layer>(test, [test]() {
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700875 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700876 LayerProperties::LAYER_FLAGS, LayerMetadata());
chaviwb4c6e582019-08-16 14:35:07 -0700877 args.textureName = test->mFlinger.mutableTexturePool().back();
Patrick Williams83f36b22022-09-14 17:57:35 +0000878 return sp<Layer>::make(args);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700879 });
880
881 LayerProperties::setupLayerState(test, layer);
882
883 return layer;
884 }
885
886 static void cleanupInjectedLayers(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700887 Base::cleanupInjectedLayers(test);
888 }
889
890 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
891 LayerProperties::setupHwcSetGeometryCallExpectations(test);
892 LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
893 }
894
895 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
896 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
897 LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
898 }
899
900 static void setupRECompositionCallExpectations(CompositionTest* test) {
901 LayerProperties::setupREBufferCompositionCallExpectations(test);
902 }
903
904 static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
905 LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
906 }
907
908 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
909 LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
910 }
911
912 static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
913 LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
914 }
915};
916
Garfield Tande619fa2020-10-02 17:13:53 -0700917template <typename LayerProperties>
918struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
919 using Base = BaseLayerVariant<LayerProperties>;
Patrick Williams46b61b92022-09-01 17:25:49 +0000920 using FlingerLayerType = sp<Layer>;
Garfield Tande619fa2020-10-02 17:13:53 -0700921
922 static FlingerLayerType createLayer(CompositionTest* test) {
923 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
Garfield Tande619fa2020-10-02 17:13:53 -0700924 LayerProperties::LAYER_FLAGS, LayerMetadata());
Patrick Williams46b61b92022-09-01 17:25:49 +0000925 FlingerLayerType layer = sp<Layer>::make(args);
Garfield Tande619fa2020-10-02 17:13:53 -0700926 Base::template initLayerDrawingStateAndComputeBounds(test, layer);
927 return layer;
928 }
929};
930
931template <typename LayerVariant, typename ParentLayerVariant>
932struct ChildLayerVariant : public LayerVariant {
933 using Base = LayerVariant;
934 using FlingerLayerType = typename LayerVariant::FlingerLayerType;
935 using ParentBase = ParentLayerVariant;
936
937 static FlingerLayerType createLayer(CompositionTest* test) {
938 // Need to create child layer first. Otherwise layer history size will be 2.
939 FlingerLayerType layer = Base::createLayer(test);
940
941 typename ParentBase::FlingerLayerType parentLayer = ParentBase::createLayer(test);
942 parentLayer->addChild(layer);
943 test->mFlinger.setLayerDrawingParent(layer, parentLayer);
944
945 test->mAuxiliaryLayers.push_back(parentLayer);
946
947 return layer;
948 }
949
950 static void cleanupInjectedLayers(CompositionTest* test) {
951 // Clear auxiliary layers first so that child layer can be successfully destroyed in the
952 // following call.
953 test->mAuxiliaryLayers.clear();
954
955 Base::cleanupInjectedLayers(test);
956 }
957};
958
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700959/* ------------------------------------------------------------------------
960 * Variants to control how the composition type is changed
961 */
962
963struct NoCompositionTypeVariant {
964 static void setupHwcSetCallExpectations(CompositionTest*) {}
965
966 static void setupHwcGetCallExpectations(CompositionTest* test) {
967 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
968 }
969};
970
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500971template <aidl::android::hardware::graphics::composer3::Composition CompositionType>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700972struct KeepCompositionTypeVariant {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500973 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
974 CompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700975
976 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800977 if (!test->mDisplayOff) {
978 EXPECT_CALL(*test->mComposer,
979 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
980 .Times(1);
981 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700982 }
983
984 static void setupHwcGetCallExpectations(CompositionTest* test) {
985 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
986 }
987};
988
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500989template <aidl::android::hardware::graphics::composer3::Composition InitialCompositionType,
990 aidl::android::hardware::graphics::composer3::Composition FinalCompositionType>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700991struct ChangeCompositionTypeVariant {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500992 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
993 FinalCompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700994
995 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800996 if (!test->mDisplayOff) {
997 EXPECT_CALL(*test->mComposer,
998 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
999 .Times(1);
1000 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001001 }
1002
1003 static void setupHwcGetCallExpectations(CompositionTest* test) {
1004 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
1005 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
1006 static_cast<Hwc2::Layer>(HWC_LAYER)}),
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001007 SetArgPointee<2>(
1008 std::vector<aidl::android::hardware::graphics::composer3::
1009 Composition>{FinalCompositionType}),
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001010 Return(Error::NONE)));
1011 }
1012};
1013
1014/* ------------------------------------------------------------------------
1015 * Variants to select how the composition is expected to be handled
1016 */
1017
1018struct CompositionResultBaseVariant {
1019 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1020
1021 template <typename Case>
1022 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
1023 Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1024 }
1025
1026 template <typename Case>
1027 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1028 Case::Layer::setupCallExpectationsForDirtyFrame(test);
1029 }
1030};
1031
1032struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1033 template <typename Case>
1034 static void setupCallExpectations(CompositionTest* test) {
1035 Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1036 Case::Display::setupHwcCompositionCallExpectations(test);
1037 }
1038};
1039
1040struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1041 template <typename Case>
1042 static void setupCallExpectations(CompositionTest* test) {
1043 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1044 Case::Display::setupHwcCompositionCallExpectations(test);
1045 }
1046};
1047
1048struct RECompositionResultVariant : public CompositionResultBaseVariant {
1049 template <typename Case>
1050 static void setupCallExpectations(CompositionTest* test) {
1051 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
Lloyd Pique66d68602019-02-13 14:23:31 -08001052 Case::Display::setupHwcClientCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001053 Case::Display::setupRECompositionCallExpectations(test);
1054 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1055 }
1056};
1057
Lloyd Pique66d68602019-02-13 14:23:31 -08001058struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001059 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001060 const auto outputLayer =
1061 TestableSurfaceFlinger::findOutputLayerForDisplay(layer, test->mDisplay);
Lloyd Piquef5275482019-01-29 18:42:42 -08001062 LOG_FATAL_IF(!outputLayer);
1063 outputLayer->editState().forceClientComposition = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001064 }
1065
1066 template <typename Case>
Lloyd Pique66d68602019-02-13 14:23:31 -08001067 static void setupCallExpectations(CompositionTest* test) {
1068 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1069 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1070 Case::Display::setupRECompositionCallExpectations(test);
1071 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1072 }
1073
1074 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001075 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1076
1077 template <typename Case>
1078 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1079};
1080
Lloyd Pique4fe29402019-08-12 16:51:24 -07001081struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
1082 static void setupLayerState(CompositionTest* test, sp<Layer>) {
1083 test->mFlinger.mutableDebugDisableHWC() = true;
1084 }
1085
1086 template <typename Case>
1087 static void setupCallExpectations(CompositionTest* test) {
1088 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1089 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1090 Case::Display::setupRECompositionCallExpectations(test);
1091 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1092 }
1093
1094 template <typename Case>
1095 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1096
1097 template <typename Case>
1098 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1099};
1100
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001101struct EmptyScreenshotResultVariant {
1102 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1103
1104 template <typename Case>
1105 static void setupCallExpectations(CompositionTest*) {}
1106};
1107
1108struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1109 using Base = EmptyScreenshotResultVariant;
1110
1111 template <typename Case>
1112 static void setupCallExpectations(CompositionTest* test) {
1113 Base::template setupCallExpectations<Case>(test);
1114 Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1115 }
1116};
1117
1118/* ------------------------------------------------------------------------
1119 * Composition test case, containing all the variants being tested
1120 */
1121
1122template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1123 typename CompositionResultCase>
1124struct CompositionCase {
1125 using ThisCase =
1126 CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1127 using Display = DisplayCase;
1128 using Layer = LayerCase;
1129 using CompositionType = CompositionTypeCase;
1130 using CompositionResult = CompositionResultCase;
1131
1132 static void setupCommon(CompositionTest* test) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -07001133 Display::template setupPreconditionCallExpectations<ThisCase>(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001134 Display::setupPreconditions(test);
1135
1136 auto layer = Layer::createLayer(test);
1137 Layer::injectLayer(test, layer);
1138 CompositionResult::setupLayerState(test, layer);
1139 }
1140
1141 static void setupForDirtyGeometry(CompositionTest* test) {
1142 setupCommon(test);
1143
1144 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1145 CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1146 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1147 CompositionResult::template setupCallExpectations<ThisCase>(test);
1148 }
1149
1150 static void setupForDirtyFrame(CompositionTest* test) {
1151 setupCommon(test);
1152
1153 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1154 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1155 CompositionResult::template setupCallExpectations<ThisCase>(test);
1156 }
1157
1158 static void setupForScreenCapture(CompositionTest* test) {
1159 setupCommon(test);
1160
1161 Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1162 CompositionResult::template setupCallExpectations<ThisCase>(test);
1163 }
1164
1165 static void cleanup(CompositionTest* test) {
1166 Layer::cleanupInjectedLayers(test);
1167
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001168 for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1169 static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1170 ->mutableLayers()
1171 .clear();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001172 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001173 }
1174};
1175
1176/* ------------------------------------------------------------------------
1177 * Composition cases to test
1178 */
1179
1180TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1181 displayRefreshCompositionDirtyGeometry<
1182 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1183 NoCompositionResultVariant>>();
1184}
1185
1186TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1187 displayRefreshCompositionDirtyFrame<
1188 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1189 NoCompositionResultVariant>>();
1190}
1191
1192TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1193 captureScreenComposition<
1194 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1195 EmptyScreenshotResultVariant>>();
1196}
1197
1198/* ------------------------------------------------------------------------
1199 * Simple buffer layers
1200 */
1201
1202TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001203 displayRefreshCompositionDirtyGeometry<CompositionCase<
1204 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1205 KeepCompositionTypeVariant<
1206 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1207 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001208}
1209
1210TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001211 displayRefreshCompositionDirtyFrame<CompositionCase<
1212 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1213 KeepCompositionTypeVariant<
1214 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1215 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001216}
1217
1218TEST_F(CompositionTest, REComposedNormalBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001219 displayRefreshCompositionDirtyFrame<CompositionCase<
1220 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1221 ChangeCompositionTypeVariant<
1222 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1223 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1224 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001225}
1226
1227TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1228 captureScreenComposition<
1229 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1230 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1231}
1232
1233/* ------------------------------------------------------------------------
1234 * Single-color layers
1235 */
1236
Vishnu Nairfa247b12020-02-11 08:58:26 -08001237TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001238 displayRefreshCompositionDirtyGeometry<CompositionCase<
1239 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1240 KeepCompositionTypeVariant<
1241 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1242 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001243}
1244
Vishnu Nairfa247b12020-02-11 08:58:26 -08001245TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001246 displayRefreshCompositionDirtyFrame<CompositionCase<
1247 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1248 KeepCompositionTypeVariant<
1249 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1250 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001251}
1252
Vishnu Nairfa247b12020-02-11 08:58:26 -08001253TEST_F(CompositionTest, REComposedEffectLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001254 displayRefreshCompositionDirtyFrame<CompositionCase<
1255 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1256 ChangeCompositionTypeVariant<
1257 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR,
1258 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1259 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001260}
1261
Vishnu Nairfa247b12020-02-11 08:58:26 -08001262TEST_F(CompositionTest, captureScreenEffectLayer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001263 captureScreenComposition<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001264 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001265 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1266}
1267
1268/* ------------------------------------------------------------------------
1269 * Layers with sideband buffers
1270 */
1271
1272TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001273 displayRefreshCompositionDirtyGeometry<CompositionCase<
1274 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1275 KeepCompositionTypeVariant<
1276 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1277 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001278}
1279
1280TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001281 displayRefreshCompositionDirtyFrame<CompositionCase<
1282 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1283 KeepCompositionTypeVariant<
1284 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1285 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001286}
1287
1288TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001289 displayRefreshCompositionDirtyFrame<CompositionCase<
1290 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1291 ChangeCompositionTypeVariant<
1292 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND,
1293 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1294 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001295}
1296
1297TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1298 captureScreenComposition<
1299 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1300 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1301}
1302
1303/* ------------------------------------------------------------------------
1304 * Layers with ISurfaceComposerClient::eSecure, on a secure display
1305 */
1306
1307TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001308 displayRefreshCompositionDirtyGeometry<CompositionCase<
1309 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1310 KeepCompositionTypeVariant<
1311 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1312 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001313}
1314
1315TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001316 displayRefreshCompositionDirtyFrame<CompositionCase<
1317 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1318 KeepCompositionTypeVariant<
1319 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1320 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001321}
1322
1323TEST_F(CompositionTest, REComposedSecureBufferLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001324 displayRefreshCompositionDirtyFrame<CompositionCase<
1325 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1326 ChangeCompositionTypeVariant<
1327 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1328 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1329 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001330}
1331
1332TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1333 captureScreenComposition<
1334 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1335 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1336}
1337
1338/* ------------------------------------------------------------------------
1339 * Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1340 */
1341
1342TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001343 displayRefreshCompositionDirtyGeometry<CompositionCase<
1344 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1345 KeepCompositionTypeVariant<
1346 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1347 ForcedClientCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001348}
1349
1350TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001351 displayRefreshCompositionDirtyFrame<CompositionCase<
1352 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1353 KeepCompositionTypeVariant<
1354 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1355 ForcedClientCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001356}
1357
1358TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1359 captureScreenComposition<
1360 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1361 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1362}
1363
1364/* ------------------------------------------------------------------------
Garfield Tande619fa2020-10-02 17:13:53 -07001365 * Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1366 */
1367
1368TEST_F(CompositionTest,
1369 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001370 displayRefreshCompositionDirtyGeometry<CompositionCase<
1371 InsecureDisplaySetupVariant,
1372 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1373 ContainerLayerVariant<SecureLayerProperties>>,
1374 KeepCompositionTypeVariant<
1375 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1376 ForcedClientCompositionResultVariant>>();
Garfield Tande619fa2020-10-02 17:13:53 -07001377}
1378
1379TEST_F(CompositionTest,
1380 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001381 displayRefreshCompositionDirtyFrame<CompositionCase<
1382 InsecureDisplaySetupVariant,
1383 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1384 ContainerLayerVariant<SecureLayerProperties>>,
1385 KeepCompositionTypeVariant<
1386 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1387 ForcedClientCompositionResultVariant>>();
Garfield Tande619fa2020-10-02 17:13:53 -07001388}
1389
1390TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1391 captureScreenComposition<
1392 CompositionCase<InsecureDisplaySetupVariant,
1393 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1394 ContainerLayerVariant<SecureLayerProperties>>,
1395 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1396}
1397
1398/* ------------------------------------------------------------------------
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001399 * Cursor layers
1400 */
1401
1402TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001403 displayRefreshCompositionDirtyGeometry<CompositionCase<
1404 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1405 KeepCompositionTypeVariant<
1406 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1407 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001408}
1409
1410TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001411 displayRefreshCompositionDirtyFrame<CompositionCase<
1412 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1413 KeepCompositionTypeVariant<
1414 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1415 HwcCompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001416}
1417
1418TEST_F(CompositionTest, REComposedCursorLayer) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001419 displayRefreshCompositionDirtyFrame<CompositionCase<
1420 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1421 ChangeCompositionTypeVariant<
1422 aidl::android::hardware::graphics::composer3::Composition::CURSOR,
1423 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1424 RECompositionResultVariant>>();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001425}
1426
1427TEST_F(CompositionTest, captureScreenCursorLayer) {
1428 captureScreenComposition<
1429 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1430 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1431}
1432
1433/* ------------------------------------------------------------------------
1434 * Simple buffer layer on a display which is powered off.
1435 */
1436
1437TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001438 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001439 displayRefreshCompositionDirtyGeometry<CompositionCase<
1440 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001441 KeepCompositionTypeVariant<
1442 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001443 HwcCompositionResultVariant>>();
1444}
1445
1446TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001447 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001448 displayRefreshCompositionDirtyFrame<CompositionCase<
1449 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001450 KeepCompositionTypeVariant<
1451 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001452 HwcCompositionResultVariant>>();
1453}
1454
1455TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001456 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001457 displayRefreshCompositionDirtyFrame<CompositionCase<
1458 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001459 ChangeCompositionTypeVariant<
1460 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1461 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001462 RECompositionResultVariant>>();
1463}
1464
1465TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1466 captureScreenComposition<CompositionCase<
1467 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1468 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1469}
1470
Lloyd Pique4fe29402019-08-12 16:51:24 -07001471/* ------------------------------------------------------------------------
1472 * Client composition forced through debug/developer settings
1473 */
1474
1475TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001476 displayRefreshCompositionDirtyGeometry<CompositionCase<
1477 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1478 KeepCompositionTypeVariant<
1479 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1480 ForcedClientCompositionViaDebugOptionResultVariant>>();
Lloyd Pique4fe29402019-08-12 16:51:24 -07001481}
1482
1483TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001484 displayRefreshCompositionDirtyFrame<CompositionCase<
1485 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1486 KeepCompositionTypeVariant<
1487 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1488 ForcedClientCompositionViaDebugOptionResultVariant>>();
Lloyd Pique4fe29402019-08-12 16:51:24 -07001489}
1490
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001491} // namespace
1492} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001493
1494// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01001495#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"