blob: 52a36a271956e369ab7f3a8e4e8989e421042062 [file] [log] [blame]
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001/*
2 * Copyright 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
Alec Mouria90a5702021-04-16 16:36:21 +000018#include "renderengine/ExternalTexture.h"
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080019#pragma clang diagnostic push
20#pragma clang diagnostic ignored "-Wconversion"
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010021#pragma clang diagnostic ignored "-Wextra"
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080022
Lloyd Piqued6b579f2018-04-06 15:29:10 -070023#undef LOG_TAG
24#define LOG_TAG "CompositionTest"
25
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080026#include <compositionengine/Display.h>
Lloyd Pique542307f2018-10-19 13:24:08 -070027#include <compositionengine/mock/DisplaySurface.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070028#include <gmock/gmock.h>
29#include <gtest/gtest.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070030#include <gui/IProducerListener.h>
Evan Roskya1f1e152019-01-24 16:17:46 -080031#include <gui/LayerMetadata.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070032#include <log/log.h>
Lloyd Pique3823e7b2018-10-18 16:58:10 -070033#include <renderengine/mock/Framebuffer.h>
34#include <renderengine/mock/Image.h>
35#include <renderengine/mock/RenderEngine.h>
Lloyd Piqued6b579f2018-04-06 15:29:10 -070036#include <system/window.h>
37#include <utils/String8.h>
38
39#include "BufferQueueLayer.h"
Garfield Tande619fa2020-10-02 17:13:53 -070040#include "ContainerLayer.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +020041#include "DisplayRenderArea.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080042#include "EffectLayer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070043#include "Layer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070044#include "TestableSurfaceFlinger.h"
45#include "mock/DisplayHardware/MockComposer.h"
Lloyd Pique9370a482019-10-03 17:58:30 -070046#include "mock/DisplayHardware/MockPowerAdvisor.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070047#include "mock/MockEventThread.h"
48#include "mock/MockMessageQueue.h"
Alec Mourie4034bb2019-11-19 12:45:54 -080049#include "mock/MockTimeStats.h"
Ady Abraham8cb21882020-08-26 18:22:05 -070050#include "mock/MockVsyncController.h"
Alec Mouriba013fa2018-10-16 12:43:11 -070051#include "mock/system/window/MockNativeWindow.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070052
53namespace android {
54namespace {
55
Peiyong Line9d809e2020-04-14 13:10:48 -070056namespace hal = android::hardware::graphics::composer::hal;
57
Peiyong Lin65248e02020-04-18 21:15:07 -070058using hal::Error;
59using hal::IComposer;
60using hal::IComposerClient;
61using hal::PowerMode;
62using hal::Transform;
63
Lloyd Piqued6b579f2018-04-06 15:29:10 -070064using testing::_;
David Sodman15094112018-10-11 09:39:37 -070065using testing::AtLeast;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070066using testing::DoAll;
67using testing::IsNull;
68using testing::Mock;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070069using testing::Return;
70using testing::ReturnRef;
71using testing::SetArgPointee;
72
Lloyd Piqued6b579f2018-04-06 15:29:10 -070073using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
74using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;
75
Peiyong Line9d809e2020-04-14 13:10:48 -070076constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DISPLAY_ID;
77constexpr hal::HWLayerId HWC_LAYER = 5000;
Lloyd Piqued6b579f2018-04-06 15:29:10 -070078constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0);
79
Marin Shalamanova524a092020-07-27 21:39:55 +020080constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID(42);
Lloyd Piqued6b579f2018-04-06 15:29:10 -070081constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
82constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
83
Lloyd Piqued6b579f2018-04-06 15:29:10 -070084constexpr int DEFAULT_TEXTURE_ID = 6000;
85constexpr int DEFAULT_LAYER_STACK = 7000;
86
87constexpr int DEFAULT_DISPLAY_MAX_LUMINANCE = 500;
88
89constexpr int DEFAULT_SIDEBAND_STREAM = 51;
90
91class CompositionTest : public testing::Test {
92public:
93 CompositionTest() {
94 const ::testing::TestInfo* const test_info =
95 ::testing::UnitTest::GetInstance()->current_test_info();
96 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
97
Lloyd Piqued6b579f2018-04-06 15:29:10 -070098 mFlinger.mutableEventQueue().reset(mMessageQueue);
Ana Krulecafb45842019-02-13 13:33:03 -080099 setupScheduler();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700100
Alec Mourif6fd29e2018-11-17 04:56:41 +0000101 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
102 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
103 EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
104 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700105
106 mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
Alec Mourie4034bb2019-11-19 12:45:54 -0800107 mFlinger.setupTimeStats(std::shared_ptr<TimeStats>(mTimeStats));
Dominik Laskowski13948602021-03-08 20:48:28 -0800108
109 mComposer = new Hwc2::mock::Composer();
110 mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
Garfield Tan9c9c1912021-07-19 12:02:16 -0700111
112 mFlinger.mutableMaxRenderTargetSize() = 16384;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700113 }
114
115 ~CompositionTest() {
116 const ::testing::TestInfo* const test_info =
117 ::testing::UnitTest::GetInstance()->current_test_info();
118 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
119 }
120
Ana Krulecafb45842019-02-13 13:33:03 -0800121 void setupScheduler() {
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700122 auto eventThread = std::make_unique<mock::EventThread>();
123 auto sfEventThread = std::make_unique<mock::EventThread>();
Ana Krulecafb45842019-02-13 13:33:03 -0800124
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700125 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
Dominik Laskowski98041832019-08-01 18:35:59 -0700126 EXPECT_CALL(*eventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -0700127 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
128 ResyncCallback())));
Dominik Laskowski98041832019-08-01 18:35:59 -0700129
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700130 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
Dominik Laskowski98041832019-08-01 18:35:59 -0700131 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -0700132 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
133 ResyncCallback())));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700134
Ady Abraham8cb21882020-08-26 18:22:05 -0700135 auto vsyncController = std::make_unique<mock::VsyncController>();
136 auto vsyncTracker = std::make_unique<mock::VSyncTracker>();
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700137
Ady Abraham8cb21882020-08-26 18:22:05 -0700138 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
139 EXPECT_CALL(*vsyncTracker, currentPeriod())
Marin Shalamanov045b7002021-01-07 16:56:24 +0100140 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Ady Abraham8cb21882020-08-26 18:22:05 -0700141 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700142
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700143 constexpr ISchedulerCallback* kCallback = nullptr;
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700144 constexpr bool kHasMultipleConfigs = true;
Ady Abraham8cb21882020-08-26 18:22:05 -0700145 mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
146 std::move(eventThread), std::move(sfEventThread), kCallback,
147 kHasMultipleConfigs);
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700148
149 // Layer history should be created if there are multiple configs.
150 ASSERT_TRUE(mFlinger.scheduler()->hasLayerHistory());
Ana Krulecafb45842019-02-13 13:33:03 -0800151 }
152
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700153 void setupForceGeometryDirty() {
154 // TODO: This requires the visible region and other related
155 // state to be set, and is problematic for BufferLayers since they are
156 // not visible without a buffer (and setting up a buffer looks like a
157 // pain)
158 // mFlinger.mutableVisibleRegionsDirty() = true;
159
160 mFlinger.mutableGeometryInvalid() = true;
161 }
162
163 template <typename Case>
164 void displayRefreshCompositionDirtyGeometry();
165
166 template <typename Case>
167 void displayRefreshCompositionDirtyFrame();
168
169 template <typename Case>
170 void captureScreenComposition();
171
Peiyong Line9d809e2020-04-14 13:10:48 -0700172 std::unordered_set<hal::Capability> mDefaultCapabilities = {hal::Capability::SIDEBAND_STREAM};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700173
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800174 bool mDisplayOff = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700175 TestableSurfaceFlinger mFlinger;
176 sp<DisplayDevice> mDisplay;
177 sp<DisplayDevice> mExternalDisplay;
Lloyd Pique542307f2018-10-19 13:24:08 -0700178 sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
179 new compositionengine::mock::DisplaySurface();
Alec Mouriba013fa2018-10-16 12:43:11 -0700180 mock::NativeWindow* mNativeWindow = new mock::NativeWindow();
Garfield Tande619fa2020-10-02 17:13:53 -0700181 std::vector<sp<Layer>> mAuxiliaryLayers;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700182
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800183 sp<GraphicBuffer> mBuffer = new GraphicBuffer();
184 ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();
185
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700186 Hwc2::mock::Composer* mComposer = nullptr;
187 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
Alec Mourie4034bb2019-11-19 12:45:54 -0800188 mock::TimeStats* mTimeStats = new mock::TimeStats();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700189 mock::MessageQueue* mMessageQueue = new mock::MessageQueue();
Lloyd Pique9370a482019-10-03 17:58:30 -0700190 Hwc2::mock::PowerAdvisor mPowerAdvisor;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700191
192 sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;
193
Alec Mouria90a5702021-04-16 16:36:21 +0000194 std::shared_ptr<renderengine::ExternalTexture> mCaptureScreenBuffer;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700195};
196
197template <typename LayerCase>
198void CompositionTest::displayRefreshCompositionDirtyGeometry() {
199 setupForceGeometryDirty();
200 LayerCase::setupForDirtyGeometry(this);
201
202 // --------------------------------------------------------------------
203 // Invocation
204
205 mFlinger.onMessageReceived(MessageQueue::INVALIDATE);
206 mFlinger.onMessageReceived(MessageQueue::REFRESH);
207
208 LayerCase::cleanup(this);
209}
210
211template <typename LayerCase>
212void CompositionTest::displayRefreshCompositionDirtyFrame() {
213 LayerCase::setupForDirtyFrame(this);
214
215 // --------------------------------------------------------------------
216 // Invocation
217
218 mFlinger.onMessageReceived(MessageQueue::INVALIDATE);
219 mFlinger.onMessageReceived(MessageQueue::REFRESH);
220
221 LayerCase::cleanup(this);
222}
223
224template <typename LayerCase>
225void CompositionTest::captureScreenComposition() {
226 LayerCase::setupForScreenCapture(this);
227
228 const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700229 constexpr bool forSystem = true;
Lucas Dupin9d763b72020-04-20 18:42:31 -0700230 constexpr bool regionSampling = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700231
Marin Shalamanov1c434292020-06-12 01:47:29 +0200232 auto renderArea = DisplayRenderArea::create(mDisplay, sourceCrop, sourceCrop.getSize(),
233 ui::Dataspace::V0_SRGB, ui::Transform::ROT_0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700234
235 auto traverseLayers = [this](const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700236 return mFlinger.traverseLayersInLayerStack(mDisplay->getLayerStack(),
237 CaptureArgs::UNSET_UID, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700238 };
239
240 // TODO: Eliminate expensive/real allocation if possible.
241 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
242 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Alec Mouria90a5702021-04-16 16:36:21 +0000243 mCaptureScreenBuffer = std::make_shared<
244 renderengine::ExternalTexture>(new GraphicBuffer(renderArea->getReqWidth(),
245 renderArea->getReqHeight(),
246 HAL_PIXEL_FORMAT_RGBA_8888, 1, usage,
247 "screenshot"),
248 *mRenderEngine, true);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700249
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700250 status_t result =
Alec Mouria90a5702021-04-16 16:36:21 +0000251 mFlinger.renderScreenImplLocked(*renderArea, traverseLayers, mCaptureScreenBuffer,
Ady Abraham99599942021-01-27 20:27:23 -0800252 forSystem, regionSampling);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700253 EXPECT_EQ(NO_ERROR, result);
254
255 LayerCase::cleanup(this);
256}
257
258/* ------------------------------------------------------------------------
259 * Variants for each display configuration which can be tested
260 */
261
262template <typename Derived>
263struct BaseDisplayVariant {
264 static constexpr bool IS_SECURE = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700265 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700266
267 static void setupPreconditions(CompositionTest* test) {
Peiyong Lin65248e02020-04-18 21:15:07 -0700268 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700269 .WillOnce(Return(Error::NONE));
Alec Mouriba013fa2018-10-16 12:43:11 -0700270
Peiyong Line9d809e2020-04-14 13:10:48 -0700271 FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700272 .setCapabilities(&test->mDefaultCapabilities)
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700273 .setPowerMode(Derived::INIT_POWER_MODE)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700274 .inject(&test->mFlinger, test->mComposer);
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800275 Mock::VerifyAndClear(test->mComposer);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700276
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800277 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
278 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
279 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
280 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
281 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
282 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
283 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
Lloyd Pique9370a482019-10-03 17:58:30 -0700284
285 const ::testing::TestInfo* const test_info =
286 ::testing::UnitTest::GetInstance()->current_test_info();
287
Dominik Laskowski13948602021-03-08 20:48:28 -0800288 auto ceDisplayArgs = compositionengine::DisplayCreationArgsBuilder()
289 .setId(DEFAULT_DISPLAY_ID)
290 .setConnectionType(ui::DisplayConnectionType::Internal)
291 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
292 .setIsSecure(Derived::IS_SECURE)
293 .setLayerStackId(DEFAULT_LAYER_STACK)
294 .setPowerAdvisor(&test->mPowerAdvisor)
295 .setName(std::string("Injected display for ") +
296 test_info->test_case_name() + "." + test_info->name())
297 .build();
Lloyd Pique9370a482019-10-03 17:58:30 -0700298
299 auto compositionDisplay =
300 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
301 ceDisplayArgs);
302
Marin Shalamanov700e6392020-02-12 20:22:26 +0100303 test->mDisplay = FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100304 ui::DisplayConnectionType::Internal, HWC_DISPLAY,
Marin Shalamanov700e6392020-02-12 20:22:26 +0100305 true /* isPrimary */)
306 .setDisplaySurface(test->mDisplaySurface)
307 .setNativeWindow(test->mNativeWindow)
308 .setSecure(Derived::IS_SECURE)
309 .setPowerMode(Derived::INIT_POWER_MODE)
310 .inject();
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800311 Mock::VerifyAndClear(test->mNativeWindow);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700312 test->mDisplay->setLayerStack(DEFAULT_LAYER_STACK);
313 }
314
315 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700316 static void setupPreconditionCallExpectations(CompositionTest* test) {
317 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))
318 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::DisplayCapability>({})),
319 Return(Error::NONE)));
320 }
321
322 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700323 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
324 EXPECT_CALL(*test->mComposer,
325 setColorTransform(HWC_DISPLAY, _, Hwc2::ColorTransform::IDENTITY))
326 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700327 EXPECT_CALL(*test->mComposer, getDisplayRequests(HWC_DISPLAY, _, _, _)).Times(1);
328 EXPECT_CALL(*test->mComposer, acceptDisplayChanges(HWC_DISPLAY)).Times(1);
329 EXPECT_CALL(*test->mComposer, presentDisplay(HWC_DISPLAY, _)).Times(1);
330 EXPECT_CALL(*test->mComposer, getReleaseFences(HWC_DISPLAY, _, _)).Times(1);
331
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700332 EXPECT_CALL(*test->mDisplaySurface, onFrameCommitted()).Times(1);
333 EXPECT_CALL(*test->mDisplaySurface, advanceFrame()).Times(1);
334
335 Case::CompositionType::setupHwcSetCallExpectations(test);
336 Case::CompositionType::setupHwcGetCallExpectations(test);
337 }
338
339 template <typename Case>
340 static void setupCommonScreensCaptureCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000341 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Lloyd Pique9370a482019-10-03 17:58:30 -0700342 .WillRepeatedly([](const renderengine::DisplaySettings& displaySettings,
343 const std::vector<const renderengine::LayerSettings*>&,
Alec Mouria90a5702021-04-16 16:36:21 +0000344 const std::shared_ptr<renderengine::ExternalTexture>&,
345 const bool, base::unique_fd&&, base::unique_fd*) -> status_t {
Lloyd Pique9370a482019-10-03 17:58:30 -0700346 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
347 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
348 displaySettings.physicalDisplay);
349 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
350 displaySettings.clip);
351 return NO_ERROR;
352 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700353 }
354
355 static void setupNonEmptyFrameCompositionCallExpectations(CompositionTest* test) {
356 EXPECT_CALL(*test->mDisplaySurface, beginFrame(true)).Times(1);
357 }
358
359 static void setupEmptyFrameCompositionCallExpectations(CompositionTest* test) {
360 EXPECT_CALL(*test->mDisplaySurface, beginFrame(false)).Times(1);
361 }
362
363 static void setupHwcCompositionCallExpectations(CompositionTest* test) {
Lloyd Pique66d68602019-02-13 14:23:31 -0800364 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _)).Times(1);
365
Lloyd Pique542307f2018-10-19 13:24:08 -0700366 EXPECT_CALL(*test->mDisplaySurface,
367 prepareFrame(compositionengine::DisplaySurface::COMPOSITION_HWC))
368 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700369 }
370
Lloyd Pique66d68602019-02-13 14:23:31 -0800371 static void setupHwcClientCompositionCallExpectations(CompositionTest* test) {
372 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _)).Times(1);
373 }
374
375 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
376 EXPECT_CALL(*test->mComposer, validateDisplay(HWC_DISPLAY, _, _)).Times(1);
377 }
378
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700379 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Pique542307f2018-10-19 13:24:08 -0700380 EXPECT_CALL(*test->mDisplaySurface,
Peiyong Linf3ffc4e2019-12-13 00:46:24 -0800381 prepareFrame(compositionengine::DisplaySurface::COMPOSITION_GPU))
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700382 .Times(1);
383 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
384 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
385
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800386 EXPECT_CALL(*test->mNativeWindow, queueBuffer(_, _)).WillOnce(Return(0));
387 EXPECT_CALL(*test->mNativeWindow, dequeueBuffer(_, _))
388 .WillOnce(DoAll(SetArgPointee<0>(test->mNativeWindowBuffer), SetArgPointee<1>(-1),
389 Return(0)));
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000390 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Lloyd Pique9370a482019-10-03 17:58:30 -0700391 .WillRepeatedly([](const renderengine::DisplaySettings& displaySettings,
392 const std::vector<const renderengine::LayerSettings*>&,
Alec Mouria90a5702021-04-16 16:36:21 +0000393 const std::shared_ptr<renderengine::ExternalTexture>&,
394 const bool, base::unique_fd&&, base::unique_fd*) -> status_t {
Lloyd Pique9370a482019-10-03 17:58:30 -0700395 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
396 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
397 displaySettings.physicalDisplay);
398 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
399 displaySettings.clip);
400 EXPECT_EQ(ui::Dataspace::UNKNOWN, displaySettings.outputDataspace);
401 return NO_ERROR;
402 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700403 }
404
405 template <typename Case>
406 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
407 Case::Layer::setupRECompositionCallExpectations(test);
408 }
409
410 template <typename Case>
411 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
412 Case::Layer::setupREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700413 }
414};
415
416struct DefaultDisplaySetupVariant : public BaseDisplayVariant<DefaultDisplaySetupVariant> {};
417
418struct InsecureDisplaySetupVariant : public BaseDisplayVariant<InsecureDisplaySetupVariant> {
419 static constexpr bool IS_SECURE = false;
420
421 template <typename Case>
422 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
423 Case::Layer::setupInsecureRECompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700424 }
425
426 template <typename Case>
427 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
428 Case::Layer::setupInsecureREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700429 }
430};
431
432struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDisplaySetupVariant> {
Peiyong Lin65248e02020-04-18 21:15:07 -0700433 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::OFF;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700434
435 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700436 static void setupPreconditionCallExpectations(CompositionTest*) {}
437
438 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700439 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
440 // TODO: This seems like an unnecessary call if display is powered off.
441 EXPECT_CALL(*test->mComposer,
442 setColorTransform(HWC_DISPLAY, _, Hwc2::ColorTransform::IDENTITY))
443 .Times(1);
444
445 // TODO: This seems like an unnecessary call if display is powered off.
446 Case::CompositionType::setupHwcSetCallExpectations(test);
447 }
448
449 static void setupHwcCompositionCallExpectations(CompositionTest*) {}
Lloyd Pique66d68602019-02-13 14:23:31 -0800450 static void setupHwcClientCompositionCallExpectations(CompositionTest*) {}
451 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest*) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700452
453 static void setupRECompositionCallExpectations(CompositionTest* test) {
454 // TODO: This seems like an unnecessary call if display is powered off.
455 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
456 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
457 }
458
459 template <typename Case>
460 static void setupRELayerCompositionCallExpectations(CompositionTest*) {}
461};
462
463/* ------------------------------------------------------------------------
464 * Variants for each layer configuration which can be tested
465 */
466
467template <typename LayerProperties>
468struct BaseLayerProperties {
469 static constexpr uint32_t WIDTH = 100;
470 static constexpr uint32_t HEIGHT = 100;
471 static constexpr PixelFormat FORMAT = PIXEL_FORMAT_RGBA_8888;
472 static constexpr uint64_t USAGE =
473 GraphicBuffer::USAGE_SW_READ_NEVER | GraphicBuffer::USAGE_SW_WRITE_NEVER;
474 static constexpr android_dataspace DATASPACE = HAL_DATASPACE_UNKNOWN;
475 static constexpr uint32_t SCALING_MODE = 0;
476 static constexpr uint32_t TRANSFORM = 0;
477 static constexpr uint32_t LAYER_FLAGS = 0;
478 static constexpr float COLOR[] = {1.f, 1.f, 1.f, 1.f};
479 static constexpr IComposerClient::BlendMode BLENDMODE =
480 IComposerClient::BlendMode::PREMULTIPLIED;
481
482 static void enqueueBuffer(CompositionTest*, sp<BufferQueueLayer> layer) {
483 auto producer = layer->getProducer();
484
485 IGraphicBufferProducer::QueueBufferOutput qbo;
486 status_t result = producer->connect(nullptr, NATIVE_WINDOW_API_EGL, false, &qbo);
487 if (result != NO_ERROR) {
488 ALOGE("Failed to connect() (%d)", result);
489 return;
490 }
491
492 int slot;
493 sp<Fence> fence;
494 result = producer->dequeueBuffer(&slot, &fence, LayerProperties::WIDTH,
495 LayerProperties::HEIGHT, LayerProperties::FORMAT,
496 LayerProperties::USAGE, nullptr, nullptr);
497 if (result != IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) {
498 ALOGE("Failed to dequeueBuffer() (%d)", result);
499 return;
500 }
501
502 sp<GraphicBuffer> buffer;
503 result = producer->requestBuffer(slot, &buffer);
504 if (result != NO_ERROR) {
505 ALOGE("Failed to requestBuffer() (%d)", result);
506 return;
507 }
508
509 IGraphicBufferProducer::QueueBufferInput qbi(systemTime(), false /* isAutoTimestamp */,
510 LayerProperties::DATASPACE,
511 Rect(LayerProperties::WIDTH,
512 LayerProperties::HEIGHT),
513 LayerProperties::SCALING_MODE,
514 LayerProperties::TRANSFORM, Fence::NO_FENCE);
515 result = producer->queueBuffer(slot, qbi, &qbo);
516 if (result != NO_ERROR) {
517 ALOGE("Failed to queueBuffer (%d)", result);
518 return;
519 }
520 }
521
522 static void setupLatchedBuffer(CompositionTest* test, sp<BufferQueueLayer> layer) {
523 // TODO: Eliminate the complexity of actually creating a buffer
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700524 status_t err =
525 layer->setDefaultBufferProperties(LayerProperties::WIDTH, LayerProperties::HEIGHT,
526 LayerProperties::FORMAT);
527 ASSERT_EQ(NO_ERROR, err);
528 Mock::VerifyAndClear(test->mRenderEngine);
529
530 EXPECT_CALL(*test->mMessageQueue, invalidate()).Times(1);
531 enqueueBuffer(test, layer);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700532 Mock::VerifyAndClearExpectations(test->mMessageQueue);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700533
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700534 bool ignoredRecomputeVisibleRegions;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700535 layer->latchBuffer(ignoredRecomputeVisibleRegions, 0, 0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700536 Mock::VerifyAndClear(test->mRenderEngine);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700537 }
538
539 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
540 setupLatchedBuffer(test, layer);
541 }
542
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700543 static void setupHwcSetGeometryCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800544 if (!test->mDisplayOff) {
545 // TODO: Coverage of other values
546 EXPECT_CALL(*test->mComposer,
547 setLayerBlendMode(HWC_DISPLAY, HWC_LAYER, LayerProperties::BLENDMODE))
548 .Times(1);
549 // TODO: Coverage of other values for origin
550 EXPECT_CALL(*test->mComposer,
551 setLayerDisplayFrame(HWC_DISPLAY, HWC_LAYER,
552 IComposerClient::Rect({0, 0, LayerProperties::WIDTH,
553 LayerProperties::HEIGHT})))
554 .Times(1);
555 EXPECT_CALL(*test->mComposer,
556 setLayerPlaneAlpha(HWC_DISPLAY, HWC_LAYER, LayerProperties::COLOR[3]))
557 .Times(1);
558 // TODO: Coverage of other values
559 EXPECT_CALL(*test->mComposer, setLayerZOrder(HWC_DISPLAY, HWC_LAYER, 0u)).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700560
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800561 // These expectations retire on saturation as the code path these
562 // expectations are for appears to make an extra call to them.
563 // TODO: Investigate this extra call
564 EXPECT_CALL(*test->mComposer,
565 setLayerTransform(HWC_DISPLAY, HWC_LAYER, DEFAULT_TRANSFORM))
566 .Times(AtLeast(1))
567 .RetiresOnSaturation();
568 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700569 }
570
571 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800572 if (!test->mDisplayOff) {
573 EXPECT_CALL(*test->mComposer,
574 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
575 IComposerClient::FRect({0.f, 0.f, LayerProperties::WIDTH,
576 LayerProperties::HEIGHT})))
577 .Times(1);
578 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700579 }
580
581 static void setupHwcSetSourceCropColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800582 if (!test->mDisplayOff) {
583 EXPECT_CALL(*test->mComposer,
584 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
585 IComposerClient::FRect({0.f, 0.f, 0.f, 0.f})))
586 .Times(1);
587 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700588 }
589
590 static void setupHwcSetPerFrameCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800591 if (!test->mDisplayOff) {
592 EXPECT_CALL(*test->mComposer,
593 setLayerVisibleRegion(HWC_DISPLAY, HWC_LAYER,
594 std::vector<IComposerClient::Rect>(
595 {IComposerClient::Rect(
596 {0, 0, LayerProperties::WIDTH,
597 LayerProperties::HEIGHT})})))
598 .Times(1);
599 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700600 }
601
602 static void setupHwcSetPerFrameColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800603 if (!test->mDisplayOff) {
604 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
605 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700606
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800607 // TODO: use COLOR
608 EXPECT_CALL(*test->mComposer,
609 setLayerColor(HWC_DISPLAY, HWC_LAYER,
610 IComposerClient::Color({0xff, 0xff, 0xff, 0xff})))
611 .Times(1);
612 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700613 }
614
615 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800616 if (!test->mDisplayOff) {
617 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
618 .Times(1);
619 EXPECT_CALL(*test->mComposer, setLayerBuffer(HWC_DISPLAY, HWC_LAYER, _, _, _)).Times(1);
620 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700621 }
622
623 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000624 EXPECT_CALL(*test->mRenderEngine, drawLayers)
625 .WillOnce([](const renderengine::DisplaySettings& displaySettings,
Vishnu Nair9b079a22020-01-21 14:36:08 -0800626 const std::vector<const renderengine::LayerSettings*>& layerSettings,
Alec Mouria90a5702021-04-16 16:36:21 +0000627 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
628 base::unique_fd&&, base::unique_fd*) -> status_t {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000629 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
630 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
631 displaySettings.physicalDisplay);
632 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
633 displaySettings.clip);
634 // screen capture adds an additional color layer as an alpha
635 // prefill, so gtet the back layer.
Lloyd Piquea2468662019-03-07 21:31:06 -0800636 if (layerSettings.empty()) {
637 ADD_FAILURE() << "layerSettings was not expected to be empty in "
638 "setupREBufferCompositionCommonCallExpectations "
639 "verification lambda";
640 return NO_ERROR;
641 }
Vishnu Nair9b079a22020-01-21 14:36:08 -0800642 const renderengine::LayerSettings* layer = layerSettings.back();
643 EXPECT_THAT(layer->source.buffer.buffer, Not(IsNull()));
644 EXPECT_THAT(layer->source.buffer.fence, Not(IsNull()));
645 EXPECT_EQ(DEFAULT_TEXTURE_ID, layer->source.buffer.textureName);
646 EXPECT_EQ(false, layer->source.buffer.isY410BT2020);
647 EXPECT_EQ(true, layer->source.buffer.usePremultipliedAlpha);
648 EXPECT_EQ(false, layer->source.buffer.isOpaque);
649 EXPECT_EQ(0.0, layer->geometry.roundedCornersRadius);
650 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer->sourceDataspace);
651 EXPECT_EQ(LayerProperties::COLOR[3], layer->alpha);
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000652 return NO_ERROR;
653 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700654 }
655
656 static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
657 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700658 }
659
660 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
661 setupREBufferCompositionCallExpectations(test);
662 }
663
664 static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
665 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
666 }
667
668 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
669 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
670 }
671
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700672 static void setupREColorCompositionCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000673 EXPECT_CALL(*test->mRenderEngine, drawLayers)
674 .WillOnce([](const renderengine::DisplaySettings& displaySettings,
Vishnu Nair9b079a22020-01-21 14:36:08 -0800675 const std::vector<const renderengine::LayerSettings*>& layerSettings,
Alec Mouria90a5702021-04-16 16:36:21 +0000676 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
677 base::unique_fd&&, base::unique_fd*) -> status_t {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000678 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
679 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
680 displaySettings.physicalDisplay);
681 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
682 displaySettings.clip);
683 // screen capture adds an additional color layer as an alpha
684 // prefill, so get the back layer.
Lloyd Piquea2468662019-03-07 21:31:06 -0800685 if (layerSettings.empty()) {
686 ADD_FAILURE()
687 << "layerSettings was not expected to be empty in "
688 "setupREColorCompositionCallExpectations verification lambda";
689 return NO_ERROR;
690 }
Vishnu Nair9b079a22020-01-21 14:36:08 -0800691 const renderengine::LayerSettings* layer = layerSettings.back();
692 EXPECT_THAT(layer->source.buffer.buffer, IsNull());
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000693 EXPECT_EQ(half3(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
694 LayerProperties::COLOR[2]),
Vishnu Nair9b079a22020-01-21 14:36:08 -0800695 layer->source.solidColor);
696 EXPECT_EQ(0.0, layer->geometry.roundedCornersRadius);
697 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer->sourceDataspace);
698 EXPECT_EQ(LayerProperties::COLOR[3], layer->alpha);
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000699 return NO_ERROR;
700 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700701 }
702
703 static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
704 setupREColorCompositionCallExpectations(test);
705 }
706};
707
708struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
709
Vishnu Nairfa247b12020-02-11 08:58:26 -0800710struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
Alec Mourida8a9d12020-01-30 20:00:31 -0800711 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
712};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700713
714struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
715 using Base = BaseLayerProperties<SidebandLayerProperties>;
716 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
717
718 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
719 sp<NativeHandle> stream =
720 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
721 false);
722 test->mFlinger.setLayerSidebandStream(layer, stream);
723 }
724
725 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
726 EXPECT_CALL(*test->mComposer,
727 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
728 IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
729 .Times(1);
730 }
731
732 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
733 EXPECT_CALL(*test->mComposer,
734 setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
735 reinterpret_cast<native_handle_t*>(
736 DEFAULT_SIDEBAND_STREAM)))
737 .WillOnce(Return(Error::NONE));
738
739 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
740 }
741
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000742 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700743};
744
Garfield Tande619fa2020-10-02 17:13:53 -0700745template <typename LayerProperties>
746struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
747 using Base = BaseLayerProperties<LayerProperties>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700748
749 static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000750 EXPECT_CALL(*test->mRenderEngine, drawLayers)
751 .WillOnce([](const renderengine::DisplaySettings& displaySettings,
Vishnu Nair9b079a22020-01-21 14:36:08 -0800752 const std::vector<const renderengine::LayerSettings*>& layerSettings,
Alec Mouria90a5702021-04-16 16:36:21 +0000753 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
754 base::unique_fd&&, base::unique_fd*) -> status_t {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000755 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
756 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
757 displaySettings.physicalDisplay);
758 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
759 displaySettings.clip);
760 // screen capture adds an additional color layer as an alpha
761 // prefill, so get the back layer.
Lloyd Piquea2468662019-03-07 21:31:06 -0800762 if (layerSettings.empty()) {
763 ADD_FAILURE() << "layerSettings was not expected to be empty in "
764 "setupInsecureREBufferCompositionCommonCallExpectations "
765 "verification lambda";
766 return NO_ERROR;
767 }
Vishnu Nair9b079a22020-01-21 14:36:08 -0800768 const renderengine::LayerSettings* layer = layerSettings.back();
769 EXPECT_THAT(layer->source.buffer.buffer, IsNull());
770 EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer->source.solidColor);
771 EXPECT_EQ(0.0, layer->geometry.roundedCornersRadius);
772 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer->sourceDataspace);
773 EXPECT_EQ(1.0f, layer->alpha);
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000774 return NO_ERROR;
775 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700776 }
777
778 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
779 setupInsecureREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700780 }
781
782 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
783 setupInsecureREBufferCompositionCommonCallExpectations(test);
784 }
785};
786
Garfield Tande619fa2020-10-02 17:13:53 -0700787struct ParentSecureLayerProperties
788 : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
789
790struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
791 static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
792};
793
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700794struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
795 using Base = BaseLayerProperties<CursorLayerProperties>;
796
797 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
798 Base::setupLayerState(test, layer);
799 test->mFlinger.setLayerPotentialCursor(layer, true);
800 }
801};
802
803struct NoLayerVariant {
804 using FlingerLayerType = sp<BufferQueueLayer>;
805
806 static FlingerLayerType createLayer(CompositionTest*) { return FlingerLayerType(); }
807 static void injectLayer(CompositionTest*, FlingerLayerType) {}
808 static void cleanupInjectedLayers(CompositionTest*) {}
809
810 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
811 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
812};
813
814template <typename LayerProperties>
815struct BaseLayerVariant {
816 template <typename L, typename F>
817 static sp<L> createLayerWithFactory(CompositionTest* test, F factory) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700818 EXPECT_CALL(*test->mMessageQueue, postMessage(_)).Times(0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700819
820 sp<L> layer = factory();
821
Dominik Laskowski49cea512019-11-12 14:13:23 -0800822 // Layer should be registered with scheduler.
823 EXPECT_EQ(1, test->mFlinger.scheduler()->layerHistorySize());
824
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700825 Mock::VerifyAndClear(test->mComposer);
826 Mock::VerifyAndClear(test->mRenderEngine);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700827 Mock::VerifyAndClearExpectations(test->mMessageQueue);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700828
Garfield Tande619fa2020-10-02 17:13:53 -0700829 initLayerDrawingStateAndComputeBounds(test, layer);
830
831 return layer;
832 }
833
834 template <typename L>
835 static void initLayerDrawingStateAndComputeBounds(CompositionTest* test, sp<L> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700836 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
837 layerDrawingState.layerStack = DEFAULT_LAYER_STACK;
chaviw766c9c52021-02-10 17:36:47 -0800838 layerDrawingState.width = 100;
839 layerDrawingState.height = 100;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700840 layerDrawingState.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
841 LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700842 layer->computeBounds(FloatRect(0, 0, 100, 100), ui::Transform(), 0.f /* shadowRadius */);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700843 }
844
845 static void injectLayer(CompositionTest* test, sp<Layer> layer) {
846 EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
847 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
848
Lloyd Piquede196652020-01-22 17:29:58 -0800849 auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
850 layer->getCompositionEngineLayerFE());
Lloyd Pique01c77c12019-04-17 12:48:32 -0700851 outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
852 outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700853
854 Mock::VerifyAndClear(test->mComposer);
855
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700856 test->mFlinger.mutableDrawingState().layersSortedByZ.add(layer);
857 }
858
859 static void cleanupInjectedLayers(CompositionTest* test) {
860 EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
861 .WillOnce(Return(Error::NONE));
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800862
Lloyd Pique01c77c12019-04-17 12:48:32 -0700863 test->mDisplay->getCompositionDisplay()->clearOutputLayers();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700864 test->mFlinger.mutableDrawingState().layersSortedByZ.clear();
Dominik Laskowski49cea512019-11-12 14:13:23 -0800865
866 // Layer should be unregistered with scheduler.
867 test->mFlinger.onMessageReceived(MessageQueue::INVALIDATE);
868 EXPECT_EQ(0, test->mFlinger.scheduler()->layerHistorySize());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700869 }
870};
871
872template <typename LayerProperties>
Vishnu Nairfa247b12020-02-11 08:58:26 -0800873struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700874 using Base = BaseLayerVariant<LayerProperties>;
Vishnu Nairfa247b12020-02-11 08:58:26 -0800875 using FlingerLayerType = sp<EffectLayer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700876
877 static FlingerLayerType createLayer(CompositionTest* test) {
Vishnu Nairfa247b12020-02-11 08:58:26 -0800878 FlingerLayerType layer = Base::template createLayerWithFactory<EffectLayer>(test, [test]() {
879 return new EffectLayer(
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700880 LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Vishnu Nairfa247b12020-02-11 08:58:26 -0800881 LayerProperties::WIDTH, LayerProperties::HEIGHT,
882 LayerProperties::LAYER_FLAGS, LayerMetadata()));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700883 });
Vishnu Nair60356342018-11-13 13:00:45 -0800884
885 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
chaviw25714502021-02-11 10:01:08 -0800886 layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700887 return layer;
888 }
889
890 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700891 LayerProperties::setupREColorCompositionCallExpectations(test);
892 }
893
894 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
895 LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
896 }
897
898 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
899 LayerProperties::setupHwcSetGeometryCallExpectations(test);
900 LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
901 }
902
903 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
904 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
905 LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
906 }
907};
908
909template <typename LayerProperties>
910struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
911 using Base = BaseLayerVariant<LayerProperties>;
912 using FlingerLayerType = sp<BufferQueueLayer>;
913
914 static FlingerLayerType createLayer(CompositionTest* test) {
915 test->mFlinger.mutableTexturePool().push_back(DEFAULT_TEXTURE_ID);
916
917 FlingerLayerType layer =
918 Base::template createLayerWithFactory<BufferQueueLayer>(test, [test]() {
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700919 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700920 LayerProperties::WIDTH, LayerProperties::HEIGHT,
921 LayerProperties::LAYER_FLAGS, LayerMetadata());
chaviwb4c6e582019-08-16 14:35:07 -0700922 args.textureName = test->mFlinger.mutableTexturePool().back();
923 return new BufferQueueLayer(args);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700924 });
925
926 LayerProperties::setupLayerState(test, layer);
927
928 return layer;
929 }
930
931 static void cleanupInjectedLayers(CompositionTest* test) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700932 EXPECT_CALL(*test->mMessageQueue, postMessage(_)).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700933 Base::cleanupInjectedLayers(test);
934 }
935
936 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
937 LayerProperties::setupHwcSetGeometryCallExpectations(test);
938 LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
939 }
940
941 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
942 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
943 LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
944 }
945
946 static void setupRECompositionCallExpectations(CompositionTest* test) {
947 LayerProperties::setupREBufferCompositionCallExpectations(test);
948 }
949
950 static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
951 LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
952 }
953
954 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
955 LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
956 }
957
958 static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
959 LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
960 }
961};
962
Garfield Tande619fa2020-10-02 17:13:53 -0700963template <typename LayerProperties>
964struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
965 using Base = BaseLayerVariant<LayerProperties>;
966 using FlingerLayerType = sp<ContainerLayer>;
967
968 static FlingerLayerType createLayer(CompositionTest* test) {
969 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
970 LayerProperties::WIDTH, LayerProperties::HEIGHT,
971 LayerProperties::LAYER_FLAGS, LayerMetadata());
972 FlingerLayerType layer = new ContainerLayer(args);
973 Base::template initLayerDrawingStateAndComputeBounds(test, layer);
974 return layer;
975 }
976};
977
978template <typename LayerVariant, typename ParentLayerVariant>
979struct ChildLayerVariant : public LayerVariant {
980 using Base = LayerVariant;
981 using FlingerLayerType = typename LayerVariant::FlingerLayerType;
982 using ParentBase = ParentLayerVariant;
983
984 static FlingerLayerType createLayer(CompositionTest* test) {
985 // Need to create child layer first. Otherwise layer history size will be 2.
986 FlingerLayerType layer = Base::createLayer(test);
987
988 typename ParentBase::FlingerLayerType parentLayer = ParentBase::createLayer(test);
989 parentLayer->addChild(layer);
990 test->mFlinger.setLayerDrawingParent(layer, parentLayer);
991
992 test->mAuxiliaryLayers.push_back(parentLayer);
993
994 return layer;
995 }
996
997 static void cleanupInjectedLayers(CompositionTest* test) {
998 // Clear auxiliary layers first so that child layer can be successfully destroyed in the
999 // following call.
1000 test->mAuxiliaryLayers.clear();
1001
1002 Base::cleanupInjectedLayers(test);
1003 }
1004};
1005
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001006/* ------------------------------------------------------------------------
1007 * Variants to control how the composition type is changed
1008 */
1009
1010struct NoCompositionTypeVariant {
1011 static void setupHwcSetCallExpectations(CompositionTest*) {}
1012
1013 static void setupHwcGetCallExpectations(CompositionTest* test) {
1014 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1015 }
1016};
1017
1018template <IComposerClient::Composition CompositionType>
1019struct KeepCompositionTypeVariant {
Peiyong Line9d809e2020-04-14 13:10:48 -07001020 static constexpr hal::Composition TYPE = CompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001021
1022 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001023 if (!test->mDisplayOff) {
1024 EXPECT_CALL(*test->mComposer,
1025 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
1026 .Times(1);
1027 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001028 }
1029
1030 static void setupHwcGetCallExpectations(CompositionTest* test) {
1031 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1032 }
1033};
1034
1035template <IComposerClient::Composition InitialCompositionType,
1036 IComposerClient::Composition FinalCompositionType>
1037struct ChangeCompositionTypeVariant {
Peiyong Line9d809e2020-04-14 13:10:48 -07001038 static constexpr hal::Composition TYPE = FinalCompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001039
1040 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001041 if (!test->mDisplayOff) {
1042 EXPECT_CALL(*test->mComposer,
1043 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
1044 .Times(1);
1045 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001046 }
1047
1048 static void setupHwcGetCallExpectations(CompositionTest* test) {
1049 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
1050 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
1051 static_cast<Hwc2::Layer>(HWC_LAYER)}),
1052 SetArgPointee<2>(std::vector<IComposerClient::Composition>{
1053 FinalCompositionType}),
1054 Return(Error::NONE)));
1055 }
1056};
1057
1058/* ------------------------------------------------------------------------
1059 * Variants to select how the composition is expected to be handled
1060 */
1061
1062struct CompositionResultBaseVariant {
1063 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1064
1065 template <typename Case>
1066 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
1067 Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1068 }
1069
1070 template <typename Case>
1071 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1072 Case::Layer::setupCallExpectationsForDirtyFrame(test);
1073 }
1074};
1075
1076struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1077 template <typename Case>
1078 static void setupCallExpectations(CompositionTest* test) {
1079 Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1080 Case::Display::setupHwcCompositionCallExpectations(test);
1081 }
1082};
1083
1084struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1085 template <typename Case>
1086 static void setupCallExpectations(CompositionTest* test) {
1087 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1088 Case::Display::setupHwcCompositionCallExpectations(test);
1089 }
1090};
1091
1092struct RECompositionResultVariant : public CompositionResultBaseVariant {
1093 template <typename Case>
1094 static void setupCallExpectations(CompositionTest* test) {
1095 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
Lloyd Pique66d68602019-02-13 14:23:31 -08001096 Case::Display::setupHwcClientCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001097 Case::Display::setupRECompositionCallExpectations(test);
1098 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1099 }
1100};
1101
Lloyd Pique66d68602019-02-13 14:23:31 -08001102struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001103 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001104 const auto outputLayer =
1105 TestableSurfaceFlinger::findOutputLayerForDisplay(layer, test->mDisplay);
Lloyd Piquef5275482019-01-29 18:42:42 -08001106 LOG_FATAL_IF(!outputLayer);
1107 outputLayer->editState().forceClientComposition = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001108 }
1109
1110 template <typename Case>
Lloyd Pique66d68602019-02-13 14:23:31 -08001111 static void setupCallExpectations(CompositionTest* test) {
1112 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1113 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1114 Case::Display::setupRECompositionCallExpectations(test);
1115 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1116 }
1117
1118 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001119 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1120
1121 template <typename Case>
1122 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1123};
1124
Lloyd Pique4fe29402019-08-12 16:51:24 -07001125struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
1126 static void setupLayerState(CompositionTest* test, sp<Layer>) {
1127 test->mFlinger.mutableDebugDisableHWC() = true;
1128 }
1129
1130 template <typename Case>
1131 static void setupCallExpectations(CompositionTest* test) {
1132 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1133 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1134 Case::Display::setupRECompositionCallExpectations(test);
1135 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1136 }
1137
1138 template <typename Case>
1139 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1140
1141 template <typename Case>
1142 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1143};
1144
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001145struct EmptyScreenshotResultVariant {
1146 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1147
1148 template <typename Case>
1149 static void setupCallExpectations(CompositionTest*) {}
1150};
1151
1152struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1153 using Base = EmptyScreenshotResultVariant;
1154
1155 template <typename Case>
1156 static void setupCallExpectations(CompositionTest* test) {
1157 Base::template setupCallExpectations<Case>(test);
1158 Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1159 }
1160};
1161
1162/* ------------------------------------------------------------------------
1163 * Composition test case, containing all the variants being tested
1164 */
1165
1166template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1167 typename CompositionResultCase>
1168struct CompositionCase {
1169 using ThisCase =
1170 CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1171 using Display = DisplayCase;
1172 using Layer = LayerCase;
1173 using CompositionType = CompositionTypeCase;
1174 using CompositionResult = CompositionResultCase;
1175
1176 static void setupCommon(CompositionTest* test) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -07001177 Display::template setupPreconditionCallExpectations<ThisCase>(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001178 Display::setupPreconditions(test);
1179
1180 auto layer = Layer::createLayer(test);
1181 Layer::injectLayer(test, layer);
1182 CompositionResult::setupLayerState(test, layer);
1183 }
1184
1185 static void setupForDirtyGeometry(CompositionTest* test) {
1186 setupCommon(test);
1187
1188 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1189 CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1190 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1191 CompositionResult::template setupCallExpectations<ThisCase>(test);
1192 }
1193
1194 static void setupForDirtyFrame(CompositionTest* test) {
1195 setupCommon(test);
1196
1197 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1198 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1199 CompositionResult::template setupCallExpectations<ThisCase>(test);
1200 }
1201
1202 static void setupForScreenCapture(CompositionTest* test) {
1203 setupCommon(test);
1204
1205 Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1206 CompositionResult::template setupCallExpectations<ThisCase>(test);
1207 }
1208
1209 static void cleanup(CompositionTest* test) {
1210 Layer::cleanupInjectedLayers(test);
1211
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001212 for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1213 static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1214 ->mutableLayers()
1215 .clear();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001216 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001217 }
1218};
1219
1220/* ------------------------------------------------------------------------
1221 * Composition cases to test
1222 */
1223
1224TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1225 displayRefreshCompositionDirtyGeometry<
1226 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1227 NoCompositionResultVariant>>();
1228}
1229
1230TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1231 displayRefreshCompositionDirtyFrame<
1232 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1233 NoCompositionResultVariant>>();
1234}
1235
1236TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1237 captureScreenComposition<
1238 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1239 EmptyScreenshotResultVariant>>();
1240}
1241
1242/* ------------------------------------------------------------------------
1243 * Simple buffer layers
1244 */
1245
1246TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
1247 displayRefreshCompositionDirtyGeometry<
1248 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1249 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1250 HwcCompositionResultVariant>>();
1251}
1252
1253TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
1254 displayRefreshCompositionDirtyFrame<
1255 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1256 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1257 HwcCompositionResultVariant>>();
1258}
1259
1260TEST_F(CompositionTest, REComposedNormalBufferLayer) {
1261 displayRefreshCompositionDirtyFrame<
1262 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1263 ChangeCompositionTypeVariant<IComposerClient::Composition::DEVICE,
1264 IComposerClient::Composition::CLIENT>,
1265 RECompositionResultVariant>>();
1266}
1267
1268TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1269 captureScreenComposition<
1270 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1271 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1272}
1273
1274/* ------------------------------------------------------------------------
1275 * Single-color layers
1276 */
1277
Vishnu Nairfa247b12020-02-11 08:58:26 -08001278TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001279 displayRefreshCompositionDirtyGeometry<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001280 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001281 KeepCompositionTypeVariant<IComposerClient::Composition::SOLID_COLOR>,
1282 HwcCompositionResultVariant>>();
1283}
1284
Vishnu Nairfa247b12020-02-11 08:58:26 -08001285TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001286 displayRefreshCompositionDirtyFrame<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001287 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001288 KeepCompositionTypeVariant<IComposerClient::Composition::SOLID_COLOR>,
1289 HwcCompositionResultVariant>>();
1290}
1291
Vishnu Nairfa247b12020-02-11 08:58:26 -08001292TEST_F(CompositionTest, REComposedEffectLayer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001293 displayRefreshCompositionDirtyFrame<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001294 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001295 ChangeCompositionTypeVariant<IComposerClient::Composition::SOLID_COLOR,
1296 IComposerClient::Composition::CLIENT>,
1297 RECompositionResultVariant>>();
1298}
1299
Vishnu Nairfa247b12020-02-11 08:58:26 -08001300TEST_F(CompositionTest, captureScreenEffectLayer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001301 captureScreenComposition<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001302 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001303 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1304}
1305
1306/* ------------------------------------------------------------------------
1307 * Layers with sideband buffers
1308 */
1309
1310TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
1311 displayRefreshCompositionDirtyGeometry<
1312 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1313 KeepCompositionTypeVariant<IComposerClient::Composition::SIDEBAND>,
1314 HwcCompositionResultVariant>>();
1315}
1316
1317TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
1318 displayRefreshCompositionDirtyFrame<
1319 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1320 KeepCompositionTypeVariant<IComposerClient::Composition::SIDEBAND>,
1321 HwcCompositionResultVariant>>();
1322}
1323
1324TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
1325 displayRefreshCompositionDirtyFrame<
1326 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1327 ChangeCompositionTypeVariant<IComposerClient::Composition::SIDEBAND,
1328 IComposerClient::Composition::CLIENT>,
1329 RECompositionResultVariant>>();
1330}
1331
1332TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1333 captureScreenComposition<
1334 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1335 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1336}
1337
1338/* ------------------------------------------------------------------------
1339 * Layers with ISurfaceComposerClient::eSecure, on a secure display
1340 */
1341
1342TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
1343 displayRefreshCompositionDirtyGeometry<
1344 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1345 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1346 HwcCompositionResultVariant>>();
1347}
1348
1349TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
1350 displayRefreshCompositionDirtyFrame<
1351 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1352 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1353 HwcCompositionResultVariant>>();
1354}
1355
1356TEST_F(CompositionTest, REComposedSecureBufferLayer) {
1357 displayRefreshCompositionDirtyFrame<
1358 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1359 ChangeCompositionTypeVariant<IComposerClient::Composition::DEVICE,
1360 IComposerClient::Composition::CLIENT>,
1361 RECompositionResultVariant>>();
1362}
1363
1364TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1365 captureScreenComposition<
1366 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1367 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1368}
1369
1370/* ------------------------------------------------------------------------
1371 * Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1372 */
1373
1374TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
1375 displayRefreshCompositionDirtyGeometry<
1376 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1377 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1378 ForcedClientCompositionResultVariant>>();
1379}
1380
1381TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
1382 displayRefreshCompositionDirtyFrame<
1383 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1384 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1385 ForcedClientCompositionResultVariant>>();
1386}
1387
1388TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1389 captureScreenComposition<
1390 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1391 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1392}
1393
1394/* ------------------------------------------------------------------------
Garfield Tande619fa2020-10-02 17:13:53 -07001395 * Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1396 */
1397
1398TEST_F(CompositionTest,
1399 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyGeometry) {
1400 displayRefreshCompositionDirtyGeometry<
1401 CompositionCase<InsecureDisplaySetupVariant,
1402 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1403 ContainerLayerVariant<SecureLayerProperties>>,
1404 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1405 ForcedClientCompositionResultVariant>>();
1406}
1407
1408TEST_F(CompositionTest,
1409 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyFrame) {
1410 displayRefreshCompositionDirtyFrame<
1411 CompositionCase<InsecureDisplaySetupVariant,
1412 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1413 ContainerLayerVariant<SecureLayerProperties>>,
1414 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1415 ForcedClientCompositionResultVariant>>();
1416}
1417
1418TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1419 captureScreenComposition<
1420 CompositionCase<InsecureDisplaySetupVariant,
1421 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1422 ContainerLayerVariant<SecureLayerProperties>>,
1423 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1424}
1425
1426/* ------------------------------------------------------------------------
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001427 * Cursor layers
1428 */
1429
1430TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
1431 displayRefreshCompositionDirtyGeometry<
1432 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1433 KeepCompositionTypeVariant<IComposerClient::Composition::CURSOR>,
1434 HwcCompositionResultVariant>>();
1435}
1436
1437TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
1438 displayRefreshCompositionDirtyFrame<
1439 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1440 KeepCompositionTypeVariant<IComposerClient::Composition::CURSOR>,
1441 HwcCompositionResultVariant>>();
1442}
1443
1444TEST_F(CompositionTest, REComposedCursorLayer) {
1445 displayRefreshCompositionDirtyFrame<
1446 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1447 ChangeCompositionTypeVariant<IComposerClient::Composition::CURSOR,
1448 IComposerClient::Composition::CLIENT>,
1449 RECompositionResultVariant>>();
1450}
1451
1452TEST_F(CompositionTest, captureScreenCursorLayer) {
1453 captureScreenComposition<
1454 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1455 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1456}
1457
1458/* ------------------------------------------------------------------------
1459 * Simple buffer layer on a display which is powered off.
1460 */
1461
1462TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001463 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001464 displayRefreshCompositionDirtyGeometry<CompositionCase<
1465 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1466 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1467 HwcCompositionResultVariant>>();
1468}
1469
1470TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001471 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001472 displayRefreshCompositionDirtyFrame<CompositionCase<
1473 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1474 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1475 HwcCompositionResultVariant>>();
1476}
1477
1478TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001479 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001480 displayRefreshCompositionDirtyFrame<CompositionCase<
1481 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1482 ChangeCompositionTypeVariant<IComposerClient::Composition::DEVICE,
1483 IComposerClient::Composition::CLIENT>,
1484 RECompositionResultVariant>>();
1485}
1486
1487TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1488 captureScreenComposition<CompositionCase<
1489 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1490 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1491}
1492
Lloyd Pique4fe29402019-08-12 16:51:24 -07001493/* ------------------------------------------------------------------------
1494 * Client composition forced through debug/developer settings
1495 */
1496
1497TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
1498 displayRefreshCompositionDirtyGeometry<
1499 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1500 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1501 ForcedClientCompositionViaDebugOptionResultVariant>>();
1502}
1503
1504TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
1505 displayRefreshCompositionDirtyFrame<
1506 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1507 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1508 ForcedClientCompositionViaDebugOptionResultVariant>>();
1509}
1510
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001511} // namespace
1512} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001513
1514// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01001515#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"