• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "renderengine/ExternalTexture.h"
19 #pragma clang diagnostic push
20 #pragma clang diagnostic ignored "-Wconversion"
21 #pragma clang diagnostic ignored "-Wextra"
22 
23 #undef LOG_TAG
24 #define LOG_TAG "CompositionTest"
25 
26 #include <compositionengine/Display.h>
27 #include <compositionengine/mock/DisplaySurface.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/mock/FakeExternalTexture.h>
34 #include <renderengine/mock/Framebuffer.h>
35 #include <renderengine/mock/Image.h>
36 #include <renderengine/mock/RenderEngine.h>
37 #include <system/window.h>
38 #include <utils/String8.h>
39 
40 #include "BufferQueueLayer.h"
41 #include "ContainerLayer.h"
42 #include "DisplayRenderArea.h"
43 #include "EffectLayer.h"
44 #include "Layer.h"
45 #include "TestableSurfaceFlinger.h"
46 #include "mock/DisplayHardware/MockComposer.h"
47 #include "mock/DisplayHardware/MockPowerAdvisor.h"
48 #include "mock/MockEventThread.h"
49 #include "mock/MockTimeStats.h"
50 #include "mock/MockVsyncController.h"
51 #include "mock/system/window/MockNativeWindow.h"
52 
53 namespace android {
54 namespace {
55 
56 namespace hal = android::hardware::graphics::composer::hal;
57 
58 using hal::Error;
59 using hal::IComposer;
60 using hal::IComposerClient;
61 using hal::PowerMode;
62 using hal::Transform;
63 
64 using aidl::android::hardware::graphics::composer3::Capability;
65 
66 using testing::_;
67 using testing::AtLeast;
68 using testing::DoAll;
69 using testing::IsNull;
70 using testing::Mock;
71 using testing::Return;
72 using testing::ReturnRef;
73 using testing::SetArgPointee;
74 
75 using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
76 using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;
77 
78 constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DISPLAY_ID;
79 constexpr hal::HWLayerId HWC_LAYER = 5000;
80 constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0);
81 
82 constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(42u);
83 constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
84 constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
85 
86 constexpr int DEFAULT_TEXTURE_ID = 6000;
87 constexpr ui::LayerStack LAYER_STACK{7000u};
88 
89 constexpr int DEFAULT_DISPLAY_MAX_LUMINANCE = 500;
90 
91 constexpr int DEFAULT_SIDEBAND_STREAM = 51;
92 
93 MATCHER(IsIdentityMatrix, "") {
94     constexpr auto kIdentity = mat4();
95     return (mat4(arg) == kIdentity);
96 }
97 
98 class CompositionTest : public testing::Test {
99 public:
CompositionTest()100     CompositionTest() {
101         const ::testing::TestInfo* const test_info =
102                 ::testing::UnitTest::GetInstance()->current_test_info();
103         ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
104 
105         setupScheduler();
106 
107         EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
108                 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
109         EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
110                 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
111 
112         mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
113         mFlinger.setupTimeStats(std::shared_ptr<TimeStats>(mTimeStats));
114 
115         mComposer = new Hwc2::mock::Composer();
116         mPowerAdvisor = new Hwc2::mock::PowerAdvisor();
117         mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
118         mFlinger.setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor>(mPowerAdvisor));
119         mFlinger.mutableMaxRenderTargetSize() = 16384;
120     }
121 
~CompositionTest()122     ~CompositionTest() {
123         const ::testing::TestInfo* const test_info =
124                 ::testing::UnitTest::GetInstance()->current_test_info();
125         ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
126     }
127 
setupScheduler()128     void setupScheduler() {
129         auto eventThread = std::make_unique<mock::EventThread>();
130         auto sfEventThread = std::make_unique<mock::EventThread>();
131 
132         EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
133         EXPECT_CALL(*eventThread, createEventConnection(_, _))
134                 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
135                                                            ResyncCallback())));
136 
137         EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
138         EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
139                 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
140                                                            ResyncCallback())));
141 
142         auto vsyncController = std::make_unique<mock::VsyncController>();
143         auto vsyncTracker = std::make_unique<mock::VSyncTracker>();
144 
145         EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
146         EXPECT_CALL(*vsyncTracker, currentPeriod())
147                 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
148         EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
149 
150         mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
151                                 std::move(eventThread), std::move(sfEventThread),
152                                 TestableSurfaceFlinger::SchedulerCallbackImpl::kNoOp,
153                                 TestableSurfaceFlinger::kTwoDisplayModes);
154     }
155 
setupForceGeometryDirty()156     void setupForceGeometryDirty() {
157         // TODO: This requires the visible region and other related
158         // state to be set, and is problematic for BufferLayers since they are
159         // not visible without a buffer (and setting up a buffer looks like a
160         // pain)
161         // mFlinger.mutableVisibleRegionsDirty() = true;
162 
163         mFlinger.mutableGeometryDirty() = true;
164     }
165 
166     template <typename Case>
167     void displayRefreshCompositionDirtyGeometry();
168 
169     template <typename Case>
170     void displayRefreshCompositionDirtyFrame();
171 
172     template <typename Case>
173     void captureScreenComposition();
174 
175     std::unordered_set<Capability> mDefaultCapabilities = {Capability::SIDEBAND_STREAM};
176 
177     bool mDisplayOff = false;
178     TestableSurfaceFlinger mFlinger;
179     sp<DisplayDevice> mDisplay;
180     sp<DisplayDevice> mExternalDisplay;
181     sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
182             new compositionengine::mock::DisplaySurface();
183     mock::NativeWindow* mNativeWindow = new mock::NativeWindow();
184     std::vector<sp<Layer>> mAuxiliaryLayers;
185 
186     sp<GraphicBuffer> mBuffer = new GraphicBuffer();
187     ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();
188 
189     Hwc2::mock::Composer* mComposer = nullptr;
190     renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
191     mock::TimeStats* mTimeStats = new mock::TimeStats();
192     Hwc2::mock::PowerAdvisor* mPowerAdvisor = nullptr;
193 
194     sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;
195 
196     std::shared_ptr<renderengine::ExternalTexture> mCaptureScreenBuffer;
197 };
198 
199 template <typename LayerCase>
displayRefreshCompositionDirtyGeometry()200 void CompositionTest::displayRefreshCompositionDirtyGeometry() {
201     setupForceGeometryDirty();
202     LayerCase::setupForDirtyGeometry(this);
203 
204     // --------------------------------------------------------------------
205     // Invocation
206 
207     mFlinger.commitAndComposite();
208 
209     LayerCase::cleanup(this);
210 }
211 
212 template <typename LayerCase>
displayRefreshCompositionDirtyFrame()213 void CompositionTest::displayRefreshCompositionDirtyFrame() {
214     LayerCase::setupForDirtyFrame(this);
215 
216     // --------------------------------------------------------------------
217     // Invocation
218 
219     mFlinger.commitAndComposite();
220 
221     LayerCase::cleanup(this);
222 }
223 
224 template <typename LayerCase>
captureScreenComposition()225 void CompositionTest::captureScreenComposition() {
226     LayerCase::setupForScreenCapture(this);
227 
228     const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
229     constexpr bool forSystem = true;
230     constexpr bool regionSampling = false;
231 
232     auto renderArea = DisplayRenderArea::create(mDisplay, sourceCrop, sourceCrop.getSize(),
233                                                 ui::Dataspace::V0_SRGB, ui::Transform::ROT_0);
234 
235     auto traverseLayers = [this](const LayerVector::Visitor& visitor) {
236         return mFlinger.traverseLayersInLayerStack(mDisplay->getLayerStack(),
237                                                    CaptureArgs::UNSET_UID, visitor);
238     };
239 
240     const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
241             GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
242     mCaptureScreenBuffer =
243             std::make_shared<renderengine::mock::FakeExternalTexture>(renderArea->getReqWidth(),
244                                                                       renderArea->getReqHeight(),
245                                                                       HAL_PIXEL_FORMAT_RGBA_8888, 1,
246                                                                       usage);
247 
248     auto future = mFlinger.renderScreenImpl(*renderArea, traverseLayers, mCaptureScreenBuffer,
249                                             forSystem, regionSampling);
250     ASSERT_TRUE(future.valid());
251     const auto fenceResult = future.get();
252 
253     EXPECT_EQ(NO_ERROR, fenceStatus(fenceResult));
254     if (fenceResult.ok()) {
255         fenceResult.value()->waitForever(LOG_TAG);
256     }
257 
258     LayerCase::cleanup(this);
259 }
260 
261 template <class T>
futureOf(T obj)262 std::future<T> futureOf(T obj) {
263     std::promise<T> resultPromise;
264     std::future<T> resultFuture = resultPromise.get_future();
265     resultPromise.set_value(std::move(obj));
266     return resultFuture;
267 }
268 
269 /* ------------------------------------------------------------------------
270  * Variants for each display configuration which can be tested
271  */
272 
273 template <typename Derived>
274 struct BaseDisplayVariant {
275     static constexpr bool IS_SECURE = true;
276     static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
277 
setupPreconditionsandroid::__anona937b1ac0111::BaseDisplayVariant278     static void setupPreconditions(CompositionTest* test) {
279         EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
280                 .WillOnce(Return(Error::NONE));
281 
282         FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
283                 .setCapabilities(&test->mDefaultCapabilities)
284                 .setPowerMode(Derived::INIT_POWER_MODE)
285                 .inject(&test->mFlinger, test->mComposer);
286         Mock::VerifyAndClear(test->mComposer);
287 
288         EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
289                 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
290         EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
291                 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
292         EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
293         EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
294         EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
295 
296         const ::testing::TestInfo* const test_info =
297                 ::testing::UnitTest::GetInstance()->current_test_info();
298 
299         auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
300                                      .setId(DEFAULT_DISPLAY_ID)
301                                      .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
302                                      .setIsSecure(Derived::IS_SECURE)
303                                      .setPowerAdvisor(test->mPowerAdvisor)
304                                      .setName(std::string("Injected display for ") +
305                                               test_info->test_case_name() + "." + test_info->name())
306                                      .build();
307 
308         auto compositionDisplay =
309                 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
310                                                        ceDisplayArgs);
311 
312         test->mDisplay = FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
313                                                    ui::DisplayConnectionType::Internal, HWC_DISPLAY,
314                                                    true /* isPrimary */)
315                                  .setDisplaySurface(test->mDisplaySurface)
316                                  .setNativeWindow(test->mNativeWindow)
317                                  .setSecure(Derived::IS_SECURE)
318                                  .setPowerMode(Derived::INIT_POWER_MODE)
319                                  .inject();
320         Mock::VerifyAndClear(test->mNativeWindow);
321         test->mDisplay->setLayerStack(LAYER_STACK);
322     }
323 
324     template <typename Case>
setupPreconditionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant325     static void setupPreconditionCallExpectations(CompositionTest* test) {
326         EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))
327                 .WillOnce(DoAll(SetArgPointee<1>(
328                                         std::vector<aidl::android::hardware::graphics::composer3::
329                                                             DisplayCapability>({})),
330                                 Return(Error::NONE)));
331     }
332 
333     template <typename Case>
setupCommonCompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant334     static void setupCommonCompositionCallExpectations(CompositionTest* test) {
335         EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
336         EXPECT_CALL(*test->mComposer, getDisplayRequests(HWC_DISPLAY, _, _, _)).Times(1);
337         EXPECT_CALL(*test->mComposer, acceptDisplayChanges(HWC_DISPLAY)).Times(1);
338         EXPECT_CALL(*test->mComposer, presentDisplay(HWC_DISPLAY, _)).Times(1);
339         EXPECT_CALL(*test->mComposer, getReleaseFences(HWC_DISPLAY, _, _)).Times(1);
340 
341         EXPECT_CALL(*test->mDisplaySurface, onFrameCommitted()).Times(1);
342         EXPECT_CALL(*test->mDisplaySurface, advanceFrame()).Times(1);
343 
344         Case::CompositionType::setupHwcSetCallExpectations(test);
345         Case::CompositionType::setupHwcGetCallExpectations(test);
346     }
347 
348     template <typename Case>
setupCommonScreensCaptureCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant349     static void setupCommonScreensCaptureCallExpectations(CompositionTest* test) {
350         EXPECT_CALL(*test->mRenderEngine, drawLayers)
351                 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
352                                     const std::vector<renderengine::LayerSettings>&,
353                                     const std::shared_ptr<renderengine::ExternalTexture>&,
354                                     const bool, base::unique_fd&&)
355                                         -> std::future<renderengine::RenderEngineResult> {
356                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
357                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
358                               displaySettings.physicalDisplay);
359                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
360                               displaySettings.clip);
361                     return futureOf<renderengine::RenderEngineResult>(
362                             {NO_ERROR, base::unique_fd()});
363                 });
364     }
365 
setupNonEmptyFrameCompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant366     static void setupNonEmptyFrameCompositionCallExpectations(CompositionTest* test) {
367         EXPECT_CALL(*test->mDisplaySurface, beginFrame(true)).Times(1);
368     }
369 
setupEmptyFrameCompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant370     static void setupEmptyFrameCompositionCallExpectations(CompositionTest* test) {
371         EXPECT_CALL(*test->mDisplaySurface, beginFrame(false)).Times(1);
372     }
373 
setupHwcCompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant374     static void setupHwcCompositionCallExpectations(CompositionTest* test) {
375         EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _))
376                 .Times(1);
377 
378         EXPECT_CALL(*test->mDisplaySurface,
379                     prepareFrame(compositionengine::DisplaySurface::CompositionType::Hwc))
380                 .Times(1);
381     }
382 
setupHwcClientCompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant383     static void setupHwcClientCompositionCallExpectations(CompositionTest* test) {
384         EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _, _))
385                 .Times(1);
386     }
387 
setupHwcForcedClientCompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant388     static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
389         EXPECT_CALL(*test->mComposer, validateDisplay(HWC_DISPLAY, _, _, _)).Times(1);
390     }
391 
setupRECompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant392     static void setupRECompositionCallExpectations(CompositionTest* test) {
393         EXPECT_CALL(*test->mDisplaySurface,
394                     prepareFrame(compositionengine::DisplaySurface::CompositionType::Gpu))
395                 .Times(1);
396         EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
397                 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
398 
399         EXPECT_CALL(*test->mNativeWindow, queueBuffer(_, _)).WillOnce(Return(0));
400         EXPECT_CALL(*test->mNativeWindow, dequeueBuffer(_, _))
401                 .WillOnce(DoAll(SetArgPointee<0>(test->mNativeWindowBuffer), SetArgPointee<1>(-1),
402                                 Return(0)));
403         EXPECT_CALL(*test->mRenderEngine, drawLayers)
404                 .WillRepeatedly([&](const renderengine::DisplaySettings& displaySettings,
405                                     const std::vector<renderengine::LayerSettings>&,
406                                     const std::shared_ptr<renderengine::ExternalTexture>&,
407                                     const bool, base::unique_fd&&)
408                                         -> std::future<renderengine::RenderEngineResult> {
409                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
410                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
411                               displaySettings.physicalDisplay);
412                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
413                               displaySettings.clip);
414                     EXPECT_EQ(ui::Dataspace::UNKNOWN, displaySettings.outputDataspace);
415                     return futureOf<renderengine::RenderEngineResult>(
416                             {NO_ERROR, base::unique_fd()});
417                 });
418     }
419 
420     template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant421     static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
422         Case::Layer::setupRECompositionCallExpectations(test);
423     }
424 
425     template <typename Case>
setupRELayerScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::BaseDisplayVariant426     static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
427         Case::Layer::setupREScreenshotCompositionCallExpectations(test);
428     }
429 };
430 
431 struct DefaultDisplaySetupVariant : public BaseDisplayVariant<DefaultDisplaySetupVariant> {};
432 
433 struct InsecureDisplaySetupVariant : public BaseDisplayVariant<InsecureDisplaySetupVariant> {
434     static constexpr bool IS_SECURE = false;
435 
436     template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anona937b1ac0111::InsecureDisplaySetupVariant437     static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
438         Case::Layer::setupInsecureRECompositionCallExpectations(test);
439     }
440 
441     template <typename Case>
setupRELayerScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::InsecureDisplaySetupVariant442     static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
443         Case::Layer::setupInsecureREScreenshotCompositionCallExpectations(test);
444     }
445 };
446 
447 struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDisplaySetupVariant> {
448     static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::OFF;
449 
450     template <typename Case>
setupPreconditionCallExpectationsandroid::__anona937b1ac0111::PoweredOffDisplaySetupVariant451     static void setupPreconditionCallExpectations(CompositionTest*) {}
452 
453     template <typename Case>
setupCommonCompositionCallExpectationsandroid::__anona937b1ac0111::PoweredOffDisplaySetupVariant454     static void setupCommonCompositionCallExpectations(CompositionTest* test) {
455         // TODO: This seems like an unnecessary call if display is powered off.
456         EXPECT_CALL(*test->mComposer, setColorTransform(HWC_DISPLAY, IsIdentityMatrix())).Times(1);
457 
458         // TODO: This seems like an unnecessary call if display is powered off.
459         Case::CompositionType::setupHwcSetCallExpectations(test);
460     }
461 
setupHwcCompositionCallExpectationsandroid::__anona937b1ac0111::PoweredOffDisplaySetupVariant462     static void setupHwcCompositionCallExpectations(CompositionTest*) {}
setupHwcClientCompositionCallExpectationsandroid::__anona937b1ac0111::PoweredOffDisplaySetupVariant463     static void setupHwcClientCompositionCallExpectations(CompositionTest*) {}
setupHwcForcedClientCompositionCallExpectationsandroid::__anona937b1ac0111::PoweredOffDisplaySetupVariant464     static void setupHwcForcedClientCompositionCallExpectations(CompositionTest*) {}
465 
setupRECompositionCallExpectationsandroid::__anona937b1ac0111::PoweredOffDisplaySetupVariant466     static void setupRECompositionCallExpectations(CompositionTest* test) {
467         // TODO: This seems like an unnecessary call if display is powered off.
468         EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
469                 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
470     }
471 
472     template <typename Case>
setupRELayerCompositionCallExpectationsandroid::__anona937b1ac0111::PoweredOffDisplaySetupVariant473     static void setupRELayerCompositionCallExpectations(CompositionTest*) {}
474 };
475 
476 /* ------------------------------------------------------------------------
477  * Variants for each layer configuration which can be tested
478  */
479 
480 template <typename LayerProperties>
481 struct BaseLayerProperties {
482     static constexpr uint32_t WIDTH = 100;
483     static constexpr uint32_t HEIGHT = 100;
484     static constexpr PixelFormat FORMAT = PIXEL_FORMAT_RGBA_8888;
485     static constexpr uint64_t USAGE =
486             GraphicBuffer::USAGE_SW_READ_NEVER | GraphicBuffer::USAGE_SW_WRITE_NEVER;
487     static constexpr android_dataspace DATASPACE = HAL_DATASPACE_UNKNOWN;
488     static constexpr uint32_t SCALING_MODE = 0;
489     static constexpr uint32_t TRANSFORM = 0;
490     static constexpr uint32_t LAYER_FLAGS = 0;
491     static constexpr float COLOR[] = {1.f, 1.f, 1.f, 1.f};
492     static constexpr IComposerClient::BlendMode BLENDMODE =
493             IComposerClient::BlendMode::PREMULTIPLIED;
494 
enqueueBufferandroid::__anona937b1ac0111::BaseLayerProperties495     static void enqueueBuffer(CompositionTest*, sp<BufferQueueLayer> layer) {
496         auto producer = layer->getProducer();
497 
498         IGraphicBufferProducer::QueueBufferOutput qbo;
499         status_t result = producer->connect(nullptr, NATIVE_WINDOW_API_EGL, false, &qbo);
500         if (result != NO_ERROR) {
501             ALOGE("Failed to connect() (%d)", result);
502             return;
503         }
504 
505         int slot;
506         sp<Fence> fence;
507         result = producer->dequeueBuffer(&slot, &fence, LayerProperties::WIDTH,
508                                          LayerProperties::HEIGHT, LayerProperties::FORMAT,
509                                          LayerProperties::USAGE, nullptr, nullptr);
510         if (result != IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) {
511             ALOGE("Failed to dequeueBuffer() (%d)", result);
512             return;
513         }
514 
515         sp<GraphicBuffer> buffer;
516         result = producer->requestBuffer(slot, &buffer);
517         if (result != NO_ERROR) {
518             ALOGE("Failed to requestBuffer() (%d)", result);
519             return;
520         }
521 
522         IGraphicBufferProducer::QueueBufferInput qbi(systemTime(), false /* isAutoTimestamp */,
523                                                      LayerProperties::DATASPACE,
524                                                      Rect(LayerProperties::WIDTH,
525                                                           LayerProperties::HEIGHT),
526                                                      LayerProperties::SCALING_MODE,
527                                                      LayerProperties::TRANSFORM, Fence::NO_FENCE);
528         result = producer->queueBuffer(slot, qbi, &qbo);
529         if (result != NO_ERROR) {
530             ALOGE("Failed to queueBuffer (%d)", result);
531             return;
532         }
533     }
534 
setupLatchedBufferandroid::__anona937b1ac0111::BaseLayerProperties535     static void setupLatchedBuffer(CompositionTest* test, sp<BufferQueueLayer> layer) {
536         // TODO: Eliminate the complexity of actually creating a buffer
537         layer->setSizeForTest(LayerProperties::WIDTH, LayerProperties::HEIGHT);
538         status_t err =
539                 layer->setDefaultBufferProperties(LayerProperties::WIDTH, LayerProperties::HEIGHT,
540                                                   LayerProperties::FORMAT);
541         ASSERT_EQ(NO_ERROR, err);
542         Mock::VerifyAndClear(test->mRenderEngine);
543 
544         EXPECT_CALL(*test->mFlinger.scheduler(), scheduleFrame()).Times(1);
545         enqueueBuffer(test, layer);
546         Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
547 
548         bool ignoredRecomputeVisibleRegions;
549         layer->latchBuffer(ignoredRecomputeVisibleRegions, 0, 0);
550         Mock::VerifyAndClear(test->mRenderEngine);
551     }
552 
setupLayerStateandroid::__anona937b1ac0111::BaseLayerProperties553     static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
554         setupLatchedBuffer(test, layer);
555     }
556 
setupHwcSetGeometryCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties557     static void setupHwcSetGeometryCallExpectations(CompositionTest* test) {
558         if (!test->mDisplayOff) {
559             // TODO: Coverage of other values
560             EXPECT_CALL(*test->mComposer,
561                         setLayerBlendMode(HWC_DISPLAY, HWC_LAYER, LayerProperties::BLENDMODE))
562                     .Times(1);
563             // TODO: Coverage of other values for origin
564             EXPECT_CALL(*test->mComposer,
565                         setLayerDisplayFrame(HWC_DISPLAY, HWC_LAYER,
566                                              IComposerClient::Rect({0, 0, LayerProperties::WIDTH,
567                                                                     LayerProperties::HEIGHT})))
568                     .Times(1);
569             EXPECT_CALL(*test->mComposer,
570                         setLayerPlaneAlpha(HWC_DISPLAY, HWC_LAYER, LayerProperties::COLOR[3]))
571                     .Times(1);
572             // TODO: Coverage of other values
573             EXPECT_CALL(*test->mComposer, setLayerZOrder(HWC_DISPLAY, HWC_LAYER, 0u)).Times(1);
574 
575             // These expectations retire on saturation as the code path these
576             // expectations are for appears to make an extra call to them.
577             // TODO: Investigate this extra call
578             EXPECT_CALL(*test->mComposer,
579                         setLayerTransform(HWC_DISPLAY, HWC_LAYER, DEFAULT_TRANSFORM))
580                     .Times(AtLeast(1))
581                     .RetiresOnSaturation();
582         }
583     }
584 
setupHwcSetSourceCropBufferCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties585     static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
586         if (!test->mDisplayOff) {
587             EXPECT_CALL(*test->mComposer,
588                         setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
589                                            IComposerClient::FRect({0.f, 0.f, LayerProperties::WIDTH,
590                                                                    LayerProperties::HEIGHT})))
591                     .Times(1);
592         }
593     }
594 
setupHwcSetSourceCropColorCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties595     static void setupHwcSetSourceCropColorCallExpectations(CompositionTest* test) {
596         if (!test->mDisplayOff) {
597             EXPECT_CALL(*test->mComposer,
598                         setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
599                                            IComposerClient::FRect({0.f, 0.f, 0.f, 0.f})))
600                     .Times(1);
601         }
602     }
603 
setupHwcSetPerFrameCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties604     static void setupHwcSetPerFrameCallExpectations(CompositionTest* test) {
605         if (!test->mDisplayOff) {
606             EXPECT_CALL(*test->mComposer,
607                         setLayerVisibleRegion(HWC_DISPLAY, HWC_LAYER,
608                                               std::vector<IComposerClient::Rect>(
609                                                       {IComposerClient::Rect(
610                                                               {0, 0, LayerProperties::WIDTH,
611                                                                LayerProperties::HEIGHT})})))
612                     .Times(1);
613         }
614     }
615 
setupHwcSetPerFrameColorCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties616     static void setupHwcSetPerFrameColorCallExpectations(CompositionTest* test) {
617         if (!test->mDisplayOff) {
618             EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
619                     .Times(1);
620 
621             // TODO: use COLOR
622             EXPECT_CALL(*test->mComposer,
623                         setLayerColor(HWC_DISPLAY, HWC_LAYER,
624                                       aidl::android::hardware::graphics::composer3::Color(
625                                               {1.0f, 1.0f, 1.0f, 1.0f})))
626                     .Times(1);
627         }
628     }
629 
setupHwcSetPerFrameBufferCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties630     static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
631         if (!test->mDisplayOff) {
632             EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
633                     .Times(1);
634             EXPECT_CALL(*test->mComposer, setLayerBuffer(HWC_DISPLAY, HWC_LAYER, _, _, _)).Times(1);
635         }
636     }
637 
setupREBufferCompositionCommonCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties638     static void setupREBufferCompositionCommonCallExpectations(CompositionTest* test) {
639         EXPECT_CALL(*test->mRenderEngine, drawLayers)
640                 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
641                               const std::vector<renderengine::LayerSettings>& layerSettings,
642                               const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
643                               base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
644                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
645                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
646                               displaySettings.physicalDisplay);
647                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
648                               displaySettings.clip);
649                     // screen capture adds an additional color layer as an alpha
650                     // prefill, so gtet the back layer.
651                     std::future<renderengine::RenderEngineResult> resultFuture =
652                             futureOf<renderengine::RenderEngineResult>(
653                                     {NO_ERROR, base::unique_fd()});
654                     if (layerSettings.empty()) {
655                         ADD_FAILURE() << "layerSettings was not expected to be empty in "
656                                          "setupREBufferCompositionCommonCallExpectations "
657                                          "verification lambda";
658                         return resultFuture;
659                     }
660                     const renderengine::LayerSettings layer = layerSettings.back();
661                     EXPECT_THAT(layer.source.buffer.buffer, Not(IsNull()));
662                     EXPECT_THAT(layer.source.buffer.fence, Not(IsNull()));
663                     EXPECT_EQ(DEFAULT_TEXTURE_ID, layer.source.buffer.textureName);
664                     EXPECT_EQ(false, layer.source.buffer.isY410BT2020);
665                     EXPECT_EQ(true, layer.source.buffer.usePremultipliedAlpha);
666                     EXPECT_EQ(false, layer.source.buffer.isOpaque);
667                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
668                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
669                     EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
670                     EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
671                     return resultFuture;
672                 });
673     }
674 
setupREBufferCompositionCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties675     static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
676         LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
677     }
678 
setupInsecureREBufferCompositionCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties679     static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
680         setupREBufferCompositionCallExpectations(test);
681     }
682 
setupREBufferScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties683     static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
684         LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
685     }
686 
setupInsecureREBufferScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties687     static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
688         LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
689     }
690 
setupREColorCompositionCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties691     static void setupREColorCompositionCallExpectations(CompositionTest* test) {
692         EXPECT_CALL(*test->mRenderEngine, drawLayers)
693                 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
694                               const std::vector<renderengine::LayerSettings>& layerSettings,
695                               const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
696                               base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
697                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
698                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
699                               displaySettings.physicalDisplay);
700                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
701                               displaySettings.clip);
702                     // screen capture adds an additional color layer as an alpha
703                     // prefill, so get the back layer.
704                     std::future<renderengine::RenderEngineResult> resultFuture =
705                             futureOf<renderengine::RenderEngineResult>(
706                                     {NO_ERROR, base::unique_fd()});
707                     if (layerSettings.empty()) {
708                         ADD_FAILURE()
709                                 << "layerSettings was not expected to be empty in "
710                                    "setupREColorCompositionCallExpectations 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(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
716                                     LayerProperties::COLOR[2]),
717                               layer.source.solidColor);
718                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
719                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
720                     EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
721                     EXPECT_EQ(LayerProperties::COLOR[3], layer.alpha);
722                     return resultFuture;
723                 });
724     }
725 
setupREColorScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::BaseLayerProperties726     static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
727         setupREColorCompositionCallExpectations(test);
728     }
729 };
730 
731 struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
732 
733 struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
734     static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
735 };
736 
737 struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
738     using Base = BaseLayerProperties<SidebandLayerProperties>;
739     static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
740 
setupLayerStateandroid::__anona937b1ac0111::SidebandLayerProperties741     static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
742         sp<NativeHandle> stream =
743                 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
744                                      false);
745         test->mFlinger.setLayerSidebandStream(layer, stream);
746     }
747 
setupHwcSetSourceCropBufferCallExpectationsandroid::__anona937b1ac0111::SidebandLayerProperties748     static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
749         EXPECT_CALL(*test->mComposer,
750                     setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
751                                        IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
752                 .Times(1);
753     }
754 
setupHwcSetPerFrameBufferCallExpectationsandroid::__anona937b1ac0111::SidebandLayerProperties755     static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
756         EXPECT_CALL(*test->mComposer,
757                     setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
758                                            reinterpret_cast<native_handle_t*>(
759                                                    DEFAULT_SIDEBAND_STREAM)))
760                 .WillOnce(Return(Error::NONE));
761 
762         EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
763     }
764 
setupREBufferCompositionCommonCallExpectationsandroid::__anona937b1ac0111::SidebandLayerProperties765     static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
766 };
767 
768 template <typename LayerProperties>
769 struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
770     using Base = BaseLayerProperties<LayerProperties>;
771 
setupInsecureREBufferCompositionCommonCallExpectationsandroid::__anona937b1ac0111::CommonSecureLayerProperties772     static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
773         EXPECT_CALL(*test->mRenderEngine, drawLayers)
774                 .WillOnce([&](const renderengine::DisplaySettings& displaySettings,
775                               const std::vector<renderengine::LayerSettings>& layerSettings,
776                               const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
777                               base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
778                     EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
779                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
780                               displaySettings.physicalDisplay);
781                     EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
782                               displaySettings.clip);
783                     // screen capture adds an additional color layer as an alpha
784                     // prefill, so get the back layer.
785                     std::future<renderengine::RenderEngineResult> resultFuture =
786                             futureOf<renderengine::RenderEngineResult>(
787                                     {NO_ERROR, base::unique_fd()});
788                     if (layerSettings.empty()) {
789                         ADD_FAILURE() << "layerSettings was not expected to be empty in "
790                                          "setupInsecureREBufferCompositionCommonCallExpectations "
791                                          "verification lambda";
792                         return resultFuture;
793                     }
794                     const renderengine::LayerSettings layer = layerSettings.back();
795                     EXPECT_THAT(layer.source.buffer.buffer, IsNull());
796                     EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer.source.solidColor);
797                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.x);
798                     EXPECT_EQ(0.0, layer.geometry.roundedCornersRadius.y);
799                     EXPECT_EQ(ui::Dataspace::UNKNOWN, layer.sourceDataspace);
800                     EXPECT_EQ(1.0f, layer.alpha);
801                     return resultFuture;
802                 });
803     }
804 
setupInsecureREBufferCompositionCallExpectationsandroid::__anona937b1ac0111::CommonSecureLayerProperties805     static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
806         setupInsecureREBufferCompositionCommonCallExpectations(test);
807     }
808 
setupInsecureREBufferScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::CommonSecureLayerProperties809     static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
810         setupInsecureREBufferCompositionCommonCallExpectations(test);
811     }
812 };
813 
814 struct ParentSecureLayerProperties
815       : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
816 
817 struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
818     static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
819 };
820 
821 struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
822     using Base = BaseLayerProperties<CursorLayerProperties>;
823 
setupLayerStateandroid::__anona937b1ac0111::CursorLayerProperties824     static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
825         Base::setupLayerState(test, layer);
826         test->mFlinger.setLayerPotentialCursor(layer, true);
827     }
828 };
829 
830 struct NoLayerVariant {
831     using FlingerLayerType = sp<BufferQueueLayer>;
832 
createLayerandroid::__anona937b1ac0111::NoLayerVariant833     static FlingerLayerType createLayer(CompositionTest*) { return FlingerLayerType(); }
injectLayerandroid::__anona937b1ac0111::NoLayerVariant834     static void injectLayer(CompositionTest*, FlingerLayerType) {}
cleanupInjectedLayersandroid::__anona937b1ac0111::NoLayerVariant835     static void cleanupInjectedLayers(CompositionTest*) {}
836 
setupCallExpectationsForDirtyGeometryandroid::__anona937b1ac0111::NoLayerVariant837     static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
setupCallExpectationsForDirtyFrameandroid::__anona937b1ac0111::NoLayerVariant838     static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
839 };
840 
841 template <typename LayerProperties>
842 struct BaseLayerVariant {
843     template <typename L, typename F>
createLayerWithFactoryandroid::__anona937b1ac0111::BaseLayerVariant844     static sp<L> createLayerWithFactory(CompositionTest* test, F factory) {
845         EXPECT_CALL(*test->mFlinger.scheduler(), postMessage(_)).Times(0);
846 
847         sp<L> layer = factory();
848 
849         // Layer should be registered with scheduler.
850         EXPECT_EQ(1u, test->mFlinger.scheduler()->layerHistorySize());
851 
852         Mock::VerifyAndClear(test->mComposer);
853         Mock::VerifyAndClear(test->mRenderEngine);
854         Mock::VerifyAndClearExpectations(test->mFlinger.scheduler());
855 
856         initLayerDrawingStateAndComputeBounds(test, layer);
857 
858         return layer;
859     }
860 
861     template <typename L>
initLayerDrawingStateAndComputeBoundsandroid::__anona937b1ac0111::BaseLayerVariant862     static void initLayerDrawingStateAndComputeBounds(CompositionTest* test, sp<L> layer) {
863         auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
864         layerDrawingState.layerStack = LAYER_STACK;
865         layerDrawingState.width = 100;
866         layerDrawingState.height = 100;
867         layerDrawingState.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
868                                         LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
869         layer->computeBounds(FloatRect(0, 0, 100, 100), ui::Transform(), 0.f /* shadowRadius */);
870     }
871 
injectLayerandroid::__anona937b1ac0111::BaseLayerVariant872     static void injectLayer(CompositionTest* test, sp<Layer> layer) {
873         EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
874                 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
875 
876         auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
877                 layer->getCompositionEngineLayerFE());
878         outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
879         outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
880 
881         Mock::VerifyAndClear(test->mComposer);
882 
883         test->mFlinger.mutableDrawingState().layersSortedByZ.add(layer);
884     }
885 
cleanupInjectedLayersandroid::__anona937b1ac0111::BaseLayerVariant886     static void cleanupInjectedLayers(CompositionTest* test) {
887         EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
888                 .WillOnce(Return(Error::NONE));
889 
890         test->mDisplay->getCompositionDisplay()->clearOutputLayers();
891         test->mFlinger.mutableDrawingState().layersSortedByZ.clear();
892 
893         // Layer should be unregistered with scheduler.
894         test->mFlinger.commit();
895         EXPECT_EQ(0u, test->mFlinger.scheduler()->layerHistorySize());
896     }
897 };
898 
899 template <typename LayerProperties>
900 struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
901     using Base = BaseLayerVariant<LayerProperties>;
902     using FlingerLayerType = sp<EffectLayer>;
903 
createLayerandroid::__anona937b1ac0111::EffectLayerVariant904     static FlingerLayerType createLayer(CompositionTest* test) {
905         FlingerLayerType layer = Base::template createLayerWithFactory<EffectLayer>(test, [test]() {
906             return new EffectLayer(
907                     LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(), "test-layer",
908                                       LayerProperties::LAYER_FLAGS, LayerMetadata()));
909         });
910 
911         auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
912         layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
913         return layer;
914     }
915 
setupRECompositionCallExpectationsandroid::__anona937b1ac0111::EffectLayerVariant916     static void setupRECompositionCallExpectations(CompositionTest* test) {
917         LayerProperties::setupREColorCompositionCallExpectations(test);
918     }
919 
setupREScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::EffectLayerVariant920     static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
921         LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
922     }
923 
setupCallExpectationsForDirtyGeometryandroid::__anona937b1ac0111::EffectLayerVariant924     static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
925         LayerProperties::setupHwcSetGeometryCallExpectations(test);
926         LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
927     }
928 
setupCallExpectationsForDirtyFrameandroid::__anona937b1ac0111::EffectLayerVariant929     static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
930         LayerProperties::setupHwcSetPerFrameCallExpectations(test);
931         LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
932     }
933 };
934 
935 template <typename LayerProperties>
936 struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
937     using Base = BaseLayerVariant<LayerProperties>;
938     using FlingerLayerType = sp<BufferQueueLayer>;
939 
createLayerandroid::__anona937b1ac0111::BufferLayerVariant940     static FlingerLayerType createLayer(CompositionTest* test) {
941         test->mFlinger.mutableTexturePool().push_back(DEFAULT_TEXTURE_ID);
942 
943         FlingerLayerType layer =
944                 Base::template createLayerWithFactory<BufferQueueLayer>(test, [test]() {
945                     LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
946                                            LayerProperties::LAYER_FLAGS, LayerMetadata());
947                     args.textureName = test->mFlinger.mutableTexturePool().back();
948                     return new BufferQueueLayer(args);
949                 });
950 
951         LayerProperties::setupLayerState(test, layer);
952 
953         return layer;
954     }
955 
cleanupInjectedLayersandroid::__anona937b1ac0111::BufferLayerVariant956     static void cleanupInjectedLayers(CompositionTest* test) {
957         Base::cleanupInjectedLayers(test);
958     }
959 
setupCallExpectationsForDirtyGeometryandroid::__anona937b1ac0111::BufferLayerVariant960     static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
961         LayerProperties::setupHwcSetGeometryCallExpectations(test);
962         LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
963     }
964 
setupCallExpectationsForDirtyFrameandroid::__anona937b1ac0111::BufferLayerVariant965     static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
966         LayerProperties::setupHwcSetPerFrameCallExpectations(test);
967         LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
968     }
969 
setupRECompositionCallExpectationsandroid::__anona937b1ac0111::BufferLayerVariant970     static void setupRECompositionCallExpectations(CompositionTest* test) {
971         LayerProperties::setupREBufferCompositionCallExpectations(test);
972     }
973 
setupInsecureRECompositionCallExpectationsandroid::__anona937b1ac0111::BufferLayerVariant974     static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
975         LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
976     }
977 
setupREScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::BufferLayerVariant978     static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
979         LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
980     }
981 
setupInsecureREScreenshotCompositionCallExpectationsandroid::__anona937b1ac0111::BufferLayerVariant982     static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
983         LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
984     }
985 };
986 
987 template <typename LayerProperties>
988 struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
989     using Base = BaseLayerVariant<LayerProperties>;
990     using FlingerLayerType = sp<ContainerLayer>;
991 
createLayerandroid::__anona937b1ac0111::ContainerLayerVariant992     static FlingerLayerType createLayer(CompositionTest* test) {
993         LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
994                                LayerProperties::LAYER_FLAGS, LayerMetadata());
995         FlingerLayerType layer = new ContainerLayer(args);
996         Base::template initLayerDrawingStateAndComputeBounds(test, layer);
997         return layer;
998     }
999 };
1000 
1001 template <typename LayerVariant, typename ParentLayerVariant>
1002 struct ChildLayerVariant : public LayerVariant {
1003     using Base = LayerVariant;
1004     using FlingerLayerType = typename LayerVariant::FlingerLayerType;
1005     using ParentBase = ParentLayerVariant;
1006 
createLayerandroid::__anona937b1ac0111::ChildLayerVariant1007     static FlingerLayerType createLayer(CompositionTest* test) {
1008         // Need to create child layer first. Otherwise layer history size will be 2.
1009         FlingerLayerType layer = Base::createLayer(test);
1010 
1011         typename ParentBase::FlingerLayerType parentLayer = ParentBase::createLayer(test);
1012         parentLayer->addChild(layer);
1013         test->mFlinger.setLayerDrawingParent(layer, parentLayer);
1014 
1015         test->mAuxiliaryLayers.push_back(parentLayer);
1016 
1017         return layer;
1018     }
1019 
cleanupInjectedLayersandroid::__anona937b1ac0111::ChildLayerVariant1020     static void cleanupInjectedLayers(CompositionTest* test) {
1021         // Clear auxiliary layers first so that child layer can be successfully destroyed in the
1022         // following call.
1023         test->mAuxiliaryLayers.clear();
1024 
1025         Base::cleanupInjectedLayers(test);
1026     }
1027 };
1028 
1029 /* ------------------------------------------------------------------------
1030  * Variants to control how the composition type is changed
1031  */
1032 
1033 struct NoCompositionTypeVariant {
setupHwcSetCallExpectationsandroid::__anona937b1ac0111::NoCompositionTypeVariant1034     static void setupHwcSetCallExpectations(CompositionTest*) {}
1035 
setupHwcGetCallExpectationsandroid::__anona937b1ac0111::NoCompositionTypeVariant1036     static void setupHwcGetCallExpectations(CompositionTest* test) {
1037         EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1038     }
1039 };
1040 
1041 template <aidl::android::hardware::graphics::composer3::Composition CompositionType>
1042 struct KeepCompositionTypeVariant {
1043     static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
1044             CompositionType;
1045 
setupHwcSetCallExpectationsandroid::__anona937b1ac0111::KeepCompositionTypeVariant1046     static void setupHwcSetCallExpectations(CompositionTest* test) {
1047         if (!test->mDisplayOff) {
1048             EXPECT_CALL(*test->mComposer,
1049                         setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
1050                     .Times(1);
1051         }
1052     }
1053 
setupHwcGetCallExpectationsandroid::__anona937b1ac0111::KeepCompositionTypeVariant1054     static void setupHwcGetCallExpectations(CompositionTest* test) {
1055         EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1056     }
1057 };
1058 
1059 template <aidl::android::hardware::graphics::composer3::Composition InitialCompositionType,
1060           aidl::android::hardware::graphics::composer3::Composition FinalCompositionType>
1061 struct ChangeCompositionTypeVariant {
1062     static constexpr aidl::android::hardware::graphics::composer3::Composition TYPE =
1063             FinalCompositionType;
1064 
setupHwcSetCallExpectationsandroid::__anona937b1ac0111::ChangeCompositionTypeVariant1065     static void setupHwcSetCallExpectations(CompositionTest* test) {
1066         if (!test->mDisplayOff) {
1067             EXPECT_CALL(*test->mComposer,
1068                         setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
1069                     .Times(1);
1070         }
1071     }
1072 
setupHwcGetCallExpectationsandroid::__anona937b1ac0111::ChangeCompositionTypeVariant1073     static void setupHwcGetCallExpectations(CompositionTest* test) {
1074         EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
1075                 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
1076                                         static_cast<Hwc2::Layer>(HWC_LAYER)}),
1077                                 SetArgPointee<2>(
1078                                         std::vector<aidl::android::hardware::graphics::composer3::
1079                                                             Composition>{FinalCompositionType}),
1080                                 Return(Error::NONE)));
1081     }
1082 };
1083 
1084 /* ------------------------------------------------------------------------
1085  * Variants to select how the composition is expected to be handled
1086  */
1087 
1088 struct CompositionResultBaseVariant {
setupLayerStateandroid::__anona937b1ac0111::CompositionResultBaseVariant1089     static void setupLayerState(CompositionTest*, sp<Layer>) {}
1090 
1091     template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anona937b1ac0111::CompositionResultBaseVariant1092     static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
1093         Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1094     }
1095 
1096     template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anona937b1ac0111::CompositionResultBaseVariant1097     static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1098         Case::Layer::setupCallExpectationsForDirtyFrame(test);
1099     }
1100 };
1101 
1102 struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1103     template <typename Case>
setupCallExpectationsandroid::__anona937b1ac0111::NoCompositionResultVariant1104     static void setupCallExpectations(CompositionTest* test) {
1105         Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1106         Case::Display::setupHwcCompositionCallExpectations(test);
1107     }
1108 };
1109 
1110 struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1111     template <typename Case>
setupCallExpectationsandroid::__anona937b1ac0111::HwcCompositionResultVariant1112     static void setupCallExpectations(CompositionTest* test) {
1113         Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1114         Case::Display::setupHwcCompositionCallExpectations(test);
1115     }
1116 };
1117 
1118 struct RECompositionResultVariant : public CompositionResultBaseVariant {
1119     template <typename Case>
setupCallExpectationsandroid::__anona937b1ac0111::RECompositionResultVariant1120     static void setupCallExpectations(CompositionTest* test) {
1121         Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1122         Case::Display::setupHwcClientCompositionCallExpectations(test);
1123         Case::Display::setupRECompositionCallExpectations(test);
1124         Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1125     }
1126 };
1127 
1128 struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
setupLayerStateandroid::__anona937b1ac0111::ForcedClientCompositionResultVariant1129     static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
1130         const auto outputLayer =
1131                 TestableSurfaceFlinger::findOutputLayerForDisplay(layer, test->mDisplay);
1132         LOG_FATAL_IF(!outputLayer);
1133         outputLayer->editState().forceClientComposition = true;
1134     }
1135 
1136     template <typename Case>
setupCallExpectationsandroid::__anona937b1ac0111::ForcedClientCompositionResultVariant1137     static void setupCallExpectations(CompositionTest* test) {
1138         Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1139         Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1140         Case::Display::setupRECompositionCallExpectations(test);
1141         Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1142     }
1143 
1144     template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anona937b1ac0111::ForcedClientCompositionResultVariant1145     static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1146 
1147     template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anona937b1ac0111::ForcedClientCompositionResultVariant1148     static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1149 };
1150 
1151 struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
setupLayerStateandroid::__anona937b1ac0111::ForcedClientCompositionViaDebugOptionResultVariant1152     static void setupLayerState(CompositionTest* test, sp<Layer>) {
1153         test->mFlinger.mutableDebugDisableHWC() = true;
1154     }
1155 
1156     template <typename Case>
setupCallExpectationsandroid::__anona937b1ac0111::ForcedClientCompositionViaDebugOptionResultVariant1157     static void setupCallExpectations(CompositionTest* test) {
1158         Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1159         Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1160         Case::Display::setupRECompositionCallExpectations(test);
1161         Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1162     }
1163 
1164     template <typename Case>
setupCallExpectationsForDirtyGeometryandroid::__anona937b1ac0111::ForcedClientCompositionViaDebugOptionResultVariant1165     static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1166 
1167     template <typename Case>
setupCallExpectationsForDirtyFrameandroid::__anona937b1ac0111::ForcedClientCompositionViaDebugOptionResultVariant1168     static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1169 };
1170 
1171 struct EmptyScreenshotResultVariant {
setupLayerStateandroid::__anona937b1ac0111::EmptyScreenshotResultVariant1172     static void setupLayerState(CompositionTest*, sp<Layer>) {}
1173 
1174     template <typename Case>
setupCallExpectationsandroid::__anona937b1ac0111::EmptyScreenshotResultVariant1175     static void setupCallExpectations(CompositionTest*) {}
1176 };
1177 
1178 struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1179     using Base = EmptyScreenshotResultVariant;
1180 
1181     template <typename Case>
setupCallExpectationsandroid::__anona937b1ac0111::REScreenshotResultVariant1182     static void setupCallExpectations(CompositionTest* test) {
1183         Base::template setupCallExpectations<Case>(test);
1184         Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1185     }
1186 };
1187 
1188 /* ------------------------------------------------------------------------
1189  * Composition test case, containing all the variants being tested
1190  */
1191 
1192 template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1193           typename CompositionResultCase>
1194 struct CompositionCase {
1195     using ThisCase =
1196             CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1197     using Display = DisplayCase;
1198     using Layer = LayerCase;
1199     using CompositionType = CompositionTypeCase;
1200     using CompositionResult = CompositionResultCase;
1201 
setupCommonandroid::__anona937b1ac0111::CompositionCase1202     static void setupCommon(CompositionTest* test) {
1203         Display::template setupPreconditionCallExpectations<ThisCase>(test);
1204         Display::setupPreconditions(test);
1205 
1206         auto layer = Layer::createLayer(test);
1207         Layer::injectLayer(test, layer);
1208         CompositionResult::setupLayerState(test, layer);
1209     }
1210 
setupForDirtyGeometryandroid::__anona937b1ac0111::CompositionCase1211     static void setupForDirtyGeometry(CompositionTest* test) {
1212         setupCommon(test);
1213 
1214         Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1215         CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1216         CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1217         CompositionResult::template setupCallExpectations<ThisCase>(test);
1218     }
1219 
setupForDirtyFrameandroid::__anona937b1ac0111::CompositionCase1220     static void setupForDirtyFrame(CompositionTest* test) {
1221         setupCommon(test);
1222 
1223         Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1224         CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1225         CompositionResult::template setupCallExpectations<ThisCase>(test);
1226     }
1227 
setupForScreenCaptureandroid::__anona937b1ac0111::CompositionCase1228     static void setupForScreenCapture(CompositionTest* test) {
1229         setupCommon(test);
1230 
1231         Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1232         CompositionResult::template setupCallExpectations<ThisCase>(test);
1233     }
1234 
cleanupandroid::__anona937b1ac0111::CompositionCase1235     static void cleanup(CompositionTest* test) {
1236         Layer::cleanupInjectedLayers(test);
1237 
1238         for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1239             static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1240                     ->mutableLayers()
1241                     .clear();
1242         }
1243     }
1244 };
1245 
1246 /* ------------------------------------------------------------------------
1247  * Composition cases to test
1248  */
1249 
TEST_F(CompositionTest,noLayersDoesMinimalWorkWithDirtyGeometry)1250 TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1251     displayRefreshCompositionDirtyGeometry<
1252             CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1253                             NoCompositionResultVariant>>();
1254 }
1255 
TEST_F(CompositionTest,noLayersDoesMinimalWorkWithDirtyFrame)1256 TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1257     displayRefreshCompositionDirtyFrame<
1258             CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1259                             NoCompositionResultVariant>>();
1260 }
1261 
TEST_F(CompositionTest,noLayersDoesMinimalWorkToCaptureScreen)1262 TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1263     captureScreenComposition<
1264             CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1265                             EmptyScreenshotResultVariant>>();
1266 }
1267 
1268 /* ------------------------------------------------------------------------
1269  *  Simple buffer layers
1270  */
1271 
TEST_F(CompositionTest,HWCComposedNormalBufferLayerWithDirtyGeometry)1272 TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
1273     displayRefreshCompositionDirtyGeometry<CompositionCase<
1274             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1275             KeepCompositionTypeVariant<
1276                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1277             HwcCompositionResultVariant>>();
1278 }
1279 
TEST_F(CompositionTest,HWCComposedNormalBufferLayerWithDirtyFrame)1280 TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
1281     displayRefreshCompositionDirtyFrame<CompositionCase<
1282             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1283             KeepCompositionTypeVariant<
1284                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1285             HwcCompositionResultVariant>>();
1286 }
1287 
TEST_F(CompositionTest,REComposedNormalBufferLayer)1288 TEST_F(CompositionTest, REComposedNormalBufferLayer) {
1289     displayRefreshCompositionDirtyFrame<CompositionCase<
1290             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1291             ChangeCompositionTypeVariant<
1292                     aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1293                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1294             RECompositionResultVariant>>();
1295 }
1296 
TEST_F(CompositionTest,captureScreenNormalBufferLayer)1297 TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1298     captureScreenComposition<
1299             CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1300                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1301 }
1302 
1303 /* ------------------------------------------------------------------------
1304  *  Single-color layers
1305  */
1306 
TEST_F(CompositionTest,HWCComposedEffectLayerWithDirtyGeometry)1307 TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
1308     displayRefreshCompositionDirtyGeometry<CompositionCase<
1309             DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1310             KeepCompositionTypeVariant<
1311                     aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1312             HwcCompositionResultVariant>>();
1313 }
1314 
TEST_F(CompositionTest,HWCComposedEffectLayerWithDirtyFrame)1315 TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
1316     displayRefreshCompositionDirtyFrame<CompositionCase<
1317             DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1318             KeepCompositionTypeVariant<
1319                     aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR>,
1320             HwcCompositionResultVariant>>();
1321 }
1322 
TEST_F(CompositionTest,REComposedEffectLayer)1323 TEST_F(CompositionTest, REComposedEffectLayer) {
1324     displayRefreshCompositionDirtyFrame<CompositionCase<
1325             DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1326             ChangeCompositionTypeVariant<
1327                     aidl::android::hardware::graphics::composer3::Composition::SOLID_COLOR,
1328                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1329             RECompositionResultVariant>>();
1330 }
1331 
TEST_F(CompositionTest,captureScreenEffectLayer)1332 TEST_F(CompositionTest, captureScreenEffectLayer) {
1333     captureScreenComposition<
1334             CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
1335                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1336 }
1337 
1338 /* ------------------------------------------------------------------------
1339  *  Layers with sideband buffers
1340  */
1341 
TEST_F(CompositionTest,HWCComposedSidebandBufferLayerWithDirtyGeometry)1342 TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
1343     displayRefreshCompositionDirtyGeometry<CompositionCase<
1344             DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1345             KeepCompositionTypeVariant<
1346                     aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1347             HwcCompositionResultVariant>>();
1348 }
1349 
TEST_F(CompositionTest,HWCComposedSidebandBufferLayerWithDirtyFrame)1350 TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
1351     displayRefreshCompositionDirtyFrame<CompositionCase<
1352             DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1353             KeepCompositionTypeVariant<
1354                     aidl::android::hardware::graphics::composer3::Composition::SIDEBAND>,
1355             HwcCompositionResultVariant>>();
1356 }
1357 
TEST_F(CompositionTest,REComposedSidebandBufferLayer)1358 TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
1359     displayRefreshCompositionDirtyFrame<CompositionCase<
1360             DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1361             ChangeCompositionTypeVariant<
1362                     aidl::android::hardware::graphics::composer3::Composition::SIDEBAND,
1363                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1364             RECompositionResultVariant>>();
1365 }
1366 
TEST_F(CompositionTest,captureScreenSidebandBufferLayer)1367 TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1368     captureScreenComposition<
1369             CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1370                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1371 }
1372 
1373 /* ------------------------------------------------------------------------
1374  *  Layers with ISurfaceComposerClient::eSecure, on a secure display
1375  */
1376 
TEST_F(CompositionTest,HWCComposedSecureBufferLayerWithDirtyGeometry)1377 TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
1378     displayRefreshCompositionDirtyGeometry<CompositionCase<
1379             DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1380             KeepCompositionTypeVariant<
1381                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1382             HwcCompositionResultVariant>>();
1383 }
1384 
TEST_F(CompositionTest,HWCComposedSecureBufferLayerWithDirtyFrame)1385 TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
1386     displayRefreshCompositionDirtyFrame<CompositionCase<
1387             DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1388             KeepCompositionTypeVariant<
1389                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1390             HwcCompositionResultVariant>>();
1391 }
1392 
TEST_F(CompositionTest,REComposedSecureBufferLayer)1393 TEST_F(CompositionTest, REComposedSecureBufferLayer) {
1394     displayRefreshCompositionDirtyFrame<CompositionCase<
1395             DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1396             ChangeCompositionTypeVariant<
1397                     aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1398                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1399             RECompositionResultVariant>>();
1400 }
1401 
TEST_F(CompositionTest,captureScreenSecureBufferLayerOnSecureDisplay)1402 TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1403     captureScreenComposition<
1404             CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1405                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1406 }
1407 
1408 /* ------------------------------------------------------------------------
1409  *  Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1410  */
1411 
TEST_F(CompositionTest,HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry)1412 TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
1413     displayRefreshCompositionDirtyGeometry<CompositionCase<
1414             InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1415             KeepCompositionTypeVariant<
1416                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1417             ForcedClientCompositionResultVariant>>();
1418 }
1419 
TEST_F(CompositionTest,HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame)1420 TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
1421     displayRefreshCompositionDirtyFrame<CompositionCase<
1422             InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1423             KeepCompositionTypeVariant<
1424                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1425             ForcedClientCompositionResultVariant>>();
1426 }
1427 
TEST_F(CompositionTest,captureScreenSecureBufferLayerOnInsecureDisplay)1428 TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1429     captureScreenComposition<
1430             CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1431                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1432 }
1433 
1434 /* ------------------------------------------------------------------------
1435  *  Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1436  */
1437 
TEST_F(CompositionTest,HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyGeometry)1438 TEST_F(CompositionTest,
1439        HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyGeometry) {
1440     displayRefreshCompositionDirtyGeometry<CompositionCase<
1441             InsecureDisplaySetupVariant,
1442             ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1443                               ContainerLayerVariant<SecureLayerProperties>>,
1444             KeepCompositionTypeVariant<
1445                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1446             ForcedClientCompositionResultVariant>>();
1447 }
1448 
TEST_F(CompositionTest,HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyFrame)1449 TEST_F(CompositionTest,
1450        HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyFrame) {
1451     displayRefreshCompositionDirtyFrame<CompositionCase<
1452             InsecureDisplaySetupVariant,
1453             ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1454                               ContainerLayerVariant<SecureLayerProperties>>,
1455             KeepCompositionTypeVariant<
1456                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1457             ForcedClientCompositionResultVariant>>();
1458 }
1459 
TEST_F(CompositionTest,captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay)1460 TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1461     captureScreenComposition<
1462             CompositionCase<InsecureDisplaySetupVariant,
1463                             ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1464                                               ContainerLayerVariant<SecureLayerProperties>>,
1465                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1466 }
1467 
1468 /* ------------------------------------------------------------------------
1469  *  Cursor layers
1470  */
1471 
TEST_F(CompositionTest,HWCComposedCursorLayerWithDirtyGeometry)1472 TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
1473     displayRefreshCompositionDirtyGeometry<CompositionCase<
1474             DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1475             KeepCompositionTypeVariant<
1476                     aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1477             HwcCompositionResultVariant>>();
1478 }
1479 
TEST_F(CompositionTest,HWCComposedCursorLayerWithDirtyFrame)1480 TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
1481     displayRefreshCompositionDirtyFrame<CompositionCase<
1482             DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1483             KeepCompositionTypeVariant<
1484                     aidl::android::hardware::graphics::composer3::Composition::CURSOR>,
1485             HwcCompositionResultVariant>>();
1486 }
1487 
TEST_F(CompositionTest,REComposedCursorLayer)1488 TEST_F(CompositionTest, REComposedCursorLayer) {
1489     displayRefreshCompositionDirtyFrame<CompositionCase<
1490             DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1491             ChangeCompositionTypeVariant<
1492                     aidl::android::hardware::graphics::composer3::Composition::CURSOR,
1493                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1494             RECompositionResultVariant>>();
1495 }
1496 
TEST_F(CompositionTest,captureScreenCursorLayer)1497 TEST_F(CompositionTest, captureScreenCursorLayer) {
1498     captureScreenComposition<
1499             CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1500                             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1501 }
1502 
1503 /* ------------------------------------------------------------------------
1504  *  Simple buffer layer on a display which is powered off.
1505  */
1506 
TEST_F(CompositionTest,displayOffHWCComposedNormalBufferLayerWithDirtyGeometry)1507 TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
1508     mDisplayOff = true;
1509     displayRefreshCompositionDirtyGeometry<CompositionCase<
1510             PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1511             KeepCompositionTypeVariant<
1512                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1513             HwcCompositionResultVariant>>();
1514 }
1515 
TEST_F(CompositionTest,displayOffHWCComposedNormalBufferLayerWithDirtyFrame)1516 TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
1517     mDisplayOff = true;
1518     displayRefreshCompositionDirtyFrame<CompositionCase<
1519             PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1520             KeepCompositionTypeVariant<
1521                     aidl::android::hardware::graphics::composer3::Composition::DEVICE>,
1522             HwcCompositionResultVariant>>();
1523 }
1524 
TEST_F(CompositionTest,displayOffREComposedNormalBufferLayer)1525 TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
1526     mDisplayOff = true;
1527     displayRefreshCompositionDirtyFrame<CompositionCase<
1528             PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1529             ChangeCompositionTypeVariant<
1530                     aidl::android::hardware::graphics::composer3::Composition::DEVICE,
1531                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1532             RECompositionResultVariant>>();
1533 }
1534 
TEST_F(CompositionTest,captureScreenNormalBufferLayerOnPoweredOffDisplay)1535 TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1536     captureScreenComposition<CompositionCase<
1537             PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1538             NoCompositionTypeVariant, REScreenshotResultVariant>>();
1539 }
1540 
1541 /* ------------------------------------------------------------------------
1542  *  Client composition forced through debug/developer settings
1543  */
1544 
TEST_F(CompositionTest,DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry)1545 TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
1546     displayRefreshCompositionDirtyGeometry<CompositionCase<
1547             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1548             KeepCompositionTypeVariant<
1549                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1550             ForcedClientCompositionViaDebugOptionResultVariant>>();
1551 }
1552 
TEST_F(CompositionTest,DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame)1553 TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
1554     displayRefreshCompositionDirtyFrame<CompositionCase<
1555             DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1556             KeepCompositionTypeVariant<
1557                     aidl::android::hardware::graphics::composer3::Composition::CLIENT>,
1558             ForcedClientCompositionViaDebugOptionResultVariant>>();
1559 }
1560 
1561 } // namespace
1562 } // namespace android
1563 
1564 // TODO(b/129481165): remove the #pragma below and fix conversion issues
1565 #pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
1566