xref: /aosp_15_r20/frameworks/native/services/surfaceflinger/tests/unittests/CompositionTest.cpp (revision 38e8c45f13ce32b0dcecb25141ffecaf386fa17f) 
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 "DisplayRenderArea.h"
40 #include "Layer.h"
41 #include "TestableSurfaceFlinger.h"
42 #include "mock/DisplayHardware/MockComposer.h"
43 #include "mock/MockEventThread.h"
44 #include "mock/MockTimeStats.h"
45 #include "mock/MockVsyncController.h"
46 #include "mock/PowerAdvisor/MockPowerAdvisor.h"
47 #include "mock/system/window/MockNativeWindow.h"
48 
49 namespace android {
50 namespace {
51 
52 namespace hal = android::hardware::graphics::composer::hal;
53 
54 using hal::Error;
55 using hal::IComposer;
56 using hal::IComposerClient;
57 using hal::PowerMode;
58 using hal::Transform;
59 
60 using aidl::android::hardware::graphics::composer3::Capability;
61 
62 using testing::_;
63 using testing::AtLeast;
64 using testing::DoAll;
65 using testing::IsNull;
66 using testing::Mock;
67 using testing::Return;
68 using testing::ReturnRef;
69 using testing::SetArgPointee;
70 
71 using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
72 using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;
73 using namespace ftl::flag_operators;
74 
75 constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DISPLAY_ID;
76 constexpr hal::HWLayerId HWC_LAYER = 5000;
77 constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0);
78 
79 constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(42u);
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 renderArea =
202             DisplayRenderArea::create(mDisplay, sourceCrop, sourceCrop.getSize(),
203                                       ui::Dataspace::V0_SRGB,
204                                       RenderArea::Options::CAPTURE_SECURE_LAYERS |
205                                               RenderArea::Options::HINT_FOR_SEAMLESS_TRANSITION);
206 
207     auto getLayerSnapshotsFn = mFlinger.getLayerSnapshotsForScreenshotsFn(mDisplay->getLayerStack(),
208                                                                           CaptureArgs::UNSET_UID);
209 
210     const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
211             GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
212     mCaptureScreenBuffer =
213             std::make_shared<renderengine::mock::FakeExternalTexture>(renderArea->getReqWidth(),
214                                                                       renderArea->getReqHeight(),
215                                                                       HAL_PIXEL_FORMAT_RGBA_8888, 1,
216                                                                       usage);
217 
218     auto future = mFlinger.renderScreenImpl(mDisplay, std::move(renderArea), getLayerSnapshotsFn,
219                                             mCaptureScreenBuffer, regionSampling);
220     ASSERT_TRUE(future.valid());
221     const auto fenceResult = future.get();
222 
223     EXPECT_EQ(NO_ERROR, fenceStatus(fenceResult));
224     if (fenceResult.ok()) {
225         fenceResult.value()->waitForever(LOG_TAG);
226     }
227 
228     LayerCase::cleanup(this);
229 }
230 
231 /* ------------------------------------------------------------------------
232  * Variants for each display configuration which can be tested
233  */
234 
235 template <typename Derived>
236 struct BaseDisplayVariant {
237     static constexpr bool IS_SECURE = true;
238     static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
239 
setupPreconditionsandroid::__anone39d41f60111::BaseDisplayVariant240     static void setupPreconditions(CompositionTest* test) {
241         EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
242                 .WillOnce(Return(Error::NONE));
243 
244         FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
245                 .setCapabilities(&test->mDefaultCapabilities)
246                 .setPowerMode(Derived::INIT_POWER_MODE)
247                 .inject(&test->mFlinger, test->mComposer);
248         Mock::VerifyAndClear(test->mComposer);
249 
250         EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
251                 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
252         EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
253                 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
254         EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
255         EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
256         EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
257 
258         const ::testing::TestInfo* const test_info =
259                 ::testing::UnitTest::GetInstance()->current_test_info();
260 
261         auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
262                                      .setId(DEFAULT_DISPLAY_ID)
263                                      .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
264                                      .setIsSecure(Derived::IS_SECURE)
265                                      .setPowerAdvisor(test->mPowerAdvisor)
266                                      .setName(std::string("Injected display for ") +
267                                               test_info->test_case_name() + "." + test_info->name())
268                                      .build();
269 
270         auto compositionDisplay =
271                 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
272                                                        ceDisplayArgs);
273 
274         constexpr auto kDisplayConnectionType = ui::DisplayConnectionType::Internal;
275         constexpr bool kIsPrimary = true;
276 
277         test->mDisplay =
278                 FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
279                                           kDisplayConnectionType, HWC_DISPLAY, kIsPrimary)
280                         .setDisplaySurface(test->mDisplaySurface)
281                         .setNativeWindow(test->mNativeWindow)
282                         .setSecure(Derived::IS_SECURE)
283                         .setPowerMode(Derived::INIT_POWER_MODE)
284                         .setRefreshRateSelector(test->mFlinger.scheduler()->refreshRateSelector())
285                         .skipSchedulerRegistration()
286                         .inject();
287         Mock::VerifyAndClear(test->mNativeWindow.get());
288 
289         constexpr bool kIsInternal = kDisplayConnectionType == ui::DisplayConnectionType::Internal;
290         test->mDisplay->setLayerFilter({LAYER_STACK, kIsInternal});
291     }
292 
293     template <typename Case>
setupPreconditionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant294     static void setupPreconditionCallExpectations(CompositionTest* test) {
295         EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))
296                 .WillOnce(DoAll(SetArgPointee<1>(
297                                         std::vector<aidl::android::hardware::graphics::composer3::
298                                                             DisplayCapability>({})),
299                                 Return(Error::NONE)));
300     }
301 
302     template <typename Case>
setupCommonCompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant303     static void setupCommonCompositionCallExpectations(CompositionTest* test) {
304         EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
305         EXPECT_CALL(*test->mComposer, getDisplayRequests(HWC_DISPLAY, _, _, _)).Times(1);
306         EXPECT_CALL(*test->mComposer, acceptDisplayChanges(HWC_DISPLAY)).Times(1);
307         EXPECT_CALL(*test->mComposer, presentDisplay(HWC_DISPLAY, _)).Times(1);
308         EXPECT_CALL(*test->mComposer, getReleaseFences(HWC_DISPLAY, _, _)).Times(1);
309 
310         EXPECT_CALL(*test->mDisplaySurface, onFrameCommitted()).Times(1);
311         EXPECT_CALL(*test->mDisplaySurface, advanceFrame(_)).Times(1);
312 
313         Case::CompositionType::setupHwcSetCallExpectations(test);
314         Case::CompositionType::setupHwcGetCallExpectations(test);
315     }
316 
317     template <typename Case>
setupCommonScreensCaptureCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant318     static void setupCommonScreensCaptureCallExpectations(CompositionTest* test) {
319         EXPECT_CALL(*test->mRenderEngine, drawLayers)
320                 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
321                                     const std::vector<renderengine::LayerSettings>&,
322                                     const std::shared_ptr<renderengine::ExternalTexture>&,
323                                     base::unique_fd&&) -> ftl::Future<FenceResult> {
324                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
325                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
326                               displaySettings.physicalDisplay);
327                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
328                               displaySettings.clip);
329                     return ftl::yield<FenceResult>(Fence::NO_FENCE);
330                 });
331     }
332 
setupNonEmptyFrameCompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant333     static void setupNonEmptyFrameCompositionCallExpectations(CompositionTest* test) {
334         EXPECT_CALL(*test->mDisplaySurface, beginFrame(true)).Times(1);
335     }
336 
setupEmptyFrameCompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant337     static void setupEmptyFrameCompositionCallExpectations(CompositionTest* test) {
338         EXPECT_CALL(*test->mDisplaySurface, beginFrame(false)).Times(1);
339     }
340 
setupHwcCompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant341     static void setupHwcCompositionCallExpectations(CompositionTest* test) {
342         EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _, _))
343                 .Times(1);
344 
345         EXPECT_CALL(*test->mDisplaySurface,
346                     prepareFrame(compositionengine::DisplaySurface::CompositionType::Hwc))
347                 .Times(1);
348     }
349 
setupHwcClientCompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant350     static void setupHwcClientCompositionCallExpectations(CompositionTest* test) {
351         EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _, _))
352                 .Times(1);
353     }
354 
setupHwcForcedClientCompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant355     static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
356         EXPECT_CALL(*test->mComposer, validateDisplay(HWC_DISPLAY, _, _, _, _)).Times(1);
357     }
358 
setupRECompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant359     static void setupRECompositionCallExpectations(CompositionTest* test) {
360         EXPECT_CALL(*test->mDisplaySurface,
361                     prepareFrame(compositionengine::DisplaySurface::CompositionType::Gpu))
362                 .Times(1);
363         EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
364                 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
365 
366         EXPECT_CALL(*test->mNativeWindow, queueBuffer(_, _)).WillOnce(Return(0));
367         EXPECT_CALL(*test->mNativeWindow, dequeueBuffer(_, _))
368                 .WillOnce(DoAll(SetArgPointee<0>(test->mNativeWindowBuffer), SetArgPointee<1>(-1),
369                                 Return(0)));
370         EXPECT_CALL(*test->mRenderEngine, drawLayers)
371                 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
372                                     const std::vector<renderengine::LayerSettings>&,
373                                     const std::shared_ptr<renderengine::ExternalTexture>&,
374                                     base::unique_fd&&) -> ftl::Future<FenceResult> {
375                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
376                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
377                               displaySettings.physicalDisplay);
378                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
379                               displaySettings.clip);
380                     EXPECT_EQ(ui::Dataspace::UNKNOWN, displaySettings.outputDataspace);
381                     return ftl::yield<FenceResult>(Fence::NO_FENCE);
382                 });
383     }
384 
385     template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant386     static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
387         Case::Layer::setupRECompositionCallExpectations(test);
388     }
389 
390     template <typename Case>
setupRELayerScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::BaseDisplayVariant391     static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
392         Case::Layer::setupREScreenshotCompositionCallExpectations(test);
393     }
394 };
395 
396 struct DefaultDisplaySetupVariant : public BaseDisplayVariant<DefaultDisplaySetupVariant> {};
397 
398 struct InsecureDisplaySetupVariant : public BaseDisplayVariant<InsecureDisplaySetupVariant> {
399     static constexpr bool IS_SECURE = false;
400 
401     template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anone39d41f60111::InsecureDisplaySetupVariant402     static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
403         Case::Layer::setupInsecureRECompositionCallExpectations(test);
404     }
405 
406     template <typename Case>
setupRELayerScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::InsecureDisplaySetupVariant407     static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
408         Case::Layer::setupInsecureREScreenshotCompositionCallExpectations(test);
409     }
410 };
411 
412 struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDisplaySetupVariant> {
413     static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::OFF;
414 
415     template <typename Case>
setupPreconditionCallExpectationsandroid::__anone39d41f60111::PoweredOffDisplaySetupVariant416     static void setupPreconditionCallExpectations(CompositionTest*) {}
417 
418     template <typename Case>
setupCommonCompositionCallExpectationsandroid::__anone39d41f60111::PoweredOffDisplaySetupVariant419     static void setupCommonCompositionCallExpectations(CompositionTest* test) {
420         // TODO: This seems like an unnecessary call if display is powered off.
421         EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
422 
423         // TODO: This seems like an unnecessary call if display is powered off.
424         Case::CompositionType::setupHwcSetCallExpectations(test);
425     }
426 
setupHwcCompositionCallExpectationsandroid::__anone39d41f60111::PoweredOffDisplaySetupVariant427     static void setupHwcCompositionCallExpectations(CompositionTest*) {}
setupHwcClientCompositionCallExpectationsandroid::__anone39d41f60111::PoweredOffDisplaySetupVariant428     static void setupHwcClientCompositionCallExpectations(CompositionTest*) {}
setupHwcForcedClientCompositionCallExpectationsandroid::__anone39d41f60111::PoweredOffDisplaySetupVariant429     static void setupHwcForcedClientCompositionCallExpectations(CompositionTest*) {}
430 
setupRECompositionCallExpectationsandroid::__anone39d41f60111::PoweredOffDisplaySetupVariant431     static void setupRECompositionCallExpectations(CompositionTest* test) {
432         // TODO: This seems like an unnecessary call if display is powered off.
433         EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
434                 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
435     }
436 
437     template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anone39d41f60111::PoweredOffDisplaySetupVariant438     static void setupRELayerCompositionCallExpectations(CompositionTest*) {}
439 };
440 
441 /* ------------------------------------------------------------------------
442  * Variants for each layer configuration which can be tested
443  */
444 
445 template <typename LayerProperties>
446 struct BaseLayerProperties {
447     static constexpr uint32_t WIDTH = 100;
448     static constexpr uint32_t HEIGHT = 100;
449     static constexpr PixelFormat FORMAT = PIXEL_FORMAT_RGBA_8888;
450     static constexpr uint64_t USAGE =
451             GraphicBuffer::USAGE_SW_READ_NEVER | GraphicBuffer::USAGE_SW_WRITE_NEVER;
452     static constexpr android_dataspace DATASPACE = HAL_DATASPACE_UNKNOWN;
453     static constexpr uint32_t SCALING_MODE = 0;
454     static constexpr uint32_t TRANSFORM = 0;
455     static constexpr uint32_t LAYER_FLAGS = 0;
456     static constexpr float COLOR[] = {1.f, 1.f, 1.f, 1.f};
457     static constexpr IComposerClient::BlendMode BLENDMODE =
458             IComposerClient::BlendMode::PREMULTIPLIED;
459 
setupLatchedBufferandroid::__anone39d41f60111::BaseLayerProperties460     static void setupLatchedBuffer(CompositionTest* test, frontend::RequestedLayerState& layer) {
461         Mock::VerifyAndClear(test->mRenderEngine);
462 
463         const auto buffer = std::make_shared<
464                 renderengine::mock::FakeExternalTexture>(LayerProperties::WIDTH,
465                                                          LayerProperties::HEIGHT,
466                                                          DEFAULT_TEXTURE_ID,
467                                                          LayerProperties::FORMAT,
468                                                          LayerProperties::USAGE |
469                                                                  GraphicBuffer::USAGE_HW_TEXTURE);
470         layer.crop = FloatRect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
471         layer.externalTexture = buffer;
472         layer.bufferData->acquireFence = Fence::NO_FENCE;
473         layer.dataspace = ui::Dataspace::UNKNOWN;
474         layer.surfaceDamageRegion = Region(Rect(LayerProperties::HEIGHT, LayerProperties::WIDTH));
475         Mock::VerifyAndClear(test->mRenderEngine);
476     }
477 
setupLayerStateandroid::__anone39d41f60111::BaseLayerProperties478     static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState& layer) {
479         setupLatchedBuffer(test, layer);
480     }
481 
setupHwcSetGeometryCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties482     static void setupHwcSetGeometryCallExpectations(CompositionTest* test) {
483         if (!test->mDisplayOff) {
484             // TODO: Coverage of other values
485             EXPECT_CALL(*test->mComposer,
486                         setLayerBlendMode(HWC_DISPLAY, HWC_LAYER, LayerProperties::BLENDMODE))
487                     .Times(1);
488             // TODO: Coverage of other values for origin
489             EXPECT_CALL(*test->mComposer,
490                         setLayerDisplayFrame(HWC_DISPLAY, HWC_LAYER,
491                                              IComposerClient::Rect({0, 0, LayerProperties::WIDTH,
492                                                                     LayerProperties::HEIGHT})))
493                     .Times(1);
494             EXPECT_CALL(*test->mComposer,
495                         setLayerPlaneAlpha(HWC_DISPLAY, HWC_LAYER, LayerProperties::COLOR[3]))
496                     .Times(1);
497             // TODO: Coverage of other values
498             EXPECT_CALL(*test->mComposer, setLayerZOrder(HWC_DISPLAY, HWC_LAYER, 0u)).Times(1);
499 
500             // These expectations retire on saturation as the code path these
501             // expectations are for appears to make an extra call to them.
502             // TODO: Investigate this extra call
503             EXPECT_CALL(*test->mComposer,
504                         setLayerTransform(HWC_DISPLAY, HWC_LAYER, DEFAULT_TRANSFORM))
505                     .Times(AtLeast(1))
506                     .RetiresOnSaturation();
507         }
508     }
509 
setupHwcSetSourceCropBufferCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties510     static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
511         if (!test->mDisplayOff) {
512             EXPECT_CALL(*test->mComposer,
513                         setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
514                                            IComposerClient::FRect({0.f, 0.f, LayerProperties::WIDTH,
515                                                                    LayerProperties::HEIGHT})))
516                     .Times(1);
517         }
518     }
519 
setupHwcSetSourceCropColorCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties520     static void setupHwcSetSourceCropColorCallExpectations(CompositionTest* test) {
521         if (!test->mDisplayOff) {
522             EXPECT_CALL(*test->mComposer,
523                         setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
524                                            IComposerClient::FRect({0.f, 0.f, 0.f, 0.f})))
525                     .Times(1);
526         }
527     }
528 
setupHwcSetPerFrameCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties529     static void setupHwcSetPerFrameCallExpectations(CompositionTest* test) {
530         if (!test->mDisplayOff) {
531             EXPECT_CALL(*test->mComposer,
532                         setLayerVisibleRegion(HWC_DISPLAY, HWC_LAYER,
533                                               std::vector<IComposerClient::Rect>(
534                                                       {IComposerClient::Rect(
535                                                               {0, 0, LayerProperties::WIDTH,
536                                                                LayerProperties::HEIGHT})})))
537                     .Times(1);
538         }
539     }
540 
setupHwcSetPerFrameColorCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties541     static void setupHwcSetPerFrameColorCallExpectations(CompositionTest* test) {
542         if (!test->mDisplayOff) {
543             EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
544                     .Times(1);
545 
546             // TODO: use COLOR
547             EXPECT_CALL(*test->mComposer,
548                         setLayerColor(HWC_DISPLAY, HWC_LAYER,
549                                       aidl::android::hardware::graphics::composer3::Color(
550                                               {1.0f, 1.0f, 1.0f, 1.0f})))
551                     .Times(1);
552         }
553     }
554 
setupHwcSetPerFrameBufferCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties555     static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
556         if (!test->mDisplayOff) {
557             EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
558                     .Times(1);
559             EXPECT_CALL(*test->mComposer, setLayerBuffer(HWC_DISPLAY, HWC_LAYER, _, _, _)).Times(1);
560         }
561     }
562 
setupREBufferCompositionCommonCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties563     static void setupREBufferCompositionCommonCallExpectations(CompositionTest* test) {
564         EXPECT_CALL(*test->mRenderEngine, drawLayers)
565                 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
566                               const std::vector<renderengine::LayerSettings>& layerSettings,
567                               const std::shared_ptr<renderengine::ExternalTexture>&,
568                               base::unique_fd&&) -> ftl::Future<FenceResult> {
569                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
570                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
571                               displaySettings.physicalDisplay);
572                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
573                               displaySettings.clip);
574                     // screen capture adds an additional color layer as an alpha
575                     // prefill, so gtet the back layer.
576                     ftl::Future<FenceResult> resultFuture =
577                             ftl::yield<FenceResult>(Fence::NO_FENCE);
578                     if (layerSettings.empty()) {
579                         ADD_FAILURE() << "layerSettings was not expected to be empty in "
580                                          "setupREBufferCompositionCommonCallExpectations "
581                                          "verification lambda";
582                         return resultFuture;
583                     }
584                     const renderengine::LayerSettings layer = layerSettings.back();
585                     EXPECT_THAT(layer.source.buffer.buffer, Not(IsNull()));
586                     EXPECT_THAT(layer.source.buffer.fence, Not(IsNull()));
587                     EXPECT_EQ(true, layer.source.buffer.usePremultipliedAlpha);
588                     EXPECT_EQ(false, layer.source.buffer.isOpaque);
589                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
590                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
591                     EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
592                     EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
593                     return resultFuture;
594                 });
595     }
596 
setupREBufferCompositionCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties597     static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
598         LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
599     }
600 
setupInsecureREBufferCompositionCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties601     static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
602         setupREBufferCompositionCallExpectations(test);
603     }
604 
setupREBufferScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties605     static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
606         LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
607     }
608 
setupInsecureREBufferScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties609     static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
610         LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
611     }
612 
setupREColorCompositionCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties613     static void setupREColorCompositionCallExpectations(CompositionTest* test) {
614         EXPECT_CALL(*test->mRenderEngine, drawLayers)
615                 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
616                               const std::vector<renderengine::LayerSettings>& layerSettings,
617                               const std::shared_ptr<renderengine::ExternalTexture>&,
618                               base::unique_fd&&) -> ftl::Future<FenceResult> {
619                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
620                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
621                               displaySettings.physicalDisplay);
622                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
623                               displaySettings.clip);
624                     // screen capture adds an additional color layer as an alpha
625                     // prefill, so get the back layer.
626                     ftl::Future<FenceResult> resultFuture =
627                             ftl::yield<FenceResult>(Fence::NO_FENCE);
628                     if (layerSettings.empty()) {
629                         ADD_FAILURE()
630                                 << "layerSettings was not expected to be empty in "
631                                    "setupREColorCompositionCallExpectations verification lambda";
632                         return resultFuture;
633                     }
634                     const renderengine::LayerSettings layer = layerSettings.back();
635                     EXPECT_THAT(layer.source.buffer.buffer, IsNull());
636                     EXPECT_EQ(half3(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
637                                     LayerProperties::COLOR[2]),
638                               layer.source.solidColor);
639                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
640                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
641                     EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
642                     EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
643                     return resultFuture;
644                 });
645     }
646 
setupREColorScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::BaseLayerProperties647     static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
648         setupREColorCompositionCallExpectations(test);
649     }
650 };
651 
652 struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
653 
654 struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
655     static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
656 };
657 
658 struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
659     using Base = BaseLayerProperties<SidebandLayerProperties>;
660     static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
661 
setupLayerStateandroid::__anone39d41f60111::SidebandLayerProperties662     static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState& layer) {
663         sp<NativeHandle> stream =
664                 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
665                                      false);
666         layer.sidebandStream = stream;
667         layer.crop =
668                 FloatRect(0, 0, SidebandLayerProperties::HEIGHT, SidebandLayerProperties::WIDTH);
669     }
670 
setupHwcSetSourceCropBufferCallExpectationsandroid::__anone39d41f60111::SidebandLayerProperties671     static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
672         EXPECT_CALL(*test->mComposer,
673                     setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
674                                        IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
675                 .Times(1);
676     }
677 
setupHwcSetPerFrameBufferCallExpectationsandroid::__anone39d41f60111::SidebandLayerProperties678     static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
679         EXPECT_CALL(*test->mComposer,
680                     setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
681                                            reinterpret_cast<native_handle_t*>(
682                                                    DEFAULT_SIDEBAND_STREAM)))
683                 .WillOnce(Return(Error::NONE));
684 
685         EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
686     }
687 
setupREBufferCompositionCommonCallExpectationsandroid::__anone39d41f60111::SidebandLayerProperties688     static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
689 };
690 
691 template <typename LayerProperties>
692 struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
693     using Base = BaseLayerProperties<LayerProperties>;
694 
setupInsecureREBufferCompositionCommonCallExpectationsandroid::__anone39d41f60111::CommonSecureLayerProperties695     static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
696         EXPECT_CALL(*test->mRenderEngine, drawLayers)
697                 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
698                               const std::vector<renderengine::LayerSettings>& layerSettings,
699                               const std::shared_ptr<renderengine::ExternalTexture>&,
700                               base::unique_fd&&) -> ftl::Future<FenceResult> {
701                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
702                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
703                               displaySettings.physicalDisplay);
704                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
705                               displaySettings.clip);
706                     // screen capture adds an additional color layer as an alpha
707                     // prefill, so get the back layer.
708                     ftl::Future<FenceResult> resultFuture =
709                             ftl::yield<FenceResult>(Fence::NO_FENCE);
710                     if (layerSettings.empty()) {
711                         ADD_FAILURE() << "layerSettings was not expected to be empty in "
712                                          "setupInsecureREBufferCompositionCommonCallExpectations "
713                                          "verification lambda";
714                         return resultFuture;
715                     }
716                     const renderengine::LayerSettings layer = layerSettings.back();
717                     EXPECT_THAT(layer.source.buffer.buffer, IsNull());
718                     EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer.source.solidColor);
719                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
720                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
721                     EXPECT_EQ(ui::Dataspace::V0_SRGB, layer.sourceDataspace);
722                     EXPECT_EQ(1.0f, layer.alpha);
723                     return resultFuture;
724                 });
725     }
726 
setupInsecureREBufferCompositionCallExpectationsandroid::__anone39d41f60111::CommonSecureLayerProperties727     static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
728         setupInsecureREBufferCompositionCommonCallExpectations(test);
729     }
730 
setupInsecureREBufferScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::CommonSecureLayerProperties731     static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
732         setupInsecureREBufferCompositionCommonCallExpectations(test);
733     }
734 };
735 
736 struct ParentSecureLayerProperties
737       : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
738 
739 struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
740     static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
741 };
742 
743 struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
744     using Base = BaseLayerProperties<CursorLayerProperties>;
745 
setupLayerStateandroid::__anone39d41f60111::CursorLayerProperties746     static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState& layer) {
747         Base::setupLayerState(test, layer);
748         layer.potentialCursor = true;
749     }
750 };
751 
752 struct NoLayerVariant {
createLayerandroid::__anone39d41f60111::NoLayerVariant753     static frontend::RequestedLayerState createLayer(CompositionTest*) {
754         return {LayerCreationArgs()};
755     }
injectLayerandroid::__anone39d41f60111::NoLayerVariant756     static void injectLayer(CompositionTest*, frontend::RequestedLayerState&) {}
cleanupInjectedLayersandroid::__anone39d41f60111::NoLayerVariant757     static void cleanupInjectedLayers(CompositionTest*) {}
758 
setupCallExpectationsForDirtyGeometryandroid::__anone39d41f60111::NoLayerVariant759     static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
setupCallExpectationsForDirtyFrameandroid::__anone39d41f60111::NoLayerVariant760     static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
761 };
762 
763 template <typename LayerProperties>
764 struct BaseLayerVariant {
765     template <typename L, typename F>
createLayerWithFactoryandroid::__anone39d41f60111::BaseLayerVariant766     static frontend::RequestedLayerState createLayerWithFactory(CompositionTest* test, F factory) {
767         EXPECT_CALL(*test->mFlinger.scheduler(), postMessage(_)).Times(0);
768 
769         auto layer = factory();
770 
771         // Layer should be registered with scheduler.
772         EXPECT_EQ(1u, test->mFlinger.scheduler()->layerHistorySize());
773 
774         Mock::VerifyAndClear(test->mComposer);
775         Mock::VerifyAndClear(test->mRenderEngine);
776         Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
777 
778         initLayerDrawingStateAndComputeBounds(test, layer);
779 
780         return layer;
781     }
782 
initLayerDrawingStateAndComputeBoundsandroid::__anone39d41f60111::BaseLayerVariant783     static void initLayerDrawingStateAndComputeBounds(CompositionTest* test,
784                                                       frontend::RequestedLayerState& layer) {
785         layer.layerStack = LAYER_STACK;
786         layer.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
787                             LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
788     }
789 
injectLayerandroid::__anone39d41f60111::BaseLayerVariant790     static void injectLayer(CompositionTest* test, frontend::RequestedLayerState& layer) {
791         EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
792                 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
793         auto legacyLayer = test->mFlinger.getLegacyLayer(layer.id);
794         auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
795                 legacyLayer->getCompositionEngineLayerFE({.id = layer.id}));
796         outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
797         outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
798 
799         Mock::VerifyAndClear(test->mComposer);
800 
801         auto layerCopy = std::make_unique<frontend::RequestedLayerState>(layer);
802         test->mFlinger.addLayer(layerCopy);
803         test->mFlinger.mutableVisibleRegionsDirty() = true;
804     }
805 
cleanupInjectedLayersandroid::__anone39d41f60111::BaseLayerVariant806     static void cleanupInjectedLayers(CompositionTest* test) {
807         EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
808                 .WillOnce(Return(Error::NONE));
809 
810         test->mFlinger.destroyAllLayerHandles();
811         test->mDisplay->getCompositionDisplay()->clearOutputLayers();
812         test->mFlinger.mutablePreviouslyComposedLayers().clear();
813         // Layer should be unregistered with scheduler.
814         test->mFlinger.commit();
815         EXPECT_EQ(0u, test->mFlinger.scheduler()->layerHistorySize());
816     }
817 };
818 
819 template <typename LayerProperties>
820 struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
821     using Base = BaseLayerVariant<LayerProperties>;
createLayerandroid::__anone39d41f60111::EffectLayerVariant822     static frontend::RequestedLayerState createLayer(CompositionTest* test) {
823         frontend::RequestedLayerState layer = Base::template createLayerWithFactory<
824                 frontend::RequestedLayerState>(test, [test]() {
825             auto args = LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(), "test-layer",
826                                           LayerProperties::LAYER_FLAGS, LayerMetadata());
827             auto legacyLayer = sp<Layer>::make(args);
828             test->mFlinger.injectLegacyLayer(legacyLayer);
829             return frontend::RequestedLayerState(args);
830         });
831 
832         layer.crop = FloatRect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
833         return layer;
834     }
835 
setupRECompositionCallExpectationsandroid::__anone39d41f60111::EffectLayerVariant836     static void setupRECompositionCallExpectations(CompositionTest* test) {
837         LayerProperties::setupREColorCompositionCallExpectations(test);
838     }
839 
setupREScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::EffectLayerVariant840     static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
841         LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
842     }
843 
setupCallExpectationsForDirtyGeometryandroid::__anone39d41f60111::EffectLayerVariant844     static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
845         LayerProperties::setupHwcSetGeometryCallExpectations(test);
846         LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
847     }
848 
setupCallExpectationsForDirtyFrameandroid::__anone39d41f60111::EffectLayerVariant849     static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
850         LayerProperties::setupHwcSetPerFrameCallExpectations(test);
851         LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
852     }
853 };
854 
855 template <typename LayerProperties>
856 struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
857     using Base = BaseLayerVariant<LayerProperties>;
858 
createLayerandroid::__anone39d41f60111::BufferLayerVariant859     static frontend::RequestedLayerState createLayer(CompositionTest* test) {
860         frontend::RequestedLayerState layer = Base::template createLayerWithFactory<
861                 frontend::RequestedLayerState>(test, [test]() {
862             LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
863                                    LayerProperties::LAYER_FLAGS, LayerMetadata());
864             auto legacyLayer = sp<Layer>::make(args);
865             test->mFlinger.injectLegacyLayer(legacyLayer);
866             return frontend::RequestedLayerState(args);
867         });
868 
869         LayerProperties::setupLayerState(test, layer);
870 
871         return layer;
872     }
873 
cleanupInjectedLayersandroid::__anone39d41f60111::BufferLayerVariant874     static void cleanupInjectedLayers(CompositionTest* test) {
875         Base::cleanupInjectedLayers(test);
876     }
877 
setupCallExpectationsForDirtyGeometryandroid::__anone39d41f60111::BufferLayerVariant878     static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
879         LayerProperties::setupHwcSetGeometryCallExpectations(test);
880         LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
881     }
882 
setupCallExpectationsForDirtyFrameandroid::__anone39d41f60111::BufferLayerVariant883     static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
884         LayerProperties::setupHwcSetPerFrameCallExpectations(test);
885         LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
886     }
887 
setupRECompositionCallExpectationsandroid::__anone39d41f60111::BufferLayerVariant888     static void setupRECompositionCallExpectations(CompositionTest* test) {
889         LayerProperties::setupREBufferCompositionCallExpectations(test);
890     }
891 
setupInsecureRECompositionCallExpectationsandroid::__anone39d41f60111::BufferLayerVariant892     static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
893         LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
894     }
895 
setupREScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::BufferLayerVariant896     static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
897         LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
898     }
899 
setupInsecureREScreenshotCompositionCallExpectationsandroid::__anone39d41f60111::BufferLayerVariant900     static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
901         LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
902     }
903 };
904 
905 template <typename LayerProperties>
906 struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
907     using Base = BaseLayerVariant<LayerProperties>;
908 
createLayerandroid::__anone39d41f60111::ContainerLayerVariant909     static frontend::RequestedLayerState createLayer(CompositionTest* test) {
910         LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
911                                LayerProperties::LAYER_FLAGS, LayerMetadata());
912         sp<Layer> legacyLayer = sp<Layer>::make(args);
913         test->mFlinger.injectLegacyLayer(legacyLayer);
914         frontend::RequestedLayerState layer(args);
915         Base::initLayerDrawingStateAndComputeBounds(test, layer);
916         return layer;
917     }
918 };
919 
920 template <typename LayerVariant, typename ParentLayerVariant>
921 struct ChildLayerVariant : public LayerVariant {
922     using Base = LayerVariant;
923     using ParentBase = ParentLayerVariant;
924 
createLayerandroid::__anone39d41f60111::ChildLayerVariant925     static frontend::RequestedLayerState createLayer(CompositionTest* test) {
926         // Need to create child layer first. Otherwise layer history size will be 2.
927         frontend::RequestedLayerState layer = Base::createLayer(test);
928         frontend::RequestedLayerState parentLayer = ParentBase::createLayer(test);
929         layer.parentId = parentLayer.id;
930         auto layerCopy = std::make_unique<frontend::RequestedLayerState>(parentLayer);
931         test->mFlinger.addLayer(layerCopy);
932         return layer;
933     }
934 
cleanupInjectedLayersandroid::__anone39d41f60111::ChildLayerVariant935     static void cleanupInjectedLayers(CompositionTest* test) { Base::cleanupInjectedLayers(test); }
936 };
937 
938 /* ------------------------------------------------------------------------
939  * Variants to control how the composition type is changed
940  */
941 
942 struct NoCompositionTypeVariant {
setupHwcSetCallExpectationsandroid::__anone39d41f60111::NoCompositionTypeVariant943     static void setupHwcSetCallExpectations(CompositionTest*) {}
944 
setupHwcGetCallExpectationsandroid::__anone39d41f60111::NoCompositionTypeVariant945     static void setupHwcGetCallExpectations(CompositionTest* test) {
946         EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
947     }
948 };
949 
950 template <aidl::android::hardware::graphics::composer3::Composition CompositionType>
951 struct KeepCompositionTypeVariant {
952     static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
953             CompositionType;
954 
setupHwcSetCallExpectationsandroid::__anone39d41f60111::KeepCompositionTypeVariant955     static void setupHwcSetCallExpectations(CompositionTest* test) {
956         if (!test->mDisplayOff) {
957             EXPECT_CALL(*test->mComposer,
958                         setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
959                     .Times(1);
960         }
961     }
962 
setupHwcGetCallExpectationsandroid::__anone39d41f60111::KeepCompositionTypeVariant963     static void setupHwcGetCallExpectations(CompositionTest* test) {
964         EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
965     }
966 };
967 
968 template <aidl::android::hardware::graphics::composer3::Composition InitialCompositionType,
969           aidl::android::hardware::graphics::composer3::Composition FinalCompositionType>
970 struct ChangeCompositionTypeVariant {
971     static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
972             FinalCompositionType;
973 
setupHwcSetCallExpectationsandroid::__anone39d41f60111::ChangeCompositionTypeVariant974     static void setupHwcSetCallExpectations(CompositionTest* test) {
975         if (!test->mDisplayOff) {
976             EXPECT_CALL(*test->mComposer,
977                         setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
978                     .Times(1);
979         }
980     }
981 
setupHwcGetCallExpectationsandroid::__anone39d41f60111::ChangeCompositionTypeVariant982     static void setupHwcGetCallExpectations(CompositionTest* test) {
983         EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
984                 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
985                                         static_cast<Hwc2::Layer>(HWC_LAYER)}),
986                                 SetArgPointee<2>(
987                                         std::vector<aidl::android::hardware::graphics::composer3::
988                                                             Composition>{FinalCompositionType}),
989                                 Return(Error::NONE)));
990     }
991 };
992 
993 /* ------------------------------------------------------------------------
994  * Variants to select how the composition is expected to be handled
995  */
996 
997 struct CompositionResultBaseVariant {
setupLayerStateandroid::__anone39d41f60111::CompositionResultBaseVariant998     static void setupLayerState(CompositionTest*, frontend::RequestedLayerState&) {}
999 
1000     template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anone39d41f60111::CompositionResultBaseVariant1001     static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
1002         Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1003     }
1004 
1005     template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anone39d41f60111::CompositionResultBaseVariant1006     static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1007         Case::Layer::setupCallExpectationsForDirtyFrame(test);
1008     }
1009 };
1010 
1011 struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1012     template <typename Case>
setupCallExpectationsandroid::__anone39d41f60111::NoCompositionResultVariant1013     static void setupCallExpectations(CompositionTest* test) {
1014         Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1015         Case::Display::setupHwcCompositionCallExpectations(test);
1016     }
1017 };
1018 
1019 struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1020     template <typename Case>
setupCallExpectationsandroid::__anone39d41f60111::HwcCompositionResultVariant1021     static void setupCallExpectations(CompositionTest* test) {
1022         Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1023         Case::Display::setupHwcCompositionCallExpectations(test);
1024     }
1025 };
1026 
1027 struct RECompositionResultVariant : public CompositionResultBaseVariant {
1028     template <typename Case>
setupCallExpectationsandroid::__anone39d41f60111::RECompositionResultVariant1029     static void setupCallExpectations(CompositionTest* test) {
1030         Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1031         Case::Display::setupHwcClientCompositionCallExpectations(test);
1032         Case::Display::setupRECompositionCallExpectations(test);
1033         Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1034     }
1035 };
1036 
1037 struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
setupLayerStateandroid::__anone39d41f60111::ForcedClientCompositionResultVariant1038     static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState& layer) {
1039         const auto outputLayer = test->mFlinger.findOutputLayerForDisplay(layer.id, test->mDisplay);
1040         LOG_FATAL_IF(!outputLayer);
1041         outputLayer->editState().forceClientComposition = true;
1042     }
1043 
1044     template <typename Case>
setupCallExpectationsandroid::__anone39d41f60111::ForcedClientCompositionResultVariant1045     static void setupCallExpectations(CompositionTest* test) {
1046         Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1047         Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1048         Case::Display::setupRECompositionCallExpectations(test);
1049         Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1050     }
1051 
1052     template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anone39d41f60111::ForcedClientCompositionResultVariant1053     static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1054 
1055     template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anone39d41f60111::ForcedClientCompositionResultVariant1056     static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1057 };
1058 
1059 struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
setupLayerStateandroid::__anone39d41f60111::ForcedClientCompositionViaDebugOptionResultVariant1060     static void setupLayerState(CompositionTest* test, frontend::RequestedLayerState&) {
1061         test->mFlinger.mutableDebugDisableHWC() = true;
1062     }
1063 
1064     template <typename Case>
setupCallExpectationsandroid::__anone39d41f60111::ForcedClientCompositionViaDebugOptionResultVariant1065     static void setupCallExpectations(CompositionTest* test) {
1066         Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1067         Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1068         Case::Display::setupRECompositionCallExpectations(test);
1069         Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1070     }
1071 
1072     template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anone39d41f60111::ForcedClientCompositionViaDebugOptionResultVariant1073     static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1074 
1075     template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anone39d41f60111::ForcedClientCompositionViaDebugOptionResultVariant1076     static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1077 };
1078 
1079 struct EmptyScreenshotResultVariant {
setupLayerStateandroid::__anone39d41f60111::EmptyScreenshotResultVariant1080     static void setupLayerState(CompositionTest*, frontend::RequestedLayerState&) {}
1081 
1082     template <typename Case>
setupCallExpectationsandroid::__anone39d41f60111::EmptyScreenshotResultVariant1083     static void setupCallExpectations(CompositionTest*) {}
1084 };
1085 
1086 struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1087     using Base = EmptyScreenshotResultVariant;
1088 
1089     template <typename Case>
setupCallExpectationsandroid::__anone39d41f60111::REScreenshotResultVariant1090     static void setupCallExpectations(CompositionTest* test) {
1091         Base::template setupCallExpectations<Case>(test);
1092         Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1093     }
1094 };
1095 
1096 /* ------------------------------------------------------------------------
1097  * Composition test case, containing all the variants being tested
1098  */
1099 
1100 template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1101           typename CompositionResultCase>
1102 struct CompositionCase {
1103     using ThisCase =
1104             CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1105     using Display = DisplayCase;
1106     using Layer = LayerCase;
1107     using CompositionType = CompositionTypeCase;
1108     using CompositionResult = CompositionResultCase;
1109 
setupCommonandroid::__anone39d41f60111::CompositionCase1110     static void setupCommon(CompositionTest* test) {
1111         Display::template setupPreconditionCallExpectations<ThisCase>(test);
1112         Display::setupPreconditions(test);
1113 
1114         auto layer = Layer::createLayer(test);
1115         Layer::injectLayer(test, layer);
1116         CompositionResult::setupLayerState(test, layer);
1117     }
1118 
setupForDirtyGeometryandroid::__anone39d41f60111::CompositionCase1119     static void setupForDirtyGeometry(CompositionTest* test) {
1120         setupCommon(test);
1121 
1122         Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1123         CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1124         CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1125         CompositionResult::template setupCallExpectations<ThisCase>(test);
1126     }
1127 
setupForDirtyFrameandroid::__anone39d41f60111::CompositionCase1128     static void setupForDirtyFrame(CompositionTest* test) {
1129         setupCommon(test);
1130 
1131         Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1132         CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1133         CompositionResult::template setupCallExpectations<ThisCase>(test);
1134     }
1135 
setupForScreenCaptureandroid::__anone39d41f60111::CompositionCase1136     static void setupForScreenCapture(CompositionTest* test) {
1137         setupCommon(test);
1138 
1139         Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1140         CompositionResult::template setupCallExpectations<ThisCase>(test);
1141     }
1142 
cleanupandroid::__anone39d41f60111::CompositionCase1143     static void cleanup(CompositionTest* test) {
1144         Layer::cleanupInjectedLayers(test);
1145 
1146         for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1147             static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1148                     ->mutableLayers()
1149                     .clear();
1150         }
1151     }
1152 };
1153 
1154 /* ------------------------------------------------------------------------
1155  * Composition cases to test
1156  */
1157 
TEST_F(CompositionTest,noLayersDoesMinimalWorkWithDirtyGeometry)1158 TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1159     displayRefreshCompositionDirtyGeometry<
1160             CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1161                             NoCompositionResultVariant>>();
1162 }
1163 
TEST_F(CompositionTest,noLayersDoesMinimalWorkWithDirtyFrame)1164 TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1165     displayRefreshCompositionDirtyFrame<
1166             CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1167                             NoCompositionResultVariant>>();
1168 }
1169 
TEST_F(CompositionTest,noLayersDoesMinimalWorkToCaptureScreen)1170 TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1171     captureScreenComposition<
1172             CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1173                             EmptyScreenshotResultVariant>>();
1174 }
1175 
1176 /* ------------------------------------------------------------------------
1177  *  Simple buffer layers
1178  */
1179 
TEST_F(CompositionTest,HWCComposedNormalBufferLayerWithDirtyGeometry)1180 TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
1181     displayRefreshCompositionDirtyGeometry<CompositionCase<
1182             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1183             KeepCompositionTypeVariant<
1184                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1185             HwcCompositionResultVariant>>();
1186 }
1187 
TEST_F(CompositionTest,HWCComposedNormalBufferLayerWithDirtyFrame)1188 TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
1189     displayRefreshCompositionDirtyFrame<CompositionCase<
1190             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1191             KeepCompositionTypeVariant<
1192                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1193             HwcCompositionResultVariant>>();
1194 }
1195 
TEST_F(CompositionTest,REComposedNormalBufferLayer)1196 TEST_F(CompositionTest, REComposedNormalBufferLayer) {
1197     displayRefreshCompositionDirtyFrame<CompositionCase<
1198             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1199             ChangeCompositionTypeVariant<
1200                     aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1201                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1202             RECompositionResultVariant>>();
1203 }
1204 
TEST_F(CompositionTest,captureScreenNormalBufferLayer)1205 TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1206     captureScreenComposition<
1207             CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1208                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1209 }
1210 
1211 /* ------------------------------------------------------------------------
1212  *  Single-color layers
1213  */
1214 
TEST_F(CompositionTest,HWCComposedEffectLayerWithDirtyGeometry)1215 TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
1216     displayRefreshCompositionDirtyGeometry<CompositionCase<
1217             DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1218             KeepCompositionTypeVariant<
1219                     aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1220             HwcCompositionResultVariant>>();
1221 }
1222 
TEST_F(CompositionTest,HWCComposedEffectLayerWithDirtyFrame)1223 TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
1224     displayRefreshCompositionDirtyFrame<CompositionCase<
1225             DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1226             KeepCompositionTypeVariant<
1227                     aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1228             HwcCompositionResultVariant>>();
1229 }
1230 
TEST_F(CompositionTest,REComposedEffectLayer)1231 TEST_F(CompositionTest, REComposedEffectLayer) {
1232     displayRefreshCompositionDirtyFrame<CompositionCase<
1233             DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1234             ChangeCompositionTypeVariant<
1235                     aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR,
1236                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1237             RECompositionResultVariant>>();
1238 }
1239 
TEST_F(CompositionTest,captureScreenEffectLayer)1240 TEST_F(CompositionTest, captureScreenEffectLayer) {
1241     captureScreenComposition<
1242             CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1243                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1244 }
1245 
1246 /* ------------------------------------------------------------------------
1247  *  Layers with sideband buffers
1248  */
1249 
TEST_F(CompositionTest,HWCComposedSidebandBufferLayerWithDirtyGeometry)1250 TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
1251     displayRefreshCompositionDirtyGeometry<CompositionCase<
1252             DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1253             KeepCompositionTypeVariant<
1254                     aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1255             HwcCompositionResultVariant>>();
1256 }
1257 
TEST_F(CompositionTest,HWCComposedSidebandBufferLayerWithDirtyFrame)1258 TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
1259     displayRefreshCompositionDirtyFrame<CompositionCase<
1260             DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1261             KeepCompositionTypeVariant<
1262                     aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1263             HwcCompositionResultVariant>>();
1264 }
1265 
TEST_F(CompositionTest,REComposedSidebandBufferLayer)1266 TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
1267     displayRefreshCompositionDirtyFrame<CompositionCase<
1268             DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1269             ChangeCompositionTypeVariant<
1270                     aidl::android::hardware::graphics::composer3::Composition::SIDEBAND,
1271                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1272             RECompositionResultVariant>>();
1273 }
1274 
TEST_F(CompositionTest,captureScreenSidebandBufferLayer)1275 TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1276     captureScreenComposition<
1277             CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1278                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1279 }
1280 
1281 /* ------------------------------------------------------------------------
1282  *  Layers with ISurfaceComposerClient::eSecure, on a secure display
1283  */
1284 
TEST_F(CompositionTest,HWCComposedSecureBufferLayerWithDirtyGeometry)1285 TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
1286     displayRefreshCompositionDirtyGeometry<CompositionCase<
1287             DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1288             KeepCompositionTypeVariant<
1289                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1290             HwcCompositionResultVariant>>();
1291 }
1292 
TEST_F(CompositionTest,HWCComposedSecureBufferLayerWithDirtyFrame)1293 TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
1294     displayRefreshCompositionDirtyFrame<CompositionCase<
1295             DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1296             KeepCompositionTypeVariant<
1297                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1298             HwcCompositionResultVariant>>();
1299 }
1300 
TEST_F(CompositionTest,REComposedSecureBufferLayer)1301 TEST_F(CompositionTest, REComposedSecureBufferLayer) {
1302     displayRefreshCompositionDirtyFrame<CompositionCase<
1303             DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1304             ChangeCompositionTypeVariant<
1305                     aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1306                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1307             RECompositionResultVariant>>();
1308 }
1309 
TEST_F(CompositionTest,captureScreenSecureBufferLayerOnSecureDisplay)1310 TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1311     captureScreenComposition<
1312             CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1313                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1314 }
1315 
1316 /* ------------------------------------------------------------------------
1317  *  Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1318  */
1319 
TEST_F(CompositionTest,HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry)1320 TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
1321     displayRefreshCompositionDirtyGeometry<CompositionCase<
1322             InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1323             KeepCompositionTypeVariant<
1324                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1325             ForcedClientCompositionResultVariant>>();
1326 }
1327 
TEST_F(CompositionTest,HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame)1328 TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
1329     displayRefreshCompositionDirtyFrame<CompositionCase<
1330             InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1331             KeepCompositionTypeVariant<
1332                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1333             ForcedClientCompositionResultVariant>>();
1334 }
1335 
TEST_F(CompositionTest,captureScreenSecureBufferLayerOnInsecureDisplay)1336 TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1337     captureScreenComposition<
1338             CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1339                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1340 }
1341 
1342 /* ------------------------------------------------------------------------
1343  *  Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1344  */
1345 
TEST_F(CompositionTest,captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay)1346 TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1347     captureScreenComposition<
1348             CompositionCase<InsecureDisplaySetupVariant,
1349                             ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1350                                               ContainerLayerVariant<SecureLayerProperties>>,
1351                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1352 }
1353 
1354 /* ------------------------------------------------------------------------
1355  *  Cursor layers
1356  */
1357 
TEST_F(CompositionTest,HWCComposedCursorLayerWithDirtyGeometry)1358 TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
1359     displayRefreshCompositionDirtyGeometry<CompositionCase<
1360             DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1361             KeepCompositionTypeVariant<
1362                     aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1363             HwcCompositionResultVariant>>();
1364 }
1365 
TEST_F(CompositionTest,HWCComposedCursorLayerWithDirtyFrame)1366 TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
1367     displayRefreshCompositionDirtyFrame<CompositionCase<
1368             DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1369             KeepCompositionTypeVariant<
1370                     aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1371             HwcCompositionResultVariant>>();
1372 }
1373 
TEST_F(CompositionTest,REComposedCursorLayer)1374 TEST_F(CompositionTest, REComposedCursorLayer) {
1375     displayRefreshCompositionDirtyFrame<CompositionCase<
1376             DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1377             ChangeCompositionTypeVariant<
1378                     aidl::android::hardware::graphics::composer3::Composition::CURSOR,
1379                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1380             RECompositionResultVariant>>();
1381 }
1382 
TEST_F(CompositionTest,captureScreenCursorLayer)1383 TEST_F(CompositionTest, captureScreenCursorLayer) {
1384     captureScreenComposition<
1385             CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1386                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1387 }
1388 
1389 /* ------------------------------------------------------------------------
1390  *  Simple buffer layer on a display which is powered off.
1391  */
1392 
TEST_F(CompositionTest,displayOffHWCComposedNormalBufferLayerWithDirtyGeometry)1393 TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
1394     mDisplayOff = true;
1395     displayRefreshCompositionDirtyGeometry<CompositionCase<
1396             PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1397             KeepCompositionTypeVariant<
1398                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1399             HwcCompositionResultVariant>>();
1400 }
1401 
TEST_F(CompositionTest,displayOffHWCComposedNormalBufferLayerWithDirtyFrame)1402 TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
1403     mDisplayOff = true;
1404     displayRefreshCompositionDirtyFrame<CompositionCase<
1405             PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1406             KeepCompositionTypeVariant<
1407                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1408             HwcCompositionResultVariant>>();
1409 }
1410 
TEST_F(CompositionTest,displayOffREComposedNormalBufferLayer)1411 TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
1412     mDisplayOff = true;
1413     displayRefreshCompositionDirtyFrame<CompositionCase<
1414             PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1415             ChangeCompositionTypeVariant<
1416                     aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1417                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1418             RECompositionResultVariant>>();
1419 }
1420 
TEST_F(CompositionTest,captureScreenNormalBufferLayerOnPoweredOffDisplay)1421 TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1422     captureScreenComposition<CompositionCase<
1423             PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1424             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1425 }
1426 
1427 /* ------------------------------------------------------------------------
1428  *  Client composition forced through debug/developer settings
1429  */
1430 
TEST_F(CompositionTest,DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry)1431 TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
1432     displayRefreshCompositionDirtyGeometry<CompositionCase<
1433             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1434             KeepCompositionTypeVariant<
1435                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1436             ForcedClientCompositionViaDebugOptionResultVariant>>();
1437 }
1438 
TEST_F(CompositionTest,DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame)1439 TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
1440     displayRefreshCompositionDirtyFrame<CompositionCase<
1441             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1442             KeepCompositionTypeVariant<
1443                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1444             ForcedClientCompositionViaDebugOptionResultVariant>>();
1445 }
1446 
1447 } // namespace
1448 } // namespace android
1449 
1450 // TODO(b/129481165): remove the #pragma below and fix conversion issues
1451 #pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
1452