blob: e42cf476571c3355bfa5d90dfd24ad35c3c840f4 [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
Dominik Laskowskif1833852021-03-23 15:06:50 -070080constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(42u);
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));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700108 setupComposer(0);
109 }
110
111 ~CompositionTest() {
112 const ::testing::TestInfo* const test_info =
113 ::testing::UnitTest::GetInstance()->current_test_info();
114 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
115 }
116
117 void setupComposer(int virtualDisplayCount) {
118 mComposer = new Hwc2::mock::Composer();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700119 EXPECT_CALL(*mComposer, getMaxVirtualDisplayCount()).WillOnce(Return(virtualDisplayCount));
120 mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
121
122 Mock::VerifyAndClear(mComposer);
123 }
124
Ana Krulecafb45842019-02-13 13:33:03 -0800125 void setupScheduler() {
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700126 auto eventThread = std::make_unique<mock::EventThread>();
127 auto sfEventThread = std::make_unique<mock::EventThread>();
Ana Krulecafb45842019-02-13 13:33:03 -0800128
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700129 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
Dominik Laskowski98041832019-08-01 18:35:59 -0700130 EXPECT_CALL(*eventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -0700131 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
132 ResyncCallback())));
Dominik Laskowski98041832019-08-01 18:35:59 -0700133
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700134 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
Dominik Laskowski98041832019-08-01 18:35:59 -0700135 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -0700136 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
137 ResyncCallback())));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700138
Ady Abraham8cb21882020-08-26 18:22:05 -0700139 auto vsyncController = std::make_unique<mock::VsyncController>();
140 auto vsyncTracker = std::make_unique<mock::VSyncTracker>();
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700141
Ady Abraham8cb21882020-08-26 18:22:05 -0700142 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
143 EXPECT_CALL(*vsyncTracker, currentPeriod())
Marin Shalamanov045b7002021-01-07 16:56:24 +0100144 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Ady Abraham8cb21882020-08-26 18:22:05 -0700145 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700146
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700147 constexpr ISchedulerCallback* kCallback = nullptr;
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700148 constexpr bool kHasMultipleConfigs = true;
Ady Abraham8cb21882020-08-26 18:22:05 -0700149 mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),
150 std::move(eventThread), std::move(sfEventThread), kCallback,
151 kHasMultipleConfigs);
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700152
153 // Layer history should be created if there are multiple configs.
154 ASSERT_TRUE(mFlinger.scheduler()->hasLayerHistory());
Ana Krulecafb45842019-02-13 13:33:03 -0800155 }
156
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700157 void setupForceGeometryDirty() {
158 // TODO: This requires the visible region and other related
159 // state to be set, and is problematic for BufferLayers since they are
160 // not visible without a buffer (and setting up a buffer looks like a
161 // pain)
162 // mFlinger.mutableVisibleRegionsDirty() = true;
163
164 mFlinger.mutableGeometryInvalid() = true;
165 }
166
167 template <typename Case>
168 void displayRefreshCompositionDirtyGeometry();
169
170 template <typename Case>
171 void displayRefreshCompositionDirtyFrame();
172
173 template <typename Case>
174 void captureScreenComposition();
175
Peiyong Line9d809e2020-04-14 13:10:48 -0700176 std::unordered_set<hal::Capability> mDefaultCapabilities = {hal::Capability::SIDEBAND_STREAM};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700177
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800178 bool mDisplayOff = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700179 TestableSurfaceFlinger mFlinger;
180 sp<DisplayDevice> mDisplay;
181 sp<DisplayDevice> mExternalDisplay;
Lloyd Pique542307f2018-10-19 13:24:08 -0700182 sp<compositionengine::mock::DisplaySurface> mDisplaySurface =
183 new compositionengine::mock::DisplaySurface();
Alec Mouriba013fa2018-10-16 12:43:11 -0700184 mock::NativeWindow* mNativeWindow = new mock::NativeWindow();
Garfield Tande619fa2020-10-02 17:13:53 -0700185 std::vector<sp<Layer>> mAuxiliaryLayers;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700186
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800187 sp<GraphicBuffer> mBuffer = new GraphicBuffer();
188 ANativeWindowBuffer* mNativeWindowBuffer = mBuffer->getNativeBuffer();
189
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700190 Hwc2::mock::Composer* mComposer = nullptr;
191 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
Alec Mourie4034bb2019-11-19 12:45:54 -0800192 mock::TimeStats* mTimeStats = new mock::TimeStats();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700193 mock::MessageQueue* mMessageQueue = new mock::MessageQueue();
Lloyd Pique9370a482019-10-03 17:58:30 -0700194 Hwc2::mock::PowerAdvisor mPowerAdvisor;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700195
196 sp<Fence> mClientTargetAcquireFence = Fence::NO_FENCE;
197
Alec Mouria90a5702021-04-16 16:36:21 +0000198 std::shared_ptr<renderengine::ExternalTexture> mCaptureScreenBuffer;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700199};
200
201template <typename LayerCase>
202void CompositionTest::displayRefreshCompositionDirtyGeometry() {
203 setupForceGeometryDirty();
204 LayerCase::setupForDirtyGeometry(this);
205
206 // --------------------------------------------------------------------
207 // Invocation
208
209 mFlinger.onMessageReceived(MessageQueue::INVALIDATE);
210 mFlinger.onMessageReceived(MessageQueue::REFRESH);
211
212 LayerCase::cleanup(this);
213}
214
215template <typename LayerCase>
216void CompositionTest::displayRefreshCompositionDirtyFrame() {
217 LayerCase::setupForDirtyFrame(this);
218
219 // --------------------------------------------------------------------
220 // Invocation
221
222 mFlinger.onMessageReceived(MessageQueue::INVALIDATE);
223 mFlinger.onMessageReceived(MessageQueue::REFRESH);
224
225 LayerCase::cleanup(this);
226}
227
228template <typename LayerCase>
229void CompositionTest::captureScreenComposition() {
230 LayerCase::setupForScreenCapture(this);
231
232 const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700233 constexpr bool forSystem = true;
Lucas Dupin9d763b72020-04-20 18:42:31 -0700234 constexpr bool regionSampling = false;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700235
Marin Shalamanov1c434292020-06-12 01:47:29 +0200236 auto renderArea = DisplayRenderArea::create(mDisplay, sourceCrop, sourceCrop.getSize(),
237 ui::Dataspace::V0_SRGB, ui::Transform::ROT_0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700238
239 auto traverseLayers = [this](const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700240 return mFlinger.traverseLayersInLayerStack(mDisplay->getLayerStack(),
241 CaptureArgs::UNSET_UID, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700242 };
243
244 // TODO: Eliminate expensive/real allocation if possible.
245 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
246 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Alec Mouria90a5702021-04-16 16:36:21 +0000247 mCaptureScreenBuffer = std::make_shared<
248 renderengine::ExternalTexture>(new GraphicBuffer(renderArea->getReqWidth(),
249 renderArea->getReqHeight(),
250 HAL_PIXEL_FORMAT_RGBA_8888, 1, usage,
251 "screenshot"),
252 *mRenderEngine, true);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700253
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700254 status_t result =
Alec Mouria90a5702021-04-16 16:36:21 +0000255 mFlinger.renderScreenImplLocked(*renderArea, traverseLayers, mCaptureScreenBuffer,
Ady Abraham99599942021-01-27 20:27:23 -0800256 forSystem, regionSampling);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700257 EXPECT_EQ(NO_ERROR, result);
258
259 LayerCase::cleanup(this);
260}
261
262/* ------------------------------------------------------------------------
263 * Variants for each display configuration which can be tested
264 */
265
266template <typename Derived>
267struct BaseDisplayVariant {
268 static constexpr bool IS_SECURE = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700269 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700270
271 static void setupPreconditions(CompositionTest* test) {
Peiyong Lin65248e02020-04-18 21:15:07 -0700272 EXPECT_CALL(*test->mComposer, setPowerMode(HWC_DISPLAY, Derived::INIT_POWER_MODE))
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700273 .WillOnce(Return(Error::NONE));
Alec Mouriba013fa2018-10-16 12:43:11 -0700274
Peiyong Line9d809e2020-04-14 13:10:48 -0700275 FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, true /* isPrimary */)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700276 .setCapabilities(&test->mDefaultCapabilities)
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700277 .setPowerMode(Derived::INIT_POWER_MODE)
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700278 .inject(&test->mFlinger, test->mComposer);
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800279 Mock::VerifyAndClear(test->mComposer);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700280
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800281 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))
282 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));
283 EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
284 .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));
285 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);
286 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);
287 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);
Lloyd Pique9370a482019-10-03 17:58:30 -0700288
289 const ::testing::TestInfo* const test_info =
290 ::testing::UnitTest::GetInstance()->current_test_info();
291
292 auto ceDisplayArgs =
293 compositionengine::DisplayCreationArgsBuilder()
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100294 .setPhysical({DEFAULT_DISPLAY_ID, ui::DisplayConnectionType::Internal})
Lloyd Pique9370a482019-10-03 17:58:30 -0700295 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
296 .setIsSecure(Derived::IS_SECURE)
297 .setLayerStackId(DEFAULT_LAYER_STACK)
298 .setPowerAdvisor(&test->mPowerAdvisor)
299 .setName(std::string("Injected display for ") +
300 test_info->test_case_name() + "." + test_info->name())
301 .build();
302
303 auto compositionDisplay =
304 compositionengine::impl::createDisplay(test->mFlinger.getCompositionEngine(),
305 ceDisplayArgs);
306
Marin Shalamanov700e6392020-02-12 20:22:26 +0100307 test->mDisplay = FakeDisplayDeviceInjector(test->mFlinger, compositionDisplay,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100308 ui::DisplayConnectionType::Internal, HWC_DISPLAY,
Marin Shalamanov700e6392020-02-12 20:22:26 +0100309 true /* isPrimary */)
310 .setDisplaySurface(test->mDisplaySurface)
311 .setNativeWindow(test->mNativeWindow)
312 .setSecure(Derived::IS_SECURE)
313 .setPowerMode(Derived::INIT_POWER_MODE)
314 .inject();
Lloyd Pique86fa3db2019-02-04 18:46:01 -0800315 Mock::VerifyAndClear(test->mNativeWindow);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700316 test->mDisplay->setLayerStack(DEFAULT_LAYER_STACK);
317 }
318
319 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700320 static void setupPreconditionCallExpectations(CompositionTest* test) {
321 EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))
322 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::DisplayCapability>({})),
323 Return(Error::NONE)));
324 }
325
326 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700327 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
328 EXPECT_CALL(*test->mComposer,
329 setColorTransform(HWC_DISPLAY, _, Hwc2::ColorTransform::IDENTITY))
330 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700331 EXPECT_CALL(*test->mComposer, getDisplayRequests(HWC_DISPLAY, _, _, _)).Times(1);
332 EXPECT_CALL(*test->mComposer, acceptDisplayChanges(HWC_DISPLAY)).Times(1);
333 EXPECT_CALL(*test->mComposer, presentDisplay(HWC_DISPLAY, _)).Times(1);
334 EXPECT_CALL(*test->mComposer, getReleaseFences(HWC_DISPLAY, _, _)).Times(1);
335
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700336 EXPECT_CALL(*test->mDisplaySurface, onFrameCommitted()).Times(1);
337 EXPECT_CALL(*test->mDisplaySurface, advanceFrame()).Times(1);
338
339 Case::CompositionType::setupHwcSetCallExpectations(test);
340 Case::CompositionType::setupHwcGetCallExpectations(test);
341 }
342
343 template <typename Case>
344 static void setupCommonScreensCaptureCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000345 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Lloyd Pique9370a482019-10-03 17:58:30 -0700346 .WillRepeatedly([](const renderengine::DisplaySettings& displaySettings,
347 const std::vector<const renderengine::LayerSettings*>&,
Alec Mouria90a5702021-04-16 16:36:21 +0000348 const std::shared_ptr<renderengine::ExternalTexture>&,
349 const bool, base::unique_fd&&, base::unique_fd*) -> status_t {
Lloyd Pique9370a482019-10-03 17:58:30 -0700350 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
351 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
352 displaySettings.physicalDisplay);
353 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
354 displaySettings.clip);
355 return NO_ERROR;
356 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700357 }
358
359 static void setupNonEmptyFrameCompositionCallExpectations(CompositionTest* test) {
360 EXPECT_CALL(*test->mDisplaySurface, beginFrame(true)).Times(1);
361 }
362
363 static void setupEmptyFrameCompositionCallExpectations(CompositionTest* test) {
364 EXPECT_CALL(*test->mDisplaySurface, beginFrame(false)).Times(1);
365 }
366
367 static void setupHwcCompositionCallExpectations(CompositionTest* test) {
Lloyd Pique66d68602019-02-13 14:23:31 -0800368 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _)).Times(1);
369
Lloyd Pique542307f2018-10-19 13:24:08 -0700370 EXPECT_CALL(*test->mDisplaySurface,
371 prepareFrame(compositionengine::DisplaySurface::COMPOSITION_HWC))
372 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700373 }
374
Lloyd Pique66d68602019-02-13 14:23:31 -0800375 static void setupHwcClientCompositionCallExpectations(CompositionTest* test) {
376 EXPECT_CALL(*test->mComposer, presentOrValidateDisplay(HWC_DISPLAY, _, _, _, _)).Times(1);
377 }
378
379 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest* test) {
380 EXPECT_CALL(*test->mComposer, validateDisplay(HWC_DISPLAY, _, _)).Times(1);
381 }
382
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700383 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Pique542307f2018-10-19 13:24:08 -0700384 EXPECT_CALL(*test->mDisplaySurface,
Peiyong Linf3ffc4e2019-12-13 00:46:24 -0800385 prepareFrame(compositionengine::DisplaySurface::COMPOSITION_GPU))
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700386 .Times(1);
387 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
388 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
389
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800390 EXPECT_CALL(*test->mNativeWindow, queueBuffer(_, _)).WillOnce(Return(0));
391 EXPECT_CALL(*test->mNativeWindow, dequeueBuffer(_, _))
392 .WillOnce(DoAll(SetArgPointee<0>(test->mNativeWindowBuffer), SetArgPointee<1>(-1),
393 Return(0)));
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000394 EXPECT_CALL(*test->mRenderEngine, drawLayers)
Lloyd Pique9370a482019-10-03 17:58:30 -0700395 .WillRepeatedly([](const renderengine::DisplaySettings& displaySettings,
396 const std::vector<const renderengine::LayerSettings*>&,
Alec Mouria90a5702021-04-16 16:36:21 +0000397 const std::shared_ptr<renderengine::ExternalTexture>&,
398 const bool, base::unique_fd&&, base::unique_fd*) -> status_t {
Lloyd Pique9370a482019-10-03 17:58:30 -0700399 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
400 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
401 displaySettings.physicalDisplay);
402 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
403 displaySettings.clip);
404 EXPECT_EQ(ui::Dataspace::UNKNOWN, displaySettings.outputDataspace);
405 return NO_ERROR;
406 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700407 }
408
409 template <typename Case>
410 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
411 Case::Layer::setupRECompositionCallExpectations(test);
412 }
413
414 template <typename Case>
415 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
416 Case::Layer::setupREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700417 }
418};
419
420struct DefaultDisplaySetupVariant : public BaseDisplayVariant<DefaultDisplaySetupVariant> {};
421
422struct InsecureDisplaySetupVariant : public BaseDisplayVariant<InsecureDisplaySetupVariant> {
423 static constexpr bool IS_SECURE = false;
424
425 template <typename Case>
426 static void setupRELayerCompositionCallExpectations(CompositionTest* test) {
427 Case::Layer::setupInsecureRECompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700428 }
429
430 template <typename Case>
431 static void setupRELayerScreenshotCompositionCallExpectations(CompositionTest* test) {
432 Case::Layer::setupInsecureREScreenshotCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700433 }
434};
435
436struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDisplaySetupVariant> {
Peiyong Lin65248e02020-04-18 21:15:07 -0700437 static constexpr hal::PowerMode INIT_POWER_MODE = hal::PowerMode::OFF;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700438
439 template <typename Case>
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700440 static void setupPreconditionCallExpectations(CompositionTest*) {}
441
442 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700443 static void setupCommonCompositionCallExpectations(CompositionTest* test) {
444 // TODO: This seems like an unnecessary call if display is powered off.
445 EXPECT_CALL(*test->mComposer,
446 setColorTransform(HWC_DISPLAY, _, Hwc2::ColorTransform::IDENTITY))
447 .Times(1);
448
449 // TODO: This seems like an unnecessary call if display is powered off.
450 Case::CompositionType::setupHwcSetCallExpectations(test);
451 }
452
453 static void setupHwcCompositionCallExpectations(CompositionTest*) {}
Lloyd Pique66d68602019-02-13 14:23:31 -0800454 static void setupHwcClientCompositionCallExpectations(CompositionTest*) {}
455 static void setupHwcForcedClientCompositionCallExpectations(CompositionTest*) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700456
457 static void setupRECompositionCallExpectations(CompositionTest* test) {
458 // TODO: This seems like an unnecessary call if display is powered off.
459 EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())
460 .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
461 }
462
463 template <typename Case>
464 static void setupRELayerCompositionCallExpectations(CompositionTest*) {}
465};
466
467/* ------------------------------------------------------------------------
468 * Variants for each layer configuration which can be tested
469 */
470
471template <typename LayerProperties>
472struct BaseLayerProperties {
473 static constexpr uint32_t WIDTH = 100;
474 static constexpr uint32_t HEIGHT = 100;
475 static constexpr PixelFormat FORMAT = PIXEL_FORMAT_RGBA_8888;
476 static constexpr uint64_t USAGE =
477 GraphicBuffer::USAGE_SW_READ_NEVER | GraphicBuffer::USAGE_SW_WRITE_NEVER;
478 static constexpr android_dataspace DATASPACE = HAL_DATASPACE_UNKNOWN;
479 static constexpr uint32_t SCALING_MODE = 0;
480 static constexpr uint32_t TRANSFORM = 0;
481 static constexpr uint32_t LAYER_FLAGS = 0;
482 static constexpr float COLOR[] = {1.f, 1.f, 1.f, 1.f};
483 static constexpr IComposerClient::BlendMode BLENDMODE =
484 IComposerClient::BlendMode::PREMULTIPLIED;
485
486 static void enqueueBuffer(CompositionTest*, sp<BufferQueueLayer> layer) {
487 auto producer = layer->getProducer();
488
489 IGraphicBufferProducer::QueueBufferOutput qbo;
490 status_t result = producer->connect(nullptr, NATIVE_WINDOW_API_EGL, false, &qbo);
491 if (result != NO_ERROR) {
492 ALOGE("Failed to connect() (%d)", result);
493 return;
494 }
495
496 int slot;
497 sp<Fence> fence;
498 result = producer->dequeueBuffer(&slot, &fence, LayerProperties::WIDTH,
499 LayerProperties::HEIGHT, LayerProperties::FORMAT,
500 LayerProperties::USAGE, nullptr, nullptr);
501 if (result != IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) {
502 ALOGE("Failed to dequeueBuffer() (%d)", result);
503 return;
504 }
505
506 sp<GraphicBuffer> buffer;
507 result = producer->requestBuffer(slot, &buffer);
508 if (result != NO_ERROR) {
509 ALOGE("Failed to requestBuffer() (%d)", result);
510 return;
511 }
512
513 IGraphicBufferProducer::QueueBufferInput qbi(systemTime(), false /* isAutoTimestamp */,
514 LayerProperties::DATASPACE,
515 Rect(LayerProperties::WIDTH,
516 LayerProperties::HEIGHT),
517 LayerProperties::SCALING_MODE,
518 LayerProperties::TRANSFORM, Fence::NO_FENCE);
519 result = producer->queueBuffer(slot, qbi, &qbo);
520 if (result != NO_ERROR) {
521 ALOGE("Failed to queueBuffer (%d)", result);
522 return;
523 }
524 }
525
526 static void setupLatchedBuffer(CompositionTest* test, sp<BufferQueueLayer> layer) {
527 // TODO: Eliminate the complexity of actually creating a buffer
528 EXPECT_CALL(*test->mRenderEngine, getMaxTextureSize()).WillOnce(Return(16384));
529 EXPECT_CALL(*test->mRenderEngine, getMaxViewportDims()).WillOnce(Return(16384));
530 status_t err =
531 layer->setDefaultBufferProperties(LayerProperties::WIDTH, LayerProperties::HEIGHT,
532 LayerProperties::FORMAT);
533 ASSERT_EQ(NO_ERROR, err);
534 Mock::VerifyAndClear(test->mRenderEngine);
535
536 EXPECT_CALL(*test->mMessageQueue, invalidate()).Times(1);
537 enqueueBuffer(test, layer);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700538 Mock::VerifyAndClearExpectations(test->mMessageQueue);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700539
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700540 bool ignoredRecomputeVisibleRegions;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700541 layer->latchBuffer(ignoredRecomputeVisibleRegions, 0, 0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700542 Mock::VerifyAndClear(test->mRenderEngine);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700543 }
544
545 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
546 setupLatchedBuffer(test, layer);
547 }
548
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700549 static void setupHwcSetGeometryCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800550 if (!test->mDisplayOff) {
551 // TODO: Coverage of other values
552 EXPECT_CALL(*test->mComposer,
553 setLayerBlendMode(HWC_DISPLAY, HWC_LAYER, LayerProperties::BLENDMODE))
554 .Times(1);
555 // TODO: Coverage of other values for origin
556 EXPECT_CALL(*test->mComposer,
557 setLayerDisplayFrame(HWC_DISPLAY, HWC_LAYER,
558 IComposerClient::Rect({0, 0, LayerProperties::WIDTH,
559 LayerProperties::HEIGHT})))
560 .Times(1);
561 EXPECT_CALL(*test->mComposer,
562 setLayerPlaneAlpha(HWC_DISPLAY, HWC_LAYER, LayerProperties::COLOR[3]))
563 .Times(1);
564 // TODO: Coverage of other values
565 EXPECT_CALL(*test->mComposer, setLayerZOrder(HWC_DISPLAY, HWC_LAYER, 0u)).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700566
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800567 // These expectations retire on saturation as the code path these
568 // expectations are for appears to make an extra call to them.
569 // TODO: Investigate this extra call
570 EXPECT_CALL(*test->mComposer,
571 setLayerTransform(HWC_DISPLAY, HWC_LAYER, DEFAULT_TRANSFORM))
572 .Times(AtLeast(1))
573 .RetiresOnSaturation();
574 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700575 }
576
577 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800578 if (!test->mDisplayOff) {
579 EXPECT_CALL(*test->mComposer,
580 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
581 IComposerClient::FRect({0.f, 0.f, LayerProperties::WIDTH,
582 LayerProperties::HEIGHT})))
583 .Times(1);
584 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700585 }
586
587 static void setupHwcSetSourceCropColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800588 if (!test->mDisplayOff) {
589 EXPECT_CALL(*test->mComposer,
590 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
591 IComposerClient::FRect({0.f, 0.f, 0.f, 0.f})))
592 .Times(1);
593 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700594 }
595
596 static void setupHwcSetPerFrameCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800597 if (!test->mDisplayOff) {
598 EXPECT_CALL(*test->mComposer,
599 setLayerVisibleRegion(HWC_DISPLAY, HWC_LAYER,
600 std::vector<IComposerClient::Rect>(
601 {IComposerClient::Rect(
602 {0, 0, LayerProperties::WIDTH,
603 LayerProperties::HEIGHT})})))
604 .Times(1);
605 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700606 }
607
608 static void setupHwcSetPerFrameColorCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800609 if (!test->mDisplayOff) {
610 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
611 .Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700612
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800613 // TODO: use COLOR
614 EXPECT_CALL(*test->mComposer,
615 setLayerColor(HWC_DISPLAY, HWC_LAYER,
616 IComposerClient::Color({0xff, 0xff, 0xff, 0xff})))
617 .Times(1);
618 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700619 }
620
621 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800622 if (!test->mDisplayOff) {
623 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _))
624 .Times(1);
625 EXPECT_CALL(*test->mComposer, setLayerBuffer(HWC_DISPLAY, HWC_LAYER, _, _, _)).Times(1);
626 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700627 }
628
629 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000630 EXPECT_CALL(*test->mRenderEngine, drawLayers)
631 .WillOnce([](const renderengine::DisplaySettings& displaySettings,
Vishnu Nair9b079a22020-01-21 14:36:08 -0800632 const std::vector<const renderengine::LayerSettings*>& layerSettings,
Alec Mouria90a5702021-04-16 16:36:21 +0000633 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
634 base::unique_fd&&, base::unique_fd*) -> status_t {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000635 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
636 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
637 displaySettings.physicalDisplay);
638 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
639 displaySettings.clip);
640 // screen capture adds an additional color layer as an alpha
641 // prefill, so gtet the back layer.
Lloyd Piquea2468662019-03-07 21:31:06 -0800642 if (layerSettings.empty()) {
643 ADD_FAILURE() << "layerSettings was not expected to be empty in "
644 "setupREBufferCompositionCommonCallExpectations "
645 "verification lambda";
646 return NO_ERROR;
647 }
Vishnu Nair9b079a22020-01-21 14:36:08 -0800648 const renderengine::LayerSettings* layer = layerSettings.back();
649 EXPECT_THAT(layer->source.buffer.buffer, Not(IsNull()));
650 EXPECT_THAT(layer->source.buffer.fence, Not(IsNull()));
651 EXPECT_EQ(DEFAULT_TEXTURE_ID, layer->source.buffer.textureName);
652 EXPECT_EQ(false, layer->source.buffer.isY410BT2020);
653 EXPECT_EQ(true, layer->source.buffer.usePremultipliedAlpha);
654 EXPECT_EQ(false, layer->source.buffer.isOpaque);
655 EXPECT_EQ(0.0, layer->geometry.roundedCornersRadius);
656 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer->sourceDataspace);
657 EXPECT_EQ(LayerProperties::COLOR[3], layer->alpha);
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000658 return NO_ERROR;
659 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700660 }
661
662 static void setupREBufferCompositionCallExpectations(CompositionTest* test) {
663 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700664 }
665
666 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
667 setupREBufferCompositionCallExpectations(test);
668 }
669
670 static void setupREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
671 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
672 }
673
674 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
675 LayerProperties::setupREBufferCompositionCommonCallExpectations(test);
676 }
677
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700678 static void setupREColorCompositionCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000679 EXPECT_CALL(*test->mRenderEngine, drawLayers)
680 .WillOnce([](const renderengine::DisplaySettings& displaySettings,
Vishnu Nair9b079a22020-01-21 14:36:08 -0800681 const std::vector<const renderengine::LayerSettings*>& layerSettings,
Alec Mouria90a5702021-04-16 16:36:21 +0000682 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
683 base::unique_fd&&, base::unique_fd*) -> status_t {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000684 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
685 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
686 displaySettings.physicalDisplay);
687 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
688 displaySettings.clip);
689 // screen capture adds an additional color layer as an alpha
690 // prefill, so get the back layer.
Lloyd Piquea2468662019-03-07 21:31:06 -0800691 if (layerSettings.empty()) {
692 ADD_FAILURE()
693 << "layerSettings was not expected to be empty in "
694 "setupREColorCompositionCallExpectations verification lambda";
695 return NO_ERROR;
696 }
Vishnu Nair9b079a22020-01-21 14:36:08 -0800697 const renderengine::LayerSettings* layer = layerSettings.back();
698 EXPECT_THAT(layer->source.buffer.buffer, IsNull());
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000699 EXPECT_EQ(half3(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
700 LayerProperties::COLOR[2]),
Vishnu Nair9b079a22020-01-21 14:36:08 -0800701 layer->source.solidColor);
702 EXPECT_EQ(0.0, layer->geometry.roundedCornersRadius);
703 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer->sourceDataspace);
704 EXPECT_EQ(LayerProperties::COLOR[3], layer->alpha);
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000705 return NO_ERROR;
706 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700707 }
708
709 static void setupREColorScreenshotCompositionCallExpectations(CompositionTest* test) {
710 setupREColorCompositionCallExpectations(test);
711 }
712};
713
714struct DefaultLayerProperties : public BaseLayerProperties<DefaultLayerProperties> {};
715
Vishnu Nairfa247b12020-02-11 08:58:26 -0800716struct EffectLayerProperties : public BaseLayerProperties<EffectLayerProperties> {
Alec Mourida8a9d12020-01-30 20:00:31 -0800717 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
718};
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700719
720struct SidebandLayerProperties : public BaseLayerProperties<SidebandLayerProperties> {
721 using Base = BaseLayerProperties<SidebandLayerProperties>;
722 static constexpr IComposerClient::BlendMode BLENDMODE = IComposerClient::BlendMode::NONE;
723
724 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
725 sp<NativeHandle> stream =
726 NativeHandle::create(reinterpret_cast<native_handle_t*>(DEFAULT_SIDEBAND_STREAM),
727 false);
728 test->mFlinger.setLayerSidebandStream(layer, stream);
729 }
730
731 static void setupHwcSetSourceCropBufferCallExpectations(CompositionTest* test) {
732 EXPECT_CALL(*test->mComposer,
733 setLayerSourceCrop(HWC_DISPLAY, HWC_LAYER,
734 IComposerClient::FRect({0.f, 0.f, -1.f, -1.f})))
735 .Times(1);
736 }
737
738 static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {
739 EXPECT_CALL(*test->mComposer,
740 setLayerSidebandStream(HWC_DISPLAY, HWC_LAYER,
741 reinterpret_cast<native_handle_t*>(
742 DEFAULT_SIDEBAND_STREAM)))
743 .WillOnce(Return(Error::NONE));
744
745 EXPECT_CALL(*test->mComposer, setLayerSurfaceDamage(HWC_DISPLAY, HWC_LAYER, _)).Times(1);
746 }
747
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000748 static void setupREBufferCompositionCommonCallExpectations(CompositionTest* /*test*/) {}
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700749};
750
Garfield Tande619fa2020-10-02 17:13:53 -0700751template <typename LayerProperties>
752struct CommonSecureLayerProperties : public BaseLayerProperties<LayerProperties> {
753 using Base = BaseLayerProperties<LayerProperties>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700754
755 static void setupInsecureREBufferCompositionCommonCallExpectations(CompositionTest* test) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000756 EXPECT_CALL(*test->mRenderEngine, drawLayers)
757 .WillOnce([](const renderengine::DisplaySettings& displaySettings,
Vishnu Nair9b079a22020-01-21 14:36:08 -0800758 const std::vector<const renderengine::LayerSettings*>& layerSettings,
Alec Mouria90a5702021-04-16 16:36:21 +0000759 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
760 base::unique_fd&&, base::unique_fd*) -> status_t {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000761 EXPECT_EQ(DEFAULT_DISPLAY_MAX_LUMINANCE, displaySettings.maxLuminance);
762 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
763 displaySettings.physicalDisplay);
764 EXPECT_EQ(Rect(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),
765 displaySettings.clip);
766 // screen capture adds an additional color layer as an alpha
767 // prefill, so get the back layer.
Lloyd Piquea2468662019-03-07 21:31:06 -0800768 if (layerSettings.empty()) {
769 ADD_FAILURE() << "layerSettings was not expected to be empty in "
770 "setupInsecureREBufferCompositionCommonCallExpectations "
771 "verification lambda";
772 return NO_ERROR;
773 }
Vishnu Nair9b079a22020-01-21 14:36:08 -0800774 const renderengine::LayerSettings* layer = layerSettings.back();
775 EXPECT_THAT(layer->source.buffer.buffer, IsNull());
776 EXPECT_EQ(half3(0.0f, 0.0f, 0.0f), layer->source.solidColor);
777 EXPECT_EQ(0.0, layer->geometry.roundedCornersRadius);
778 EXPECT_EQ(ui::Dataspace::UNKNOWN, layer->sourceDataspace);
779 EXPECT_EQ(1.0f, layer->alpha);
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000780 return NO_ERROR;
781 });
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700782 }
783
784 static void setupInsecureREBufferCompositionCallExpectations(CompositionTest* test) {
785 setupInsecureREBufferCompositionCommonCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700786 }
787
788 static void setupInsecureREBufferScreenshotCompositionCallExpectations(CompositionTest* test) {
789 setupInsecureREBufferCompositionCommonCallExpectations(test);
790 }
791};
792
Garfield Tande619fa2020-10-02 17:13:53 -0700793struct ParentSecureLayerProperties
794 : public CommonSecureLayerProperties<ParentSecureLayerProperties> {};
795
796struct SecureLayerProperties : public CommonSecureLayerProperties<SecureLayerProperties> {
797 static constexpr uint32_t LAYER_FLAGS = ISurfaceComposerClient::eSecure;
798};
799
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700800struct CursorLayerProperties : public BaseLayerProperties<CursorLayerProperties> {
801 using Base = BaseLayerProperties<CursorLayerProperties>;
802
803 static void setupLayerState(CompositionTest* test, sp<BufferQueueLayer> layer) {
804 Base::setupLayerState(test, layer);
805 test->mFlinger.setLayerPotentialCursor(layer, true);
806 }
807};
808
809struct NoLayerVariant {
810 using FlingerLayerType = sp<BufferQueueLayer>;
811
812 static FlingerLayerType createLayer(CompositionTest*) { return FlingerLayerType(); }
813 static void injectLayer(CompositionTest*, FlingerLayerType) {}
814 static void cleanupInjectedLayers(CompositionTest*) {}
815
816 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
817 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
818};
819
820template <typename LayerProperties>
821struct BaseLayerVariant {
822 template <typename L, typename F>
823 static sp<L> createLayerWithFactory(CompositionTest* test, F factory) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700824 EXPECT_CALL(*test->mMessageQueue, postMessage(_)).Times(0);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700825
826 sp<L> layer = factory();
827
Dominik Laskowski49cea512019-11-12 14:13:23 -0800828 // Layer should be registered with scheduler.
829 EXPECT_EQ(1, test->mFlinger.scheduler()->layerHistorySize());
830
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700831 Mock::VerifyAndClear(test->mComposer);
832 Mock::VerifyAndClear(test->mRenderEngine);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700833 Mock::VerifyAndClearExpectations(test->mMessageQueue);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700834
Garfield Tande619fa2020-10-02 17:13:53 -0700835 initLayerDrawingStateAndComputeBounds(test, layer);
836
837 return layer;
838 }
839
840 template <typename L>
841 static void initLayerDrawingStateAndComputeBounds(CompositionTest* test, sp<L> layer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700842 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
843 layerDrawingState.layerStack = DEFAULT_LAYER_STACK;
chaviw766c9c52021-02-10 17:36:47 -0800844 layerDrawingState.width = 100;
845 layerDrawingState.height = 100;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700846 layerDrawingState.color = half4(LayerProperties::COLOR[0], LayerProperties::COLOR[1],
847 LayerProperties::COLOR[2], LayerProperties::COLOR[3]);
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700848 layer->computeBounds(FloatRect(0, 0, 100, 100), ui::Transform(), 0.f /* shadowRadius */);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700849 }
850
851 static void injectLayer(CompositionTest* test, sp<Layer> layer) {
852 EXPECT_CALL(*test->mComposer, createLayer(HWC_DISPLAY, _))
853 .WillOnce(DoAll(SetArgPointee<1>(HWC_LAYER), Return(Error::NONE)));
854
Lloyd Piquede196652020-01-22 17:29:58 -0800855 auto outputLayer = test->mDisplay->getCompositionDisplay()->injectOutputLayerForTest(
856 layer->getCompositionEngineLayerFE());
Lloyd Pique01c77c12019-04-17 12:48:32 -0700857 outputLayer->editState().visibleRegion = Region(Rect(0, 0, 100, 100));
858 outputLayer->editState().outputSpaceVisibleRegion = Region(Rect(0, 0, 100, 100));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700859
860 Mock::VerifyAndClear(test->mComposer);
861
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700862 test->mFlinger.mutableDrawingState().layersSortedByZ.add(layer);
863 }
864
865 static void cleanupInjectedLayers(CompositionTest* test) {
866 EXPECT_CALL(*test->mComposer, destroyLayer(HWC_DISPLAY, HWC_LAYER))
867 .WillOnce(Return(Error::NONE));
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800868
Lloyd Pique01c77c12019-04-17 12:48:32 -0700869 test->mDisplay->getCompositionDisplay()->clearOutputLayers();
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700870 test->mFlinger.mutableDrawingState().layersSortedByZ.clear();
Dominik Laskowski49cea512019-11-12 14:13:23 -0800871
872 // Layer should be unregistered with scheduler.
873 test->mFlinger.onMessageReceived(MessageQueue::INVALIDATE);
874 EXPECT_EQ(0, test->mFlinger.scheduler()->layerHistorySize());
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700875 }
876};
877
878template <typename LayerProperties>
Vishnu Nairfa247b12020-02-11 08:58:26 -0800879struct EffectLayerVariant : public BaseLayerVariant<LayerProperties> {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700880 using Base = BaseLayerVariant<LayerProperties>;
Vishnu Nairfa247b12020-02-11 08:58:26 -0800881 using FlingerLayerType = sp<EffectLayer>;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700882
883 static FlingerLayerType createLayer(CompositionTest* test) {
Vishnu Nairfa247b12020-02-11 08:58:26 -0800884 FlingerLayerType layer = Base::template createLayerWithFactory<EffectLayer>(test, [test]() {
885 return new EffectLayer(
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700886 LayerCreationArgs(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Vishnu Nairfa247b12020-02-11 08:58:26 -0800887 LayerProperties::WIDTH, LayerProperties::HEIGHT,
888 LayerProperties::LAYER_FLAGS, LayerMetadata()));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700889 });
Vishnu Nair60356342018-11-13 13:00:45 -0800890
891 auto& layerDrawingState = test->mFlinger.mutableLayerDrawingState(layer);
chaviw25714502021-02-11 10:01:08 -0800892 layerDrawingState.crop = Rect(0, 0, LayerProperties::HEIGHT, LayerProperties::WIDTH);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700893 return layer;
894 }
895
896 static void setupRECompositionCallExpectations(CompositionTest* test) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700897 LayerProperties::setupREColorCompositionCallExpectations(test);
898 }
899
900 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
901 LayerProperties::setupREColorScreenshotCompositionCallExpectations(test);
902 }
903
904 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
905 LayerProperties::setupHwcSetGeometryCallExpectations(test);
906 LayerProperties::setupHwcSetSourceCropColorCallExpectations(test);
907 }
908
909 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
910 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
911 LayerProperties::setupHwcSetPerFrameColorCallExpectations(test);
912 }
913};
914
915template <typename LayerProperties>
916struct BufferLayerVariant : public BaseLayerVariant<LayerProperties> {
917 using Base = BaseLayerVariant<LayerProperties>;
918 using FlingerLayerType = sp<BufferQueueLayer>;
919
920 static FlingerLayerType createLayer(CompositionTest* test) {
921 test->mFlinger.mutableTexturePool().push_back(DEFAULT_TEXTURE_ID);
922
923 FlingerLayerType layer =
924 Base::template createLayerWithFactory<BufferQueueLayer>(test, [test]() {
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700925 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-layer",
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700926 LayerProperties::WIDTH, LayerProperties::HEIGHT,
927 LayerProperties::LAYER_FLAGS, LayerMetadata());
chaviwb4c6e582019-08-16 14:35:07 -0700928 args.textureName = test->mFlinger.mutableTexturePool().back();
929 return new BufferQueueLayer(args);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700930 });
931
932 LayerProperties::setupLayerState(test, layer);
933
934 return layer;
935 }
936
937 static void cleanupInjectedLayers(CompositionTest* test) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700938 EXPECT_CALL(*test->mMessageQueue, postMessage(_)).Times(1);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700939 Base::cleanupInjectedLayers(test);
940 }
941
942 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
943 LayerProperties::setupHwcSetGeometryCallExpectations(test);
944 LayerProperties::setupHwcSetSourceCropBufferCallExpectations(test);
945 }
946
947 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
948 LayerProperties::setupHwcSetPerFrameCallExpectations(test);
949 LayerProperties::setupHwcSetPerFrameBufferCallExpectations(test);
950 }
951
952 static void setupRECompositionCallExpectations(CompositionTest* test) {
953 LayerProperties::setupREBufferCompositionCallExpectations(test);
954 }
955
956 static void setupInsecureRECompositionCallExpectations(CompositionTest* test) {
957 LayerProperties::setupInsecureREBufferCompositionCallExpectations(test);
958 }
959
960 static void setupREScreenshotCompositionCallExpectations(CompositionTest* test) {
961 LayerProperties::setupREBufferScreenshotCompositionCallExpectations(test);
962 }
963
964 static void setupInsecureREScreenshotCompositionCallExpectations(CompositionTest* test) {
965 LayerProperties::setupInsecureREBufferScreenshotCompositionCallExpectations(test);
966 }
967};
968
Garfield Tande619fa2020-10-02 17:13:53 -0700969template <typename LayerProperties>
970struct ContainerLayerVariant : public BaseLayerVariant<LayerProperties> {
971 using Base = BaseLayerVariant<LayerProperties>;
972 using FlingerLayerType = sp<ContainerLayer>;
973
974 static FlingerLayerType createLayer(CompositionTest* test) {
975 LayerCreationArgs args(test->mFlinger.flinger(), sp<Client>(), "test-container-layer",
976 LayerProperties::WIDTH, LayerProperties::HEIGHT,
977 LayerProperties::LAYER_FLAGS, LayerMetadata());
978 FlingerLayerType layer = new ContainerLayer(args);
979 Base::template initLayerDrawingStateAndComputeBounds(test, layer);
980 return layer;
981 }
982};
983
984template <typename LayerVariant, typename ParentLayerVariant>
985struct ChildLayerVariant : public LayerVariant {
986 using Base = LayerVariant;
987 using FlingerLayerType = typename LayerVariant::FlingerLayerType;
988 using ParentBase = ParentLayerVariant;
989
990 static FlingerLayerType createLayer(CompositionTest* test) {
991 // Need to create child layer first. Otherwise layer history size will be 2.
992 FlingerLayerType layer = Base::createLayer(test);
993
994 typename ParentBase::FlingerLayerType parentLayer = ParentBase::createLayer(test);
995 parentLayer->addChild(layer);
996 test->mFlinger.setLayerDrawingParent(layer, parentLayer);
997
998 test->mAuxiliaryLayers.push_back(parentLayer);
999
1000 return layer;
1001 }
1002
1003 static void cleanupInjectedLayers(CompositionTest* test) {
1004 // Clear auxiliary layers first so that child layer can be successfully destroyed in the
1005 // following call.
1006 test->mAuxiliaryLayers.clear();
1007
1008 Base::cleanupInjectedLayers(test);
1009 }
1010};
1011
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001012/* ------------------------------------------------------------------------
1013 * Variants to control how the composition type is changed
1014 */
1015
1016struct NoCompositionTypeVariant {
1017 static void setupHwcSetCallExpectations(CompositionTest*) {}
1018
1019 static void setupHwcGetCallExpectations(CompositionTest* test) {
1020 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1021 }
1022};
1023
1024template <IComposerClient::Composition CompositionType>
1025struct KeepCompositionTypeVariant {
Peiyong Line9d809e2020-04-14 13:10:48 -07001026 static constexpr hal::Composition TYPE = CompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001027
1028 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001029 if (!test->mDisplayOff) {
1030 EXPECT_CALL(*test->mComposer,
1031 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, CompositionType))
1032 .Times(1);
1033 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001034 }
1035
1036 static void setupHwcGetCallExpectations(CompositionTest* test) {
1037 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _)).Times(1);
1038 }
1039};
1040
1041template <IComposerClient::Composition InitialCompositionType,
1042 IComposerClient::Composition FinalCompositionType>
1043struct ChangeCompositionTypeVariant {
Peiyong Line9d809e2020-04-14 13:10:48 -07001044 static constexpr hal::Composition TYPE = FinalCompositionType;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001045
1046 static void setupHwcSetCallExpectations(CompositionTest* test) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001047 if (!test->mDisplayOff) {
1048 EXPECT_CALL(*test->mComposer,
1049 setLayerCompositionType(HWC_DISPLAY, HWC_LAYER, InitialCompositionType))
1050 .Times(1);
1051 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001052 }
1053
1054 static void setupHwcGetCallExpectations(CompositionTest* test) {
1055 EXPECT_CALL(*test->mComposer, getChangedCompositionTypes(HWC_DISPLAY, _, _))
1056 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::Layer>{
1057 static_cast<Hwc2::Layer>(HWC_LAYER)}),
1058 SetArgPointee<2>(std::vector<IComposerClient::Composition>{
1059 FinalCompositionType}),
1060 Return(Error::NONE)));
1061 }
1062};
1063
1064/* ------------------------------------------------------------------------
1065 * Variants to select how the composition is expected to be handled
1066 */
1067
1068struct CompositionResultBaseVariant {
1069 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1070
1071 template <typename Case>
1072 static void setupCallExpectationsForDirtyGeometry(CompositionTest* test) {
1073 Case::Layer::setupCallExpectationsForDirtyGeometry(test);
1074 }
1075
1076 template <typename Case>
1077 static void setupCallExpectationsForDirtyFrame(CompositionTest* test) {
1078 Case::Layer::setupCallExpectationsForDirtyFrame(test);
1079 }
1080};
1081
1082struct NoCompositionResultVariant : public CompositionResultBaseVariant {
1083 template <typename Case>
1084 static void setupCallExpectations(CompositionTest* test) {
1085 Case::Display::setupEmptyFrameCompositionCallExpectations(test);
1086 Case::Display::setupHwcCompositionCallExpectations(test);
1087 }
1088};
1089
1090struct HwcCompositionResultVariant : public CompositionResultBaseVariant {
1091 template <typename Case>
1092 static void setupCallExpectations(CompositionTest* test) {
1093 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1094 Case::Display::setupHwcCompositionCallExpectations(test);
1095 }
1096};
1097
1098struct RECompositionResultVariant : public CompositionResultBaseVariant {
1099 template <typename Case>
1100 static void setupCallExpectations(CompositionTest* test) {
1101 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
Lloyd Pique66d68602019-02-13 14:23:31 -08001102 Case::Display::setupHwcClientCompositionCallExpectations(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001103 Case::Display::setupRECompositionCallExpectations(test);
1104 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1105 }
1106};
1107
Lloyd Pique66d68602019-02-13 14:23:31 -08001108struct ForcedClientCompositionResultVariant : public CompositionResultBaseVariant {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001109 static void setupLayerState(CompositionTest* test, sp<Layer> layer) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001110 const auto outputLayer =
1111 TestableSurfaceFlinger::findOutputLayerForDisplay(layer, test->mDisplay);
Lloyd Piquef5275482019-01-29 18:42:42 -08001112 LOG_FATAL_IF(!outputLayer);
1113 outputLayer->editState().forceClientComposition = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001114 }
1115
1116 template <typename Case>
Lloyd Pique66d68602019-02-13 14:23:31 -08001117 static void setupCallExpectations(CompositionTest* test) {
1118 Case::Display::setupNonEmptyFrameCompositionCallExpectations(test);
1119 Case::Display::setupHwcForcedClientCompositionCallExpectations(test);
1120 Case::Display::setupRECompositionCallExpectations(test);
1121 Case::Display::template setupRELayerCompositionCallExpectations<Case>(test);
1122 }
1123
1124 template <typename Case>
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001125 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1126
1127 template <typename Case>
1128 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1129};
1130
Lloyd Pique4fe29402019-08-12 16:51:24 -07001131struct ForcedClientCompositionViaDebugOptionResultVariant : public CompositionResultBaseVariant {
1132 static void setupLayerState(CompositionTest* test, sp<Layer>) {
1133 test->mFlinger.mutableDebugDisableHWC() = true;
1134 }
1135
1136 template <typename Case>
1137 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>
1145 static void setupCallExpectationsForDirtyGeometry(CompositionTest*) {}
1146
1147 template <typename Case>
1148 static void setupCallExpectationsForDirtyFrame(CompositionTest*) {}
1149};
1150
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001151struct EmptyScreenshotResultVariant {
1152 static void setupLayerState(CompositionTest*, sp<Layer>) {}
1153
1154 template <typename Case>
1155 static void setupCallExpectations(CompositionTest*) {}
1156};
1157
1158struct REScreenshotResultVariant : public EmptyScreenshotResultVariant {
1159 using Base = EmptyScreenshotResultVariant;
1160
1161 template <typename Case>
1162 static void setupCallExpectations(CompositionTest* test) {
1163 Base::template setupCallExpectations<Case>(test);
1164 Case::Display::template setupRELayerScreenshotCompositionCallExpectations<Case>(test);
1165 }
1166};
1167
1168/* ------------------------------------------------------------------------
1169 * Composition test case, containing all the variants being tested
1170 */
1171
1172template <typename DisplayCase, typename LayerCase, typename CompositionTypeCase,
1173 typename CompositionResultCase>
1174struct CompositionCase {
1175 using ThisCase =
1176 CompositionCase<DisplayCase, LayerCase, CompositionTypeCase, CompositionResultCase>;
1177 using Display = DisplayCase;
1178 using Layer = LayerCase;
1179 using CompositionType = CompositionTypeCase;
1180 using CompositionResult = CompositionResultCase;
1181
1182 static void setupCommon(CompositionTest* test) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -07001183 Display::template setupPreconditionCallExpectations<ThisCase>(test);
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001184 Display::setupPreconditions(test);
1185
1186 auto layer = Layer::createLayer(test);
1187 Layer::injectLayer(test, layer);
1188 CompositionResult::setupLayerState(test, layer);
1189 }
1190
1191 static void setupForDirtyGeometry(CompositionTest* test) {
1192 setupCommon(test);
1193
1194 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1195 CompositionResult::template setupCallExpectationsForDirtyGeometry<ThisCase>(test);
1196 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1197 CompositionResult::template setupCallExpectations<ThisCase>(test);
1198 }
1199
1200 static void setupForDirtyFrame(CompositionTest* test) {
1201 setupCommon(test);
1202
1203 Display::template setupCommonCompositionCallExpectations<ThisCase>(test);
1204 CompositionResult::template setupCallExpectationsForDirtyFrame<ThisCase>(test);
1205 CompositionResult::template setupCallExpectations<ThisCase>(test);
1206 }
1207
1208 static void setupForScreenCapture(CompositionTest* test) {
1209 setupCommon(test);
1210
1211 Display::template setupCommonScreensCaptureCallExpectations<ThisCase>(test);
1212 CompositionResult::template setupCallExpectations<ThisCase>(test);
1213 }
1214
1215 static void cleanup(CompositionTest* test) {
1216 Layer::cleanupInjectedLayers(test);
1217
Peiyong Linbdd08cc2019-12-17 21:35:14 -08001218 for (auto& displayData : test->mFlinger.mutableHwcDisplayData()) {
1219 static_cast<TestableSurfaceFlinger::HWC2Display*>(displayData.second.hwcDisplay.get())
1220 ->mutableLayers()
1221 .clear();
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001222 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001223 }
1224};
1225
1226/* ------------------------------------------------------------------------
1227 * Composition cases to test
1228 */
1229
1230TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyGeometry) {
1231 displayRefreshCompositionDirtyGeometry<
1232 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1233 NoCompositionResultVariant>>();
1234}
1235
1236TEST_F(CompositionTest, noLayersDoesMinimalWorkWithDirtyFrame) {
1237 displayRefreshCompositionDirtyFrame<
1238 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1239 NoCompositionResultVariant>>();
1240}
1241
1242TEST_F(CompositionTest, noLayersDoesMinimalWorkToCaptureScreen) {
1243 captureScreenComposition<
1244 CompositionCase<DefaultDisplaySetupVariant, NoLayerVariant, NoCompositionTypeVariant,
1245 EmptyScreenshotResultVariant>>();
1246}
1247
1248/* ------------------------------------------------------------------------
1249 * Simple buffer layers
1250 */
1251
1252TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyGeometry) {
1253 displayRefreshCompositionDirtyGeometry<
1254 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1255 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1256 HwcCompositionResultVariant>>();
1257}
1258
1259TEST_F(CompositionTest, HWCComposedNormalBufferLayerWithDirtyFrame) {
1260 displayRefreshCompositionDirtyFrame<
1261 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1262 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1263 HwcCompositionResultVariant>>();
1264}
1265
1266TEST_F(CompositionTest, REComposedNormalBufferLayer) {
1267 displayRefreshCompositionDirtyFrame<
1268 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1269 ChangeCompositionTypeVariant<IComposerClient::Composition::DEVICE,
1270 IComposerClient::Composition::CLIENT>,
1271 RECompositionResultVariant>>();
1272}
1273
1274TEST_F(CompositionTest, captureScreenNormalBufferLayer) {
1275 captureScreenComposition<
1276 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1277 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1278}
1279
1280/* ------------------------------------------------------------------------
1281 * Single-color layers
1282 */
1283
Vishnu Nairfa247b12020-02-11 08:58:26 -08001284TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyGeometry) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001285 displayRefreshCompositionDirtyGeometry<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001286 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001287 KeepCompositionTypeVariant<IComposerClient::Composition::SOLID_COLOR>,
1288 HwcCompositionResultVariant>>();
1289}
1290
Vishnu Nairfa247b12020-02-11 08:58:26 -08001291TEST_F(CompositionTest, HWCComposedEffectLayerWithDirtyFrame) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001292 displayRefreshCompositionDirtyFrame<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001293 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001294 KeepCompositionTypeVariant<IComposerClient::Composition::SOLID_COLOR>,
1295 HwcCompositionResultVariant>>();
1296}
1297
Vishnu Nairfa247b12020-02-11 08:58:26 -08001298TEST_F(CompositionTest, REComposedEffectLayer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001299 displayRefreshCompositionDirtyFrame<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001300 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001301 ChangeCompositionTypeVariant<IComposerClient::Composition::SOLID_COLOR,
1302 IComposerClient::Composition::CLIENT>,
1303 RECompositionResultVariant>>();
1304}
1305
Vishnu Nairfa247b12020-02-11 08:58:26 -08001306TEST_F(CompositionTest, captureScreenEffectLayer) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001307 captureScreenComposition<
Vishnu Nairfa247b12020-02-11 08:58:26 -08001308 CompositionCase<DefaultDisplaySetupVariant, EffectLayerVariant<EffectLayerProperties>,
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001309 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1310}
1311
1312/* ------------------------------------------------------------------------
1313 * Layers with sideband buffers
1314 */
1315
1316TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyGeometry) {
1317 displayRefreshCompositionDirtyGeometry<
1318 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1319 KeepCompositionTypeVariant<IComposerClient::Composition::SIDEBAND>,
1320 HwcCompositionResultVariant>>();
1321}
1322
1323TEST_F(CompositionTest, HWCComposedSidebandBufferLayerWithDirtyFrame) {
1324 displayRefreshCompositionDirtyFrame<
1325 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1326 KeepCompositionTypeVariant<IComposerClient::Composition::SIDEBAND>,
1327 HwcCompositionResultVariant>>();
1328}
1329
1330TEST_F(CompositionTest, REComposedSidebandBufferLayer) {
1331 displayRefreshCompositionDirtyFrame<
1332 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1333 ChangeCompositionTypeVariant<IComposerClient::Composition::SIDEBAND,
1334 IComposerClient::Composition::CLIENT>,
1335 RECompositionResultVariant>>();
1336}
1337
1338TEST_F(CompositionTest, captureScreenSidebandBufferLayer) {
1339 captureScreenComposition<
1340 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SidebandLayerProperties>,
1341 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1342}
1343
1344/* ------------------------------------------------------------------------
1345 * Layers with ISurfaceComposerClient::eSecure, on a secure display
1346 */
1347
1348TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyGeometry) {
1349 displayRefreshCompositionDirtyGeometry<
1350 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1351 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1352 HwcCompositionResultVariant>>();
1353}
1354
1355TEST_F(CompositionTest, HWCComposedSecureBufferLayerWithDirtyFrame) {
1356 displayRefreshCompositionDirtyFrame<
1357 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1358 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1359 HwcCompositionResultVariant>>();
1360}
1361
1362TEST_F(CompositionTest, REComposedSecureBufferLayer) {
1363 displayRefreshCompositionDirtyFrame<
1364 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1365 ChangeCompositionTypeVariant<IComposerClient::Composition::DEVICE,
1366 IComposerClient::Composition::CLIENT>,
1367 RECompositionResultVariant>>();
1368}
1369
1370TEST_F(CompositionTest, captureScreenSecureBufferLayerOnSecureDisplay) {
1371 captureScreenComposition<
1372 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1373 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1374}
1375
1376/* ------------------------------------------------------------------------
1377 * Layers with ISurfaceComposerClient::eSecure, on a non-secure display
1378 */
1379
1380TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyGeometry) {
1381 displayRefreshCompositionDirtyGeometry<
1382 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1383 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1384 ForcedClientCompositionResultVariant>>();
1385}
1386
1387TEST_F(CompositionTest, HWCComposedSecureBufferLayerOnInsecureDisplayWithDirtyFrame) {
1388 displayRefreshCompositionDirtyFrame<
1389 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1390 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1391 ForcedClientCompositionResultVariant>>();
1392}
1393
1394TEST_F(CompositionTest, captureScreenSecureBufferLayerOnInsecureDisplay) {
1395 captureScreenComposition<
1396 CompositionCase<InsecureDisplaySetupVariant, BufferLayerVariant<SecureLayerProperties>,
1397 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1398}
1399
1400/* ------------------------------------------------------------------------
Garfield Tande619fa2020-10-02 17:13:53 -07001401 * Layers with a parent layer with ISurfaceComposerClient::eSecure, on a non-secure display
1402 */
1403
1404TEST_F(CompositionTest,
1405 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyGeometry) {
1406 displayRefreshCompositionDirtyGeometry<
1407 CompositionCase<InsecureDisplaySetupVariant,
1408 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1409 ContainerLayerVariant<SecureLayerProperties>>,
1410 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1411 ForcedClientCompositionResultVariant>>();
1412}
1413
1414TEST_F(CompositionTest,
1415 HWCComposedBufferLayerWithSecureParentLayerOnInsecureDisplayWithDirtyFrame) {
1416 displayRefreshCompositionDirtyFrame<
1417 CompositionCase<InsecureDisplaySetupVariant,
1418 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1419 ContainerLayerVariant<SecureLayerProperties>>,
1420 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1421 ForcedClientCompositionResultVariant>>();
1422}
1423
1424TEST_F(CompositionTest, captureScreenBufferLayerWithSecureParentLayerOnInsecureDisplay) {
1425 captureScreenComposition<
1426 CompositionCase<InsecureDisplaySetupVariant,
1427 ChildLayerVariant<BufferLayerVariant<ParentSecureLayerProperties>,
1428 ContainerLayerVariant<SecureLayerProperties>>,
1429 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1430}
1431
1432/* ------------------------------------------------------------------------
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001433 * Cursor layers
1434 */
1435
1436TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyGeometry) {
1437 displayRefreshCompositionDirtyGeometry<
1438 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1439 KeepCompositionTypeVariant<IComposerClient::Composition::CURSOR>,
1440 HwcCompositionResultVariant>>();
1441}
1442
1443TEST_F(CompositionTest, HWCComposedCursorLayerWithDirtyFrame) {
1444 displayRefreshCompositionDirtyFrame<
1445 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1446 KeepCompositionTypeVariant<IComposerClient::Composition::CURSOR>,
1447 HwcCompositionResultVariant>>();
1448}
1449
1450TEST_F(CompositionTest, REComposedCursorLayer) {
1451 displayRefreshCompositionDirtyFrame<
1452 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1453 ChangeCompositionTypeVariant<IComposerClient::Composition::CURSOR,
1454 IComposerClient::Composition::CLIENT>,
1455 RECompositionResultVariant>>();
1456}
1457
1458TEST_F(CompositionTest, captureScreenCursorLayer) {
1459 captureScreenComposition<
1460 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<CursorLayerProperties>,
1461 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1462}
1463
1464/* ------------------------------------------------------------------------
1465 * Simple buffer layer on a display which is powered off.
1466 */
1467
1468TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyGeometry) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001469 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001470 displayRefreshCompositionDirtyGeometry<CompositionCase<
1471 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1472 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1473 HwcCompositionResultVariant>>();
1474}
1475
1476TEST_F(CompositionTest, displayOffHWCComposedNormalBufferLayerWithDirtyFrame) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001477 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001478 displayRefreshCompositionDirtyFrame<CompositionCase<
1479 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1480 KeepCompositionTypeVariant<IComposerClient::Composition::DEVICE>,
1481 HwcCompositionResultVariant>>();
1482}
1483
1484TEST_F(CompositionTest, displayOffREComposedNormalBufferLayer) {
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001485 mDisplayOff = true;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001486 displayRefreshCompositionDirtyFrame<CompositionCase<
1487 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1488 ChangeCompositionTypeVariant<IComposerClient::Composition::DEVICE,
1489 IComposerClient::Composition::CLIENT>,
1490 RECompositionResultVariant>>();
1491}
1492
1493TEST_F(CompositionTest, captureScreenNormalBufferLayerOnPoweredOffDisplay) {
1494 captureScreenComposition<CompositionCase<
1495 PoweredOffDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1496 NoCompositionTypeVariant, REScreenshotResultVariant>>();
1497}
1498
Lloyd Pique4fe29402019-08-12 16:51:24 -07001499/* ------------------------------------------------------------------------
1500 * Client composition forced through debug/developer settings
1501 */
1502
1503TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyGeometry) {
1504 displayRefreshCompositionDirtyGeometry<
1505 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1506 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1507 ForcedClientCompositionViaDebugOptionResultVariant>>();
1508}
1509
1510TEST_F(CompositionTest, DebugOptionForcingClientCompositionOfBufferLayerWithDirtyFrame) {
1511 displayRefreshCompositionDirtyFrame<
1512 CompositionCase<DefaultDisplaySetupVariant, BufferLayerVariant<DefaultLayerProperties>,
1513 KeepCompositionTypeVariant<IComposerClient::Composition::CLIENT>,
1514 ForcedClientCompositionViaDebugOptionResultVariant>>();
1515}
1516
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001517} // namespace
1518} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08001519
1520// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01001521#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"