1 /*
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
17 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wconversion"
20 #pragma clang diagnostic ignored "-Wextra"
21
22 #undef LOG_TAG
23 #define LOG_TAG "CompositionTest"
24
25 #include <compositionengine/Display.h>
26 #include <compositionengine/mock/DisplaySurface.h>
27 #include <ftl/future.h>
28 #include <gmock/gmock.h>
29 #include <gtest/gtest.h>
30 #include <gui/IProducerListener.h>
31 #include <gui/LayerMetadata.h>
32 #include <log/log.h>
33 #include <renderengine/ExternalTexture.h>
34 #include <renderengine/mock/FakeExternalTexture.h>
35 #include <renderengine/mock/RenderEngine.h>
36 #include <system/window.h>
37 #include <utils/String8.h>
38
39 #include "Layer.h"
40 #include "TestableSurfaceFlinger.h"
41 #include "mock/DisplayHardware/MockComposer.h"
42 #include "mock/MockEventThread.h"
43 #include "mock/MockTimeStats.h"
44 #include "mock/MockVsyncController.h"
45 #include "mock/PowerAdvisor/MockPowerAdvisor.h"
46 #include "mock/system/window/MockNativeWindow.h"
47
48 namespace android {
49 namespace {
50
51 namespace hal = android::hardware::graphics::composer::hal;
52
53 using hal::Error;
54 using hal::IComposer;
55 using hal::IComposerClient;
56 using hal::PowerMode;
57 using hal::Transform;
58
59 using aidl::android::hardware::graphics::composer3::Capability;
60
61 using testing::_;
62 using testing::AtLeast;
63 using testing::DoAll;
64 using testing::IsNull;
65 using testing::Mock;
66 using testing::Return;
67 using testing::ReturnRef;
68 using testing::SetArgPointee;
69
70 using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
71 using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;
72 using namespace ftl::flag_operators;
73
74 constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DISPLAY_ID;
75 constexpr hal::HWLayerId HWC_LAYER = 5000;
76 constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0);
77
78 constexpr uint8_t DEFAULT_DISPLAY_PORT = 42u;
79 constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(DEFAULT_DISPLAY_PORT);
80 constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
81 constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
82
83 constexpr int DEFAULT_TEXTURE_ID = 6000;
84 constexpr ui::LayerStack LAYER_STACK{7000u};
85
86 constexpr int DEFAULT_DISPLAY_MAX_LUMINANCE = 500;
87
88 constexpr int DEFAULT_SIDEBAND_STREAM = 51;
89
90 MATCHER(IsIdentityMatrix, "") {
91 constexpr auto kIdentity = mat4();
92 return (mat4(arg) == kIdentity);
93 }
94
95 class CompositionTest : public testing::Test {
96 public:
CompositionTest()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
102 mFlinger.setupMockScheduler({.displayId = DEFAULT_DISPLAY_ID});
103
104 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)));
108
109 mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
110 mFlinger.setupTimeStats(std::shared_ptr<TimeStats>(mTimeStats));
111
112 mComposer = new Hwc2::mock::Composer();
113 mPowerAdvisor = new adpf::mock::PowerAdvisor();
114 mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
115 mFlinger.setupPowerAdvisor(std::unique_ptr<adpf::PowerAdvisor>(mPowerAdvisor));
116 mFlinger.mutableMaxRenderTargetSize() = 16384;
117 }
118
~CompositionTest()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
setupForceGeometryDirty()125 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
132 mFlinger.mutableGeometryDirty() = true;
133 }
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
144 std::unordered_set<Capability> mDefaultCapabilities = {Capability::SIDEBAND_STREAM};
145
146 bool mDisplayOff = false;
147 TestableSurfaceFlinger mFlinger;
148 sp<DisplayDevice> mDisplay;
149 sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
150 sp<compositionengine::mock::DisplaySurface>::make();
151 sp<mock::NativeWindow> mNativeWindow = sp<mock::NativeWindow>::make();
152
153 sp<GraphicBuffer> mBuffer =
154 sp<GraphicBuffer>::make(1u, 1u, PIXEL_FORMAT_RGBA_8888,
155 GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN);
156 ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();
157
158 Hwc2::mock::Composer* mComposer = nullptr;
159 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
160 mock::TimeStats* mTimeStats = new mock::TimeStats();
161 adpf::mock::PowerAdvisor* mPowerAdvisor = nullptr;
162
163 sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;
164
165 std::shared_ptr<renderengine::ExternalTexture> mCaptureScreenBuffer;
166 };
167
168 template <typename LayerCase>
displayRefreshCompositionDirtyGeometry()169 void CompositionTest::displayRefreshCompositionDirtyGeometry() {
170 setupForceGeometryDirty();
171 LayerCase::setupForDirtyGeometry(this);
172
173 // --------------------------------------------------------------------
174 // Invocation
175
176 mFlinger.commitAndComposite();
177
178 LayerCase::cleanup(this);
179 }
180
181 template <typename LayerCase>
displayRefreshCompositionDirtyFrame()182 void CompositionTest::displayRefreshCompositionDirtyFrame() {
183 LayerCase::setupForDirtyFrame(this);
184
185 // --------------------------------------------------------------------
186 // Invocation
187
188 mFlinger.commitAndComposite();
189
190 LayerCase::cleanup(this);
191 }
192
193 template <typename LayerCase>
captureScreenComposition()194 void CompositionTest::captureScreenComposition() {
195 LayerCase::setupForScreenCapture(this);
196 mFlinger.commit();
197
198 const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
199 constexpr bool regionSampling = false;
200
201 auto getLayerSnapshotsFn = mFlinger.getLayerSnapshotsForScreenshotsFn(mDisplay->getLayerStack(),
202 CaptureArgs::UNSET_UID);
203
204 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
205 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
206 mCaptureScreenBuffer =
207 std::make_shared<renderengine::mock::FakeExternalTexture>(sourceCrop.getSize().width,
208 sourceCrop.getSize().height,
209 HAL_PIXEL_FORMAT_RGBA_8888, 1,
210 usage);
211
212 auto future = mFlinger.renderScreenImpl(mDisplay, sourceCrop, ui::Dataspace::V0_SRGB,
213 getLayerSnapshotsFn, mCaptureScreenBuffer,
214 regionSampling, mDisplay->isSecure(),
215 /* seamlessTransition */ true);
216 ASSERT_TRUE(future.valid());
217 const auto fenceResult = future.get();
218
219 EXPECT_EQ(NO_ERROR, fenceStatus(fenceResult));
220 if (fenceResult.ok()) {
221 fenceResult.value()->waitForever(LOG_TAG);
222 }
223
224 LayerCase::cleanup(this);
225 }
226
227 /* ------------------------------------------------------------------------
228 * Variants for each display configuration which can be tested
229 */
230
231 template <typename Derived>
232 struct BaseDisplayVariant {
233 static constexpr bool IS_SECURE = true;
234 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
235
setupPreconditionsandroid::__anonc5136c760111::BaseDisplayVariant236 static void setupPreconditions(CompositionTest* test) {
237 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
238 .WillOnce(Return(Error::NONE));
239
240 FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
241 .setCapabilities(&test->mDefaultCapabilities)
242 .setPowerMode(Derived::INIT_POWER_MODE)
243 .inject(&test->mFlinger, test->mComposer);
244 Mock::VerifyAndClear(test->mComposer);
245
246 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
247 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
248 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
249 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
250 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
251 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
252 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
253
254 const ::testing::TestInfo* const test_info =
255 ::testing::UnitTest::GetInstance()->current_test_info();
256
257 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
258 .setId(DEFAULT_DISPLAY_ID)
259 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
260 .setIsSecure(Derived::IS_SECURE)
261 .setPowerAdvisor(test->mPowerAdvisor)
262 .setName(std::string("Injected display for ") +
263 test_info->test_case_name() + "." + test_info->name())
264 .build();
265
266 auto compositionDisplay =
267 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
268 ceDisplayArgs);
269
270 constexpr auto kDisplayConnectionType = ui::DisplayConnectionType::Internal;
271 constexpr bool kIsPrimary = true;
272
273 test->mDisplay =
274 FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
275 kDisplayConnectionType, DEFAULT_DISPLAY_PORT, HWC_DISPLAY,
276 kIsPrimary)
277 .setDisplaySurface(test->mDisplaySurface)
278 .setNativeWindow(test->mNativeWindow)
279 .setSecure(Derived::IS_SECURE)
280 .setPowerMode(Derived::INIT_POWER_MODE)
281 .setRefreshRateSelector(test->mFlinger.scheduler()->refreshRateSelector())
282 .skipSchedulerRegistration()
283 .inject();
284 Mock::VerifyAndClear(test->mNativeWindow.get());
285
286 constexpr bool kIsInternal = kDisplayConnectionType == ui::DisplayConnectionType::Internal;
287 test->mDisplay->setLayerFilter({LAYER_STACK, kIsInternal});
288 }
289
290 template <typename Case>
setupPreconditionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant291 static void setupPreconditionCallExpectations(CompositionTest* test) {
292 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))
293 .WillOnce(DoAll(SetArgPointee<1>(
294 std::vector<aidl::android::hardware::graphics::composer3::
295 DisplayCapability>({})),
296 Return(Error::NONE)));
297 }
298
299 template <typename Case>
setupCommonCompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant300 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
301 EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
302 EXPECT_CALL(*test->mComposer, getDisplayRequests(HWC_DISPLAY, _, _, _)).Times(1);
303 EXPECT_CALL(*test->mComposer, acceptDisplayChanges(HWC_DISPLAY)).Times(1);
304 EXPECT_CALL(*test->mComposer, presentDisplay(HWC_DISPLAY, _)).Times(1);
305 EXPECT_CALL(*test->mComposer, getReleaseFences(HWC_DISPLAY, _, _)).Times(1);
306
307 EXPECT_CALL(*test->mDisplaySurface, onFrameCommitted()).Times(1);
308 EXPECT_CALL(*test->mDisplaySurface, advanceFrame(_)).Times(1);
309
310 Case::CompositionType::setupHwcSetCallExpectations(test);
311 Case::CompositionType::setupHwcGetCallExpectations(test);
312 }
313
314 template <typename Case>
setupCommonScreensCaptureCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant315 static void setupCommonScreensCaptureCallExpectations(CompositionTest* test) {
316 EXPECT_CALL(*test->mRenderEngine, drawLayers)
317 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
318 const std::vector<renderengine::LayerSettings>&,
319 const std::shared_ptr<renderengine::ExternalTexture>&,
320 base::unique_fd&&) -> ftl::Future<FenceResult> {
321 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
322 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
323 displaySettings.physicalDisplay);
324 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
325 displaySettings.clip);
326 return ftl::yield<FenceResult>(Fence::NO_FENCE);
327 });
328 }
329
setupNonEmptyFrameCompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant330 static void setupNonEmptyFrameCompositionCallExpectations(CompositionTest* test) {
331 EXPECT_CALL(*test->mDisplaySurface, beginFrame(true)).Times(1);
332 }
333
setupEmptyFrameCompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant334 static void setupEmptyFrameCompositionCallExpectations(CompositionTest* test) {
335 EXPECT_CALL(*test->mDisplaySurface, beginFrame(false)).Times(1);
336 }
337
setupHwcCompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant338 static void setupHwcCompositionCallExpectations(CompositionTest* test) {
339 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _, _))
340 .Times(1);
341
342 EXPECT_CALL(*test->mDisplaySurface,
343 prepareFrame(compositionengine::DisplaySurface::CompositionType::Hwc))
344 .Times(1);
345 }
346
setupHwcClientCompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant347 static void setupHwcClientCompositionCallExpectations(CompositionTest* test) {
348 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _, _))
349 .Times(1);
350 }
351
setupHwcForcedClientCompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant352 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
353 EXPECT_CALL(*test->mComposer, validateDisplay(HWC_DISPLAY, _, _, _, _)).Times(1);
354 }
355
setupRECompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant356 static void setupRECompositionCallExpectations(CompositionTest* test) {
357 EXPECT_CALL(*test->mDisplaySurface,
358 prepareFrame(compositionengine::DisplaySurface::CompositionType::Gpu))
359 .Times(1);
360 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
361 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
362
363 EXPECT_CALL(*test->mNativeWindow, queueBuffer(_, _)).WillOnce(Return(0));
364 EXPECT_CALL(*test->mNativeWindow, dequeueBuffer(_, _))
365 .WillOnce(DoAll(SetArgPointee<0>(test->mNativeWindowBuffer), SetArgPointee<1>(-1),
366 Return(0)));
367 EXPECT_CALL(*test->mRenderEngine, drawLayers)
368 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
369 const std::vector<renderengine::LayerSettings>&,
370 const std::shared_ptr<renderengine::ExternalTexture>&,
371 base::unique_fd&&) -> ftl::Future<FenceResult> {
372 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
373 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
374 displaySettings.physicalDisplay);
375 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
376 displaySettings.clip);
377 EXPECT_EQ(ui::Dataspace::UNKNOWN, displaySettings.outputDataspace);
378 return ftl::yield<FenceResult>(Fence::NO_FENCE);
379 });
380 }
381
382 template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant383 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
384 Case::Layer::setupRECompositionCallExpectations(test);
385 }
386
387 template <typename Case>
setupRELayerScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::BaseDisplayVariant388 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
389 Case::Layer::setupREScreenshotCompositionCallExpectations(test);
390 }
391 };
392
393 struct DefaultDisplaySetupVariant : public BaseDisplayVariant<DefaultDisplaySetupVariant> {};
394
395 struct InsecureDisplaySetupVariant : public BaseDisplayVariant<InsecureDisplaySetupVariant> {
396 static constexpr bool IS_SECURE = false;
397
398 template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anonc5136c760111::InsecureDisplaySetupVariant399 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
400 Case::Layer::setupInsecureRECompositionCallExpectations(test);
401 }
402
403 template <typename Case>
setupRELayerScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::InsecureDisplaySetupVariant404 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
405 Case::Layer::setupInsecureREScreenshotCompositionCallExpectations(test);
406 }
407 };
408
409 struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDisplaySetupVariant> {
410 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::OFF;
411
412 template <typename Case>
setupPreconditionCallExpectationsandroid::__anonc5136c760111::PoweredOffDisplaySetupVariant413 static void setupPreconditionCallExpectations(CompositionTest*) {}
414
415 template <typename Case>
setupCommonCompositionCallExpectationsandroid::__anonc5136c760111::PoweredOffDisplaySetupVariant416 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
417 // TODO: This seems like an unnecessary call if display is powered off.
418 EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
419
420 // TODO: This seems like an unnecessary call if display is powered off.
421 Case::CompositionType::setupHwcSetCallExpectations(test);
422 }
423
setupHwcCompositionCallExpectationsandroid::__anonc5136c760111::PoweredOffDisplaySetupVariant424 static void setupHwcCompositionCallExpectations(CompositionTest*) {}
setupHwcClientCompositionCallExpectationsandroid::__anonc5136c760111::PoweredOffDisplaySetupVariant425 static void setupHwcClientCompositionCallExpectations(CompositionTest*) {}
setupHwcForcedClientCompositionCallExpectationsandroid::__anonc5136c760111::PoweredOffDisplaySetupVariant426 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest*) {}
427
setupRECompositionCallExpectationsandroid::__anonc5136c760111::PoweredOffDisplaySetupVariant428 static void setupRECompositionCallExpectations(CompositionTest* test) {
429 // TODO: This seems like an unnecessary call if display is powered off.
430 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
431 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
432 }
433
434 template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anonc5136c760111::PoweredOffDisplaySetupVariant435 static void setupRELayerCompositionCallExpectations(CompositionTest*) {}
436 };
437
438 /* ------------------------------------------------------------------------
439 * Variants for each layer configuration which can be tested
440 */
441
442 template <typename LayerProperties>
443 struct BaseLayerProperties {
444 static constexpr uint32_t WIDTH = 100;
445 static constexpr uint32_t HEIGHT = 100;
446 static constexpr PixelFormat FORMAT = PIXEL_FORMAT_RGBA_8888;
447 static constexpr uint64_t USAGE =
448 GraphicBuffer::USAGE_SW_READ_NEVER | GraphicBuffer::USAGE_SW_WRITE_NEVER;
449 static constexpr android_dataspace DATASPACE = HAL_DATASPACE_UNKNOWN;
450 static constexpr uint32_t SCALING_MODE = 0;
451 static constexpr uint32_t TRANSFORM = 0;
452 static constexpr uint32_t LAYER_FLAGS = 0;
453 static constexpr float COLOR[] = {1.f, 1.f, 1.f, 1.f};
454 static constexpr IComposerClient::BlendMode BLENDMODE =
455 IComposerClient::BlendMode::PREMULTIPLIED;
456
setupLatchedBufferandroid::__anonc5136c760111::BaseLayerProperties457 static void setupLatchedBuffer(CompositionTest* test, frontend::RequestedLayerState& layer) {
458 Mock::VerifyAndClear(test->mRenderEngine);
459
460 const auto buffer = std::make_shared<
461 renderengine::mock::FakeExternalTexture>(LayerProperties::WIDTH,
462 LayerProperties::HEIGHT,
463 DEFAULT_TEXTURE_ID,
464 LayerProperties::FORMAT,
465 LayerProperties::USAGE |
466 GraphicBuffer::USAGE_HW_TEXTURE);
467 layer.crop = FloatRect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
468 layer.externalTexture = buffer;
469 layer.bufferData->acquireFence = Fence::NO_FENCE;
470 layer.dataspace = ui::Dataspace::UNKNOWN;
471 layer.setSurfaceDamageRegion(Region(Rect(LayerProperties::HEIGHT, LayerProperties::WIDTH)));
472 Mock::VerifyAndClear(test->mRenderEngine);
473 }
474
setupLayerStateandroid::__anonc5136c760111::BaseLayerProperties475 static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState& layer) {
476 setupLatchedBuffer(test, layer);
477 }
478
setupHwcSetGeometryCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties479 static void setupHwcSetGeometryCallExpectations(CompositionTest* test) {
480 if (!test->mDisplayOff) {
481 // TODO: Coverage of other values
482 EXPECT_CALL(*test->mComposer,
483 setLayerBlendMode(HWC_DISPLAY, HWC_LAYER, LayerProperties::BLENDMODE))
484 .Times(1);
485 // TODO: Coverage of other values for origin
486 EXPECT_CALL(*test->mComposer,
487 setLayerDisplayFrame(HWC_DISPLAY, HWC_LAYER,
488 IComposerClient::Rect({0, 0, LayerProperties::WIDTH,
489 LayerProperties::HEIGHT})))
490 .Times(1);
491 EXPECT_CALL(*test->mComposer,
492 setLayerPlaneAlpha(HWC_DISPLAY, HWC_LAYER, LayerProperties::COLOR[3]))
493 .Times(1);
494 // TODO: Coverage of other values
495 EXPECT_CALL(*test->mComposer, setLayerZOrder(HWC_DISPLAY, HWC_LAYER, 0u)).Times(1);
496
497 // These expectations retire on saturation as the code path these
498 // expectations are for appears to make an extra call to them.
499 // TODO: Investigate this extra call
500 EXPECT_CALL(*test->mComposer,
501 setLayerTransform(HWC_DISPLAY, HWC_LAYER, DEFAULT_TRANSFORM))
502 .Times(AtLeast(1))
503 .RetiresOnSaturation();
504 }
505 }
506
setupHwcSetSourceCropBufferCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties507 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
508 if (!test->mDisplayOff) {
509 EXPECT_CALL(*test->mComposer,
510 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
511 IComposerClient::FRect({0.f, 0.f, LayerProperties::WIDTH,
512 LayerProperties::HEIGHT})))
513 .Times(1);
514 }
515 }
516
setupHwcSetSourceCropColorCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties517 static void setupHwcSetSourceCropColorCallExpectations(CompositionTest* test) {
518 if (!test->mDisplayOff) {
519 EXPECT_CALL(*test->mComposer,
520 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
521 IComposerClient::FRect({0.f, 0.f, 0.f, 0.f})))
522 .Times(1);
523 }
524 }
525
setupHwcSetPerFrameCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties526 static void setupHwcSetPerFrameCallExpectations(CompositionTest* test) {
527 if (!test->mDisplayOff) {
528 EXPECT_CALL(*test->mComposer,
529 setLayerVisibleRegion(HWC_DISPLAY, HWC_LAYER,
530 std::vector<IComposerClient::Rect>(
531 {IComposerClient::Rect(
532 {0, 0, LayerProperties::WIDTH,
533 LayerProperties::HEIGHT})})))
534 .Times(1);
535 }
536 }
537
setupHwcSetPerFrameColorCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties538 static void setupHwcSetPerFrameColorCallExpectations(CompositionTest* test) {
539 if (!test->mDisplayOff) {
540 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
541 .Times(1);
542
543 // TODO: use COLOR
544 EXPECT_CALL(*test->mComposer,
545 setLayerColor(HWC_DISPLAY, HWC_LAYER,
546 aidl::android::hardware::graphics::composer3::Color(
547 {1.0f, 1.0f, 1.0f, 1.0f})))
548 .Times(1);
549 }
550 }
551
setupHwcSetPerFrameBufferCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties552 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
553 if (!test->mDisplayOff) {
554 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
555 .Times(1);
556 EXPECT_CALL(*test->mComposer, setLayerBuffer(HWC_DISPLAY, HWC_LAYER, _, _, _)).Times(1);
557 }
558 }
559
setupREBufferCompositionCommonCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties560 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* test) {
561 EXPECT_CALL(*test->mRenderEngine, drawLayers)
562 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
563 const std::vector<renderengine::LayerSettings>& layerSettings,
564 const std::shared_ptr<renderengine::ExternalTexture>&,
565 base::unique_fd&&) -> ftl::Future<FenceResult> {
566 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
567 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
568 displaySettings.physicalDisplay);
569 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
570 displaySettings.clip);
571 // screen capture adds an additional color layer as an alpha
572 // prefill, so gtet the back layer.
573 ftl::Future<FenceResult> resultFuture =
574 ftl::yield<FenceResult>(Fence::NO_FENCE);
575 if (layerSettings.empty()) {
576 ADD_FAILURE() << "layerSettings was not expected to be empty in "
577 "setupREBufferCompositionCommonCallExpectations "
578 "verification lambda";
579 return resultFuture;
580 }
581 const renderengine::LayerSettings layer = layerSettings.back();
582 EXPECT_THAT(layer.source.buffer.buffer, Not(IsNull()));
583 EXPECT_THAT(layer.source.buffer.fence, Not(IsNull()));
584 EXPECT_EQ(true, layer.source.buffer.usePremultipliedAlpha);
585 EXPECT_EQ(false, layer.source.buffer.isOpaque);
586 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
587 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
588 EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
589 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
590 return resultFuture;
591 });
592 }
593
setupREBufferCompositionCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties594 static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
595 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
596 }
597
setupInsecureREBufferCompositionCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties598 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
599 setupREBufferCompositionCallExpectations(test);
600 }
601
setupREBufferScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties602 static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
603 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
604 }
605
setupInsecureREBufferScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties606 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
607 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
608 }
609
setupREColorCompositionCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties610 static void setupREColorCompositionCallExpectations(CompositionTest* test) {
611 EXPECT_CALL(*test->mRenderEngine, drawLayers)
612 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
613 const std::vector<renderengine::LayerSettings>& layerSettings,
614 const std::shared_ptr<renderengine::ExternalTexture>&,
615 base::unique_fd&&) -> ftl::Future<FenceResult> {
616 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
617 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
618 displaySettings.physicalDisplay);
619 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
620 displaySettings.clip);
621 // screen capture adds an additional color layer as an alpha
622 // prefill, so get the back layer.
623 ftl::Future<FenceResult> resultFuture =
624 ftl::yield<FenceResult>(Fence::NO_FENCE);
625 if (layerSettings.empty()) {
626 ADD_FAILURE()
627 << "layerSettings was not expected to be empty in "
628 "setupREColorCompositionCallExpectations verification lambda";
629 return resultFuture;
630 }
631 const renderengine::LayerSettings layer = layerSettings.back();
632 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
633 EXPECT_EQ(half3(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
634 LayerProperties::COLOR[2]),
635 layer.source.solidColor);
636 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
637 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
638 EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
639 EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
640 return resultFuture;
641 });
642 }
643
setupREColorScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::BaseLayerProperties644 static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
645 setupREColorCompositionCallExpectations(test);
646 }
647 };
648
649 struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
650
651 struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
652 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
653 };
654
655 struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
656 using Base = BaseLayerProperties<SidebandLayerProperties>;
657 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
658
setupLayerStateandroid::__anonc5136c760111::SidebandLayerProperties659 static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState& layer) {
660 sp<NativeHandle> stream =
661 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
662 false);
663 layer.sidebandStream = stream;
664 layer.crop =
665 FloatRect(0, 0, SidebandLayerProperties::HEIGHT, SidebandLayerProperties::WIDTH);
666 }
667
setupHwcSetSourceCropBufferCallExpectationsandroid::__anonc5136c760111::SidebandLayerProperties668 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
669 EXPECT_CALL(*test->mComposer,
670 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
671 IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
672 .Times(1);
673 }
674
setupHwcSetPerFrameBufferCallExpectationsandroid::__anonc5136c760111::SidebandLayerProperties675 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
676 EXPECT_CALL(*test->mComposer,
677 setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
678 reinterpret_cast<native_handle_t*>(
679 DEFAULT_SIDEBAND_STREAM)))
680 .WillOnce(Return(Error::NONE));
681
682 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
683 }
684
setupREBufferCompositionCommonCallExpectationsandroid::__anonc5136c760111::SidebandLayerProperties685 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
686 };
687
688 template <typename LayerProperties>
689 struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
690 using Base = BaseLayerProperties<LayerProperties>;
691
setupInsecureREBufferCompositionCommonCallExpectationsandroid::__anonc5136c760111::CommonSecureLayerProperties692 static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
693 EXPECT_CALL(*test->mRenderEngine, drawLayers)
694 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
695 const std::vector<renderengine::LayerSettings>& layerSettings,
696 const std::shared_ptr<renderengine::ExternalTexture>&,
697 base::unique_fd&&) -> ftl::Future<FenceResult> {
698 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
699 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
700 displaySettings.physicalDisplay);
701 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
702 displaySettings.clip);
703 // screen capture adds an additional color layer as an alpha
704 // prefill, so get the back layer.
705 ftl::Future<FenceResult> resultFuture =
706 ftl::yield<FenceResult>(Fence::NO_FENCE);
707 if (layerSettings.empty()) {
708 ADD_FAILURE() << "layerSettings was not expected to be empty in "
709 "setupInsecureREBufferCompositionCommonCallExpectations "
710 "verification lambda";
711 return resultFuture;
712 }
713 const renderengine::LayerSettings layer = layerSettings.back();
714 EXPECT_THAT(layer.source.buffer.buffer, IsNull());
715 EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer.source.solidColor);
716 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
717 EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
718 EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
719 EXPECT_EQ(1.0f, layer.alpha);
720 return resultFuture;
721 });
722 }
723
setupInsecureREBufferCompositionCallExpectationsandroid::__anonc5136c760111::CommonSecureLayerProperties724 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
725 setupInsecureREBufferCompositionCommonCallExpectations(test);
726 }
727
setupInsecureREBufferScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::CommonSecureLayerProperties728 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
729 setupInsecureREBufferCompositionCommonCallExpectations(test);
730 }
731 };
732
733 struct ParentSecureLayerProperties
734 : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
735
736 struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
737 static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
738 };
739
740 struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
741 using Base = BaseLayerProperties<CursorLayerProperties>;
742
setupLayerStateandroid::__anonc5136c760111::CursorLayerProperties743 static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState& layer) {
744 Base::setupLayerState(test, layer);
745 layer.potentialCursor = true;
746 }
747 };
748
749 struct NoLayerVariant {
createLayerandroid::__anonc5136c760111::NoLayerVariant750 static frontend::RequestedLayerState createLayer(CompositionTest*) {
751 return {LayerCreationArgs()};
752 }
injectLayerandroid::__anonc5136c760111::NoLayerVariant753 static void injectLayer(CompositionTest*, frontend::RequestedLayerState&) {}
cleanupInjectedLayersandroid::__anonc5136c760111::NoLayerVariant754 static void cleanupInjectedLayers(CompositionTest*) {}
755
setupCallExpectationsForDirtyGeometryandroid::__anonc5136c760111::NoLayerVariant756 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
setupCallExpectationsForDirtyFrameandroid::__anonc5136c760111::NoLayerVariant757 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
758 };
759
760 template <typename LayerProperties>
761 struct BaseLayerVariant {
762 template <typename L, typename F>
createLayerWithFactoryandroid::__anonc5136c760111::BaseLayerVariant763 static frontend::RequestedLayerState createLayerWithFactory(CompositionTest* test, F factory) {
764 EXPECT_CALL(*test->mFlinger.scheduler(), postMessage(_)).Times(0);
765
766 auto layer = factory();
767
768 // Layer should be registered with scheduler.
769 EXPECT_EQ(1u, test->mFlinger.scheduler()->layerHistorySize());
770
771 Mock::VerifyAndClear(test->mComposer);
772 Mock::VerifyAndClear(test->mRenderEngine);
773 Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
774
775 initLayerDrawingStateAndComputeBounds(test, layer);
776
777 return layer;
778 }
779
initLayerDrawingStateAndComputeBoundsandroid::__anonc5136c760111::BaseLayerVariant780 static void initLayerDrawingStateAndComputeBounds(CompositionTest* test,
781 frontend::RequestedLayerState& layer) {
782 layer.layerStack = LAYER_STACK;
783 layer.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
784 LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
785 }
786
injectLayerandroid::__anonc5136c760111::BaseLayerVariant787 static void injectLayer(CompositionTest* test, frontend::RequestedLayerState& layer) {
788 EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
789 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
790 auto legacyLayer = test->mFlinger.getLegacyLayer(layer.id);
791 auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
792 legacyLayer->getCompositionEngineLayerFE({.id = layer.id}));
793 outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
794 outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
795
796 Mock::VerifyAndClear(test->mComposer);
797
798 auto layerCopy = std::make_unique<frontend::RequestedLayerState>(layer);
799 test->mFlinger.addLayer(layerCopy);
800 test->mFlinger.mutableVisibleRegionsDirty() = true;
801 }
802
cleanupInjectedLayersandroid::__anonc5136c760111::BaseLayerVariant803 static void cleanupInjectedLayers(CompositionTest* test) {
804 EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
805 .WillOnce(Return(Error::NONE));
806
807 test->mFlinger.destroyAllLayerHandles();
808 test->mDisplay->getCompositionDisplay()->clearOutputLayers();
809 test->mFlinger.mutablePreviouslyComposedLayers().clear();
810 // Layer should be unregistered with scheduler.
811 test->mFlinger.commit();
812 EXPECT_EQ(0u, test->mFlinger.scheduler()->layerHistorySize());
813 }
814 };
815
816 template <typename LayerProperties>
817 struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
818 using Base = BaseLayerVariant<LayerProperties>;
createLayerandroid::__anonc5136c760111::EffectLayerVariant819 static frontend::RequestedLayerState createLayer(CompositionTest* test) {
820 frontend::RequestedLayerState layer = Base::template createLayerWithFactory<
821 frontend::RequestedLayerState>(test, [test]() {
822 auto args = LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(), "test-layer",
823 LayerProperties::LAYER_FLAGS, LayerMetadata());
824 auto legacyLayer = sp<Layer>::make(args);
825 test->mFlinger.injectLegacyLayer(legacyLayer);
826 return frontend::RequestedLayerState(args);
827 });
828
829 layer.crop = FloatRect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
830 return layer;
831 }
832
setupRECompositionCallExpectationsandroid::__anonc5136c760111::EffectLayerVariant833 static void setupRECompositionCallExpectations(CompositionTest* test) {
834 LayerProperties::setupREColorCompositionCallExpectations(test);
835 }
836
setupREScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::EffectLayerVariant837 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
838 LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
839 }
840
setupCallExpectationsForDirtyGeometryandroid::__anonc5136c760111::EffectLayerVariant841 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
842 LayerProperties::setupHwcSetGeometryCallExpectations(test);
843 LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
844 }
845
setupCallExpectationsForDirtyFrameandroid::__anonc5136c760111::EffectLayerVariant846 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
847 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
848 LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
849 }
850 };
851
852 template <typename LayerProperties>
853 struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
854 using Base = BaseLayerVariant<LayerProperties>;
855
createLayerandroid::__anonc5136c760111::BufferLayerVariant856 static frontend::RequestedLayerState createLayer(CompositionTest* test) {
857 frontend::RequestedLayerState layer = Base::template createLayerWithFactory<
858 frontend::RequestedLayerState>(test, [test]() {
859 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
860 LayerProperties::LAYER_FLAGS, LayerMetadata());
861 auto legacyLayer = sp<Layer>::make(args);
862 test->mFlinger.injectLegacyLayer(legacyLayer);
863 return frontend::RequestedLayerState(args);
864 });
865
866 LayerProperties::setupLayerState(test, layer);
867
868 return layer;
869 }
870
cleanupInjectedLayersandroid::__anonc5136c760111::BufferLayerVariant871 static void cleanupInjectedLayers(CompositionTest* test) {
872 Base::cleanupInjectedLayers(test);
873 }
874
setupCallExpectationsForDirtyGeometryandroid::__anonc5136c760111::BufferLayerVariant875 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
876 LayerProperties::setupHwcSetGeometryCallExpectations(test);
877 LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
878 }
879
setupCallExpectationsForDirtyFrameandroid::__anonc5136c760111::BufferLayerVariant880 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
881 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
882 LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
883 }
884
setupRECompositionCallExpectationsandroid::__anonc5136c760111::BufferLayerVariant885 static void setupRECompositionCallExpectations(CompositionTest* test) {
886 LayerProperties::setupREBufferCompositionCallExpectations(test);
887 }
888
setupInsecureRECompositionCallExpectationsandroid::__anonc5136c760111::BufferLayerVariant889 static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
890 LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
891 }
892
setupREScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::BufferLayerVariant893 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
894 LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
895 }
896
setupInsecureREScreenshotCompositionCallExpectationsandroid::__anonc5136c760111::BufferLayerVariant897 static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
898 LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
899 }
900 };
901
902 template <typename LayerProperties>
903 struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
904 using Base = BaseLayerVariant<LayerProperties>;
905
createLayerandroid::__anonc5136c760111::ContainerLayerVariant906 static frontend::RequestedLayerState createLayer(CompositionTest* test) {
907 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
908 LayerProperties::LAYER_FLAGS, LayerMetadata());
909 sp<Layer> legacyLayer = sp<Layer>::make(args);
910 test->mFlinger.injectLegacyLayer(legacyLayer);
911 frontend::RequestedLayerState layer(args);
912 Base::initLayerDrawingStateAndComputeBounds(test, layer);
913 return layer;
914 }
915 };
916
917 template <typename LayerVariant, typename ParentLayerVariant>
918 struct ChildLayerVariant : public LayerVariant {
919 using Base = LayerVariant;
920 using ParentBase = ParentLayerVariant;
921
createLayerandroid::__anonc5136c760111::ChildLayerVariant922 static frontend::RequestedLayerState createLayer(CompositionTest* test) {
923 // Need to create child layer first. Otherwise layer history size will be 2.
924 frontend::RequestedLayerState layer = Base::createLayer(test);
925 frontend::RequestedLayerState parentLayer = ParentBase::createLayer(test);
926 layer.parentId = parentLayer.id;
927 auto layerCopy = std::make_unique<frontend::RequestedLayerState>(parentLayer);
928 test->mFlinger.addLayer(layerCopy);
929 return layer;
930 }
931
cleanupInjectedLayersandroid::__anonc5136c760111::ChildLayerVariant932 static void cleanupInjectedLayers(CompositionTest* test) { Base::cleanupInjectedLayers(test); }
933 };
934
935 /* ------------------------------------------------------------------------
936 * Variants to control how the composition type is changed
937 */
938
939 struct NoCompositionTypeVariant {
setupHwcSetCallExpectationsandroid::__anonc5136c760111::NoCompositionTypeVariant940 static void setupHwcSetCallExpectations(CompositionTest*) {}
941
setupHwcGetCallExpectationsandroid::__anonc5136c760111::NoCompositionTypeVariant942 static void setupHwcGetCallExpectations(CompositionTest* test) {
943 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
944 }
945 };
946
947 template <aidl::android::hardware::graphics::composer3::Composition CompositionType>
948 struct KeepCompositionTypeVariant {
949 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
950 CompositionType;
951
setupHwcSetCallExpectationsandroid::__anonc5136c760111::KeepCompositionTypeVariant952 static void setupHwcSetCallExpectations(CompositionTest* test) {
953 if (!test->mDisplayOff) {
954 EXPECT_CALL(*test->mComposer,
955 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
956 .Times(1);
957 }
958 }
959
setupHwcGetCallExpectationsandroid::__anonc5136c760111::KeepCompositionTypeVariant960 static void setupHwcGetCallExpectations(CompositionTest* test) {
961 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
962 }
963 };
964
965 template <aidl::android::hardware::graphics::composer3::Composition InitialCompositionType,
966 aidl::android::hardware::graphics::composer3::Composition FinalCompositionType>
967 struct ChangeCompositionTypeVariant {
968 static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
969 FinalCompositionType;
970
setupHwcSetCallExpectationsandroid::__anonc5136c760111::ChangeCompositionTypeVariant971 static void setupHwcSetCallExpectations(CompositionTest* test) {
972 if (!test->mDisplayOff) {
973 EXPECT_CALL(*test->mComposer,
974 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
975 .Times(1);
976 }
977 }
978
setupHwcGetCallExpectationsandroid::__anonc5136c760111::ChangeCompositionTypeVariant979 static void setupHwcGetCallExpectations(CompositionTest* test) {
980 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
981 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
982 static_cast<Hwc2::Layer>(HWC_LAYER)}),
983 SetArgPointee<2>(
984 std::vector<aidl::android::hardware::graphics::composer3::
985 Composition>{FinalCompositionType}),
986 Return(Error::NONE)));
987 }
988 };
989
990 /* ------------------------------------------------------------------------
991 * Variants to select how the composition is expected to be handled
992 */
993
994 struct CompositionResultBaseVariant {
setupLayerStateandroid::__anonc5136c760111::CompositionResultBaseVariant995 static void setupLayerState(CompositionTest*, frontend::RequestedLayerState&) {}
996
997 template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anonc5136c760111::CompositionResultBaseVariant998 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
999 Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1000 }
1001
1002 template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anonc5136c760111::CompositionResultBaseVariant1003 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1004 Case::Layer::setupCallExpectationsForDirtyFrame(test);
1005 }
1006 };
1007
1008 struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1009 template <typename Case>
setupCallExpectationsandroid::__anonc5136c760111::NoCompositionResultVariant1010 static void setupCallExpectations(CompositionTest* test) {
1011 Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1012 Case::Display::setupHwcCompositionCallExpectations(test);
1013 }
1014 };
1015
1016 struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1017 template <typename Case>
setupCallExpectationsandroid::__anonc5136c760111::HwcCompositionResultVariant1018 static void setupCallExpectations(CompositionTest* test) {
1019 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1020 Case::Display::setupHwcCompositionCallExpectations(test);
1021 }
1022 };
1023
1024 struct RECompositionResultVariant : public CompositionResultBaseVariant {
1025 template <typename Case>
setupCallExpectationsandroid::__anonc5136c760111::RECompositionResultVariant1026 static void setupCallExpectations(CompositionTest* test) {
1027 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1028 Case::Display::setupHwcClientCompositionCallExpectations(test);
1029 Case::Display::setupRECompositionCallExpectations(test);
1030 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1031 }
1032 };
1033
1034 struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
setupLayerStateandroid::__anonc5136c760111::ForcedClientCompositionResultVariant1035 static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState& layer) {
1036 const auto outputLayer = test->mFlinger.findOutputLayerForDisplay(layer.id, test->mDisplay);
1037 LOG_FATAL_IF(!outputLayer);
1038 outputLayer->editState().forceClientComposition = true;
1039 }
1040
1041 template <typename Case>
setupCallExpectationsandroid::__anonc5136c760111::ForcedClientCompositionResultVariant1042 static void setupCallExpectations(CompositionTest* test) {
1043 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1044 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1045 Case::Display::setupRECompositionCallExpectations(test);
1046 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1047 }
1048
1049 template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anonc5136c760111::ForcedClientCompositionResultVariant1050 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1051
1052 template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anonc5136c760111::ForcedClientCompositionResultVariant1053 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1054 };
1055
1056 struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
setupLayerStateandroid::__anonc5136c760111::ForcedClientCompositionViaDebugOptionResultVariant1057 static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState&) {
1058 test->mFlinger.mutableDebugDisableHWC() = true;
1059 }
1060
1061 template <typename Case>
setupCallExpectationsandroid::__anonc5136c760111::ForcedClientCompositionViaDebugOptionResultVariant1062 static void setupCallExpectations(CompositionTest* test) {
1063 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1064 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1065 Case::Display::setupRECompositionCallExpectations(test);
1066 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1067 }
1068
1069 template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anonc5136c760111::ForcedClientCompositionViaDebugOptionResultVariant1070 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1071
1072 template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anonc5136c760111::ForcedClientCompositionViaDebugOptionResultVariant1073 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1074 };
1075
1076 struct EmptyScreenshotResultVariant {
setupLayerStateandroid::__anonc5136c760111::EmptyScreenshotResultVariant1077 static void setupLayerState(CompositionTest*, frontend::RequestedLayerState&) {}
1078
1079 template <typename Case>
setupCallExpectationsandroid::__anonc5136c760111::EmptyScreenshotResultVariant1080 static void setupCallExpectations(CompositionTest*) {}
1081 };
1082
1083 struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1084 using Base = EmptyScreenshotResultVariant;
1085
1086 template <typename Case>
setupCallExpectationsandroid::__anonc5136c760111::REScreenshotResultVariant1087 static void setupCallExpectations(CompositionTest* test) {
1088 Base::template setupCallExpectations<Case>(test);
1089 Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1090 }
1091 };
1092
1093 /* ------------------------------------------------------------------------
1094 * Composition test case, containing all the variants being tested
1095 */
1096
1097 template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1098 typename CompositionResultCase>
1099 struct CompositionCase {
1100 using ThisCase =
1101 CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1102 using Display = DisplayCase;
1103 using Layer = LayerCase;
1104 using CompositionType = CompositionTypeCase;
1105 using CompositionResult = CompositionResultCase;
1106
setupCommonandroid::__anonc5136c760111::CompositionCase1107 static void setupCommon(CompositionTest* test) {
1108 Display::template setupPreconditionCallExpectations<ThisCase>(test);
1109 Display::setupPreconditions(test);
1110
1111 auto layer = Layer::createLayer(test);
1112 Layer::injectLayer(test, layer);
1113 CompositionResult::setupLayerState(test, layer);
1114 }
1115
setupForDirtyGeometryandroid::__anonc5136c760111::CompositionCase1116 static void setupForDirtyGeometry(CompositionTest* test) {
1117 setupCommon(test);
1118
1119 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1120 CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1121 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1122 CompositionResult::template setupCallExpectations<ThisCase>(test);
1123 }
1124
setupForDirtyFrameandroid::__anonc5136c760111::CompositionCase1125 static void setupForDirtyFrame(CompositionTest* test) {
1126 setupCommon(test);
1127
1128 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1129 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1130 CompositionResult::template setupCallExpectations<ThisCase>(test);
1131 }
1132
setupForScreenCaptureandroid::__anonc5136c760111::CompositionCase1133 static void setupForScreenCapture(CompositionTest* test) {
1134 setupCommon(test);
1135
1136 Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1137 CompositionResult::template setupCallExpectations<ThisCase>(test);
1138 }
1139
cleanupandroid::__anonc5136c760111::CompositionCase1140 static void cleanup(CompositionTest* test) {
1141 Layer::cleanupInjectedLayers(test);
1142
1143 for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1144 static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1145 ->mutableLayers()
1146 .clear();
1147 }
1148 }
1149 };
1150
1151 /* ------------------------------------------------------------------------
1152 * Composition cases to test
1153 */
1154
TEST_F(CompositionTest,noLayersDoesMinimalWorkWithDirtyGeometry)1155 TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1156 displayRefreshCompositionDirtyGeometry<
1157 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1158 NoCompositionResultVariant>>();
1159 }
1160
TEST_F(CompositionTest,noLayersDoesMinimalWorkWithDirtyFrame)1161 TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1162 displayRefreshCompositionDirtyFrame<
1163 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1164 NoCompositionResultVariant>>();
1165 }
1166
TEST_F(CompositionTest,noLayersDoesMinimalWorkToCaptureScreen)1167 TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1168 captureScreenComposition<
1169 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1170 EmptyScreenshotResultVariant>>();
1171 }
1172
1173 /* ------------------------------------------------------------------------
1174 * Simple buffer layers
1175 */
1176
TEST_F(CompositionTest,HWCComposedNormalBufferLayerWithDirtyGeometry)1177 TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
1178 displayRefreshCompositionDirtyGeometry<CompositionCase<
1179 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1180 KeepCompositionTypeVariant<
1181 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1182 HwcCompositionResultVariant>>();
1183 }
1184
TEST_F(CompositionTest,HWCComposedNormalBufferLayerWithDirtyFrame)1185 TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
1186 displayRefreshCompositionDirtyFrame<CompositionCase<
1187 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1188 KeepCompositionTypeVariant<
1189 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1190 HwcCompositionResultVariant>>();
1191 }
1192
TEST_F(CompositionTest,REComposedNormalBufferLayer)1193 TEST_F(CompositionTest, REComposedNormalBufferLayer) {
1194 displayRefreshCompositionDirtyFrame<CompositionCase<
1195 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1196 ChangeCompositionTypeVariant<
1197 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1198 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1199 RECompositionResultVariant>>();
1200 }
1201
TEST_F(CompositionTest,captureScreenNormalBufferLayer)1202 TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1203 captureScreenComposition<
1204 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1205 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1206 }
1207
1208 /* ------------------------------------------------------------------------
1209 * Single-color layers
1210 */
1211
TEST_F(CompositionTest,HWCComposedEffectLayerWithDirtyGeometry)1212 TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
1213 displayRefreshCompositionDirtyGeometry<CompositionCase<
1214 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1215 KeepCompositionTypeVariant<
1216 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1217 HwcCompositionResultVariant>>();
1218 }
1219
TEST_F(CompositionTest,HWCComposedEffectLayerWithDirtyFrame)1220 TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
1221 displayRefreshCompositionDirtyFrame<CompositionCase<
1222 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1223 KeepCompositionTypeVariant<
1224 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1225 HwcCompositionResultVariant>>();
1226 }
1227
TEST_F(CompositionTest,REComposedEffectLayer)1228 TEST_F(CompositionTest, REComposedEffectLayer) {
1229 displayRefreshCompositionDirtyFrame<CompositionCase<
1230 DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1231 ChangeCompositionTypeVariant<
1232 aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR,
1233 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1234 RECompositionResultVariant>>();
1235 }
1236
TEST_F(CompositionTest,captureScreenEffectLayer)1237 TEST_F(CompositionTest, captureScreenEffectLayer) {
1238 captureScreenComposition<
1239 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1240 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1241 }
1242
1243 /* ------------------------------------------------------------------------
1244 * Layers with sideband buffers
1245 */
1246
TEST_F(CompositionTest,HWCComposedSidebandBufferLayerWithDirtyGeometry)1247 TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
1248 displayRefreshCompositionDirtyGeometry<CompositionCase<
1249 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1250 KeepCompositionTypeVariant<
1251 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1252 HwcCompositionResultVariant>>();
1253 }
1254
TEST_F(CompositionTest,HWCComposedSidebandBufferLayerWithDirtyFrame)1255 TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
1256 displayRefreshCompositionDirtyFrame<CompositionCase<
1257 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1258 KeepCompositionTypeVariant<
1259 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1260 HwcCompositionResultVariant>>();
1261 }
1262
TEST_F(CompositionTest,REComposedSidebandBufferLayer)1263 TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
1264 displayRefreshCompositionDirtyFrame<CompositionCase<
1265 DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1266 ChangeCompositionTypeVariant<
1267 aidl::android::hardware::graphics::composer3::Composition::SIDEBAND,
1268 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1269 RECompositionResultVariant>>();
1270 }
1271
TEST_F(CompositionTest,captureScreenSidebandBufferLayer)1272 TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1273 captureScreenComposition<
1274 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1275 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1276 }
1277
1278 /* ------------------------------------------------------------------------
1279 * Layers with ISurfaceComposerClient::eSecure, on a secure display
1280 */
1281
TEST_F(CompositionTest,HWCComposedSecureBufferLayerWithDirtyGeometry)1282 TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
1283 displayRefreshCompositionDirtyGeometry<CompositionCase<
1284 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1285 KeepCompositionTypeVariant<
1286 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1287 HwcCompositionResultVariant>>();
1288 }
1289
TEST_F(CompositionTest,HWCComposedSecureBufferLayerWithDirtyFrame)1290 TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
1291 displayRefreshCompositionDirtyFrame<CompositionCase<
1292 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1293 KeepCompositionTypeVariant<
1294 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1295 HwcCompositionResultVariant>>();
1296 }
1297
TEST_F(CompositionTest,REComposedSecureBufferLayer)1298 TEST_F(CompositionTest, REComposedSecureBufferLayer) {
1299 displayRefreshCompositionDirtyFrame<CompositionCase<
1300 DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1301 ChangeCompositionTypeVariant<
1302 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1303 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1304 RECompositionResultVariant>>();
1305 }
1306
TEST_F(CompositionTest,captureScreenSecureBufferLayerOnSecureDisplay)1307 TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1308 captureScreenComposition<
1309 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1310 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1311 }
1312
1313 /* ------------------------------------------------------------------------
1314 * Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1315 */
1316
TEST_F(CompositionTest,HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry)1317 TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
1318 displayRefreshCompositionDirtyGeometry<CompositionCase<
1319 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1320 KeepCompositionTypeVariant<
1321 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1322 ForcedClientCompositionResultVariant>>();
1323 }
1324
TEST_F(CompositionTest,HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame)1325 TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
1326 displayRefreshCompositionDirtyFrame<CompositionCase<
1327 InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1328 KeepCompositionTypeVariant<
1329 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1330 ForcedClientCompositionResultVariant>>();
1331 }
1332
TEST_F(CompositionTest,captureScreenSecureBufferLayerOnInsecureDisplay)1333 TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1334 captureScreenComposition<
1335 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1336 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1337 }
1338
1339 /* ------------------------------------------------------------------------
1340 * Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1341 */
1342
TEST_F(CompositionTest,captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay)1343 TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1344 captureScreenComposition<
1345 CompositionCase<InsecureDisplaySetupVariant,
1346 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1347 ContainerLayerVariant<SecureLayerProperties>>,
1348 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1349 }
1350
1351 /* ------------------------------------------------------------------------
1352 * Cursor layers
1353 */
1354
TEST_F(CompositionTest,HWCComposedCursorLayerWithDirtyGeometry)1355 TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
1356 displayRefreshCompositionDirtyGeometry<CompositionCase<
1357 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1358 KeepCompositionTypeVariant<
1359 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1360 HwcCompositionResultVariant>>();
1361 }
1362
TEST_F(CompositionTest,HWCComposedCursorLayerWithDirtyFrame)1363 TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
1364 displayRefreshCompositionDirtyFrame<CompositionCase<
1365 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1366 KeepCompositionTypeVariant<
1367 aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1368 HwcCompositionResultVariant>>();
1369 }
1370
TEST_F(CompositionTest,REComposedCursorLayer)1371 TEST_F(CompositionTest, REComposedCursorLayer) {
1372 displayRefreshCompositionDirtyFrame<CompositionCase<
1373 DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1374 ChangeCompositionTypeVariant<
1375 aidl::android::hardware::graphics::composer3::Composition::CURSOR,
1376 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1377 RECompositionResultVariant>>();
1378 }
1379
TEST_F(CompositionTest,captureScreenCursorLayer)1380 TEST_F(CompositionTest, captureScreenCursorLayer) {
1381 captureScreenComposition<
1382 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1383 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1384 }
1385
1386 /* ------------------------------------------------------------------------
1387 * Simple buffer layer on a display which is powered off.
1388 */
1389
TEST_F(CompositionTest,displayOffHWCComposedNormalBufferLayerWithDirtyGeometry)1390 TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
1391 mDisplayOff = true;
1392 displayRefreshCompositionDirtyGeometry<CompositionCase<
1393 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1394 KeepCompositionTypeVariant<
1395 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1396 HwcCompositionResultVariant>>();
1397 }
1398
TEST_F(CompositionTest,displayOffHWCComposedNormalBufferLayerWithDirtyFrame)1399 TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
1400 mDisplayOff = true;
1401 displayRefreshCompositionDirtyFrame<CompositionCase<
1402 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1403 KeepCompositionTypeVariant<
1404 aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1405 HwcCompositionResultVariant>>();
1406 }
1407
TEST_F(CompositionTest,displayOffREComposedNormalBufferLayer)1408 TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
1409 mDisplayOff = true;
1410 displayRefreshCompositionDirtyFrame<CompositionCase<
1411 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1412 ChangeCompositionTypeVariant<
1413 aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1414 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1415 RECompositionResultVariant>>();
1416 }
1417
TEST_F(CompositionTest,captureScreenNormalBufferLayerOnPoweredOffDisplay)1418 TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1419 captureScreenComposition<CompositionCase<
1420 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1421 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1422 }
1423
1424 /* ------------------------------------------------------------------------
1425 * Client composition forced through debug/developer settings
1426 */
1427
TEST_F(CompositionTest,DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry)1428 TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
1429 displayRefreshCompositionDirtyGeometry<CompositionCase<
1430 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1431 KeepCompositionTypeVariant<
1432 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1433 ForcedClientCompositionViaDebugOptionResultVariant>>();
1434 }
1435
TEST_F(CompositionTest,DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame)1436 TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
1437 displayRefreshCompositionDirtyFrame<CompositionCase<
1438 DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1439 KeepCompositionTypeVariant<
1440 aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1441 ForcedClientCompositionViaDebugOptionResultVariant>>();
1442 }
1443
1444 } // namespace
1445 } // namespace android
1446
1447 // TODO(b/129481165): remove the #pragma below and fix conversion issues
1448 #pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
1449