blob: c6e56c6963b3eb7c9839e94f8c68da2fd2bbdb5c [file] [log] [blame]
Lloyd Pique45a165a2018-10-19 11:54:47 -07001/*
2 * Copyright 2019 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
Lloyd Pique45a165a2018-10-19 11:54:47 -070017#include <cmath>
18
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070019#include <compositionengine/DisplayColorProfileCreationArgs.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070020#include <compositionengine/DisplayCreationArgs.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070021#include <compositionengine/DisplaySurface.h>
22#include <compositionengine/RenderSurfaceCreationArgs.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070023#include <compositionengine/impl/Display.h>
Lloyd Piquec6607552019-12-02 17:57:39 -080024#include <compositionengine/impl/RenderSurface.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070025#include <compositionengine/mock/CompositionEngine.h>
Lloyd Piquef5275482019-01-29 18:42:42 -080026#include <compositionengine/mock/DisplayColorProfile.h>
Lloyd Piquec6607552019-12-02 17:57:39 -080027#include <compositionengine/mock/DisplaySurface.h>
Lloyd Piquedf336d92019-03-07 21:38:42 -080028#include <compositionengine/mock/LayerFE.h>
chaviw8beb4142019-04-11 13:09:05 -070029#include <compositionengine/mock/NativeWindow.h>
Lloyd Pique66d68602019-02-13 14:23:31 -080030#include <compositionengine/mock/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070031#include <compositionengine/mock/RenderSurface.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070032#include <gtest/gtest.h>
Lloyd Piquee9eff972020-05-05 12:36:44 -070033#include <renderengine/mock/RenderEngine.h>
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070034#include <ui/Rect.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010035#include <ui/StaticDisplayInfo.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070036
Lloyd Pique66d68602019-02-13 14:23:31 -080037#include "MockHWC2.h"
Lloyd Pique45a165a2018-10-19 11:54:47 -070038#include "MockHWComposer.h"
Lloyd Pique688abd42019-02-15 15:42:24 -080039#include "MockPowerAdvisor.h"
Lloyd Pique45a165a2018-10-19 11:54:47 -070040
41namespace android::compositionengine {
42namespace {
43
Peiyong Line9d809e2020-04-14 13:10:48 -070044namespace hal = android::hardware::graphics::composer::hal;
45
Lloyd Piquef5275482019-01-29 18:42:42 -080046using testing::_;
Lloyd Pique66d68602019-02-13 14:23:31 -080047using testing::DoAll;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070048using testing::Eq;
Lloyd Piquec6607552019-12-02 17:57:39 -080049using testing::InSequence;
50using testing::NiceMock;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070051using testing::Pointee;
52using testing::Ref;
Lloyd Pique31cb2942018-10-19 17:23:03 -070053using testing::Return;
Lloyd Pique45a165a2018-10-19 11:54:47 -070054using testing::ReturnRef;
Lloyd Pique66d68602019-02-13 14:23:31 -080055using testing::Sequence;
56using testing::SetArgPointee;
Lloyd Pique45a165a2018-10-19 11:54:47 -070057using testing::StrictMock;
58
Dominik Laskowski3dce4f42021-03-08 20:48:28 -080059constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(123u);
60constexpr HalVirtualDisplayId HAL_VIRTUAL_DISPLAY_ID{456u};
61constexpr GpuVirtualDisplayId GPU_VIRTUAL_DISPLAY_ID{789u};
Dominik Laskowskif1833852021-03-23 15:06:50 -070062
Dominik Laskowski3dce4f42021-03-08 20:48:28 -080063constexpr ui::Size DEFAULT_RESOLUTION{1920, 1080};
64constexpr uint32_t DEFAULT_LAYER_STACK = 42;
Lloyd Pique45a165a2018-10-19 11:54:47 -070065
Lloyd Piquede196652020-01-22 17:29:58 -080066struct Layer {
67 Layer() {
68 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
69 EXPECT_CALL(*outputLayer, getHwcLayer()).WillRepeatedly(Return(&hwc2Layer));
70 }
71
72 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
73 StrictMock<mock::OutputLayer>* outputLayer = new StrictMock<mock::OutputLayer>();
74 StrictMock<HWC2::mock::Layer> hwc2Layer;
75};
76
77struct LayerNoHWC2Layer {
78 LayerNoHWC2Layer() {
79 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
80 EXPECT_CALL(*outputLayer, getHwcLayer()).WillRepeatedly(Return(nullptr));
81 }
82
83 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
84 StrictMock<mock::OutputLayer>* outputLayer = new StrictMock<mock::OutputLayer>();
85};
86
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070087struct DisplayTestCommon : public testing::Test {
88 // Uses the full implementation of a display
89 class FullImplDisplay : public impl::Display {
Lloyd Pique01c77c12019-04-17 12:48:32 -070090 public:
Lloyd Pique01c77c12019-04-17 12:48:32 -070091 using impl::Display::injectOutputLayerForTest;
92 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
93 };
94
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070095 // Uses a special implementation with key internal member functions set up
96 // as mock implementations, to allow for easier testing.
97 struct PartialMockDisplay : public impl::Display {
98 PartialMockDisplay(const compositionengine::CompositionEngine& compositionEngine)
99 : mCompositionEngine(compositionEngine) {}
100
101 // compositionengine::Output overrides
102 const OutputCompositionState& getState() const override { return mState; }
103 OutputCompositionState& editState() override { return mState; }
104
105 // compositionengine::impl::Output overrides
106 const CompositionEngine& getCompositionEngine() const override {
107 return mCompositionEngine;
108 };
109
110 // Mock implementation overrides
111 MOCK_CONST_METHOD0(getOutputLayerCount, size_t());
112 MOCK_CONST_METHOD1(getOutputLayerOrderedByZByIndex,
113 compositionengine::OutputLayer*(size_t));
114 MOCK_METHOD2(ensureOutputLayer,
115 compositionengine::OutputLayer*(std::optional<size_t>, const sp<LayerFE>&));
116 MOCK_METHOD0(finalizePendingOutputLayers, void());
117 MOCK_METHOD0(clearOutputLayers, void());
118 MOCK_CONST_METHOD1(dumpState, void(std::string&));
119 MOCK_METHOD1(injectOutputLayerForTest, compositionengine::OutputLayer*(const sp<LayerFE>&));
120 MOCK_METHOD1(injectOutputLayerForTest, void(std::unique_ptr<OutputLayer>));
121 MOCK_CONST_METHOD0(anyLayersRequireClientComposition, bool());
122 MOCK_CONST_METHOD0(allLayersRequireClientComposition, bool());
123 MOCK_METHOD1(applyChangedTypesToLayers, void(const impl::Display::ChangedTypes&));
124 MOCK_METHOD1(applyDisplayRequests, void(const impl::Display::DisplayRequests&));
125 MOCK_METHOD1(applyLayerRequestsToLayers, void(const impl::Display::LayerRequests&));
126
127 const compositionengine::CompositionEngine& mCompositionEngine;
128 impl::OutputCompositionState mState;
129 };
130
131 static std::string getDisplayNameFromCurrentTest() {
132 const ::testing::TestInfo* const test_info =
133 ::testing::UnitTest::GetInstance()->current_test_info();
134 return std::string("display for ") + test_info->test_case_name() + "." + test_info->name();
135 }
136
137 template <typename Display>
Lloyd Pique01c77c12019-04-17 12:48:32 -0700138 static std::shared_ptr<Display> createDisplay(
139 const compositionengine::CompositionEngine& compositionEngine,
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700140 compositionengine::DisplayCreationArgs args) {
141 args.name = getDisplayNameFromCurrentTest();
Lloyd Pique01c77c12019-04-17 12:48:32 -0700142 return impl::createDisplayTemplated<Display>(compositionEngine, args);
143 }
144
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700145 template <typename Display>
146 static std::shared_ptr<StrictMock<Display>> createPartialMockDisplay(
147 const compositionengine::CompositionEngine& compositionEngine,
148 compositionengine::DisplayCreationArgs args) {
149 args.name = getDisplayNameFromCurrentTest();
150 auto display = std::make_shared<StrictMock<Display>>(compositionEngine);
Lloyd Pique66d68602019-02-13 14:23:31 -0800151
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700152 display->setConfiguration(args);
153
154 return display;
155 }
156
157 DisplayTestCommon() {
158 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
Lloyd Piquee9eff972020-05-05 12:36:44 -0700159 EXPECT_CALL(mCompositionEngine, getRenderEngine()).WillRepeatedly(ReturnRef(mRenderEngine));
160 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -0700161 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700162 }
163
164 DisplayCreationArgs getDisplayCreationArgsForPhysicalHWCDisplay() {
165 return DisplayCreationArgsBuilder()
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800166 .setId(DEFAULT_DISPLAY_ID)
167 .setConnectionType(ui::DisplayConnectionType::Internal)
168 .setPixels(DEFAULT_RESOLUTION)
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700169 .setIsSecure(true)
170 .setLayerStackId(DEFAULT_LAYER_STACK)
171 .setPowerAdvisor(&mPowerAdvisor)
172 .build();
173 }
174
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800175 DisplayCreationArgs getDisplayCreationArgsForGpuVirtualDisplay() {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700176 return DisplayCreationArgsBuilder()
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800177 .setId(GPU_VIRTUAL_DISPLAY_ID)
178 .setPixels(DEFAULT_RESOLUTION)
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700179 .setIsSecure(false)
180 .setLayerStackId(DEFAULT_LAYER_STACK)
181 .setPowerAdvisor(&mPowerAdvisor)
182 .build();
183 }
184
185 StrictMock<android::mock::HWComposer> mHwComposer;
186 StrictMock<Hwc2::mock::PowerAdvisor> mPowerAdvisor;
Lloyd Piquee9eff972020-05-05 12:36:44 -0700187 StrictMock<renderengine::mock::RenderEngine> mRenderEngine;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700188 StrictMock<mock::CompositionEngine> mCompositionEngine;
189 sp<mock::NativeWindow> mNativeWindow = new StrictMock<mock::NativeWindow>();
190};
191
192struct PartialMockDisplayTestCommon : public DisplayTestCommon {
193 using Display = DisplayTestCommon::PartialMockDisplay;
194 std::shared_ptr<Display> mDisplay =
195 createPartialMockDisplay<Display>(mCompositionEngine,
196 getDisplayCreationArgsForPhysicalHWCDisplay());
197};
198
199struct FullDisplayImplTestCommon : public DisplayTestCommon {
200 using Display = DisplayTestCommon::FullImplDisplay;
201 std::shared_ptr<Display> mDisplay =
202 createDisplay<Display>(mCompositionEngine,
203 getDisplayCreationArgsForPhysicalHWCDisplay());
204};
205
206struct DisplayWithLayersTestCommon : public FullDisplayImplTestCommon {
207 DisplayWithLayersTestCommon() {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700208 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -0800209 std::unique_ptr<compositionengine::OutputLayer>(mLayer1.outputLayer));
Lloyd Pique01c77c12019-04-17 12:48:32 -0700210 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -0800211 std::unique_ptr<compositionengine::OutputLayer>(mLayer2.outputLayer));
Lloyd Pique01c77c12019-04-17 12:48:32 -0700212 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -0800213 std::unique_ptr<compositionengine::OutputLayer>(mLayer3.outputLayer));
Lloyd Pique66d68602019-02-13 14:23:31 -0800214 }
Lloyd Pique45a165a2018-10-19 11:54:47 -0700215
Lloyd Piquede196652020-01-22 17:29:58 -0800216 Layer mLayer1;
217 Layer mLayer2;
218 LayerNoHWC2Layer mLayer3;
219 StrictMock<HWC2::mock::Layer> hwc2LayerUnknown;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700220 std::shared_ptr<Display> mDisplay =
221 createDisplay<Display>(mCompositionEngine,
222 getDisplayCreationArgsForPhysicalHWCDisplay());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700223};
224
Lloyd Pique66d68602019-02-13 14:23:31 -0800225/*
Lloyd Pique45a165a2018-10-19 11:54:47 -0700226 * Basic construction
227 */
228
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700229struct DisplayCreationTest : public DisplayTestCommon {
230 using Display = DisplayTestCommon::FullImplDisplay;
231};
Lloyd Pique45a165a2018-10-19 11:54:47 -0700232
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700233TEST_F(DisplayCreationTest, createPhysicalInternalDisplay) {
234 auto display =
235 impl::createDisplay(mCompositionEngine, getDisplayCreationArgsForPhysicalHWCDisplay());
236 EXPECT_TRUE(display->isSecure());
237 EXPECT_FALSE(display->isVirtual());
238 EXPECT_EQ(DEFAULT_DISPLAY_ID, display->getId());
239}
Lloyd Pique45a165a2018-10-19 11:54:47 -0700240
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800241TEST_F(DisplayCreationTest, createGpuVirtualDisplay) {
242 auto display =
243 impl::createDisplay(mCompositionEngine, getDisplayCreationArgsForGpuVirtualDisplay());
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700244 EXPECT_FALSE(display->isSecure());
245 EXPECT_TRUE(display->isVirtual());
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200246 EXPECT_TRUE(GpuVirtualDisplayId::tryCast(display->getId()));
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700247}
248
249/*
250 * Display::setConfiguration()
251 */
252
253using DisplaySetConfigurationTest = PartialMockDisplayTestCommon;
254
255TEST_F(DisplaySetConfigurationTest, configuresInternalSecurePhysicalDisplay) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800256 mDisplay->setConfiguration(DisplayCreationArgsBuilder()
257 .setId(DEFAULT_DISPLAY_ID)
258 .setConnectionType(ui::DisplayConnectionType::Internal)
259 .setPixels(DEFAULT_RESOLUTION)
260 .setIsSecure(true)
261 .setLayerStackId(DEFAULT_LAYER_STACK)
262 .setPowerAdvisor(&mPowerAdvisor)
263 .setName(getDisplayNameFromCurrentTest())
264 .build());
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700265
266 EXPECT_EQ(DEFAULT_DISPLAY_ID, mDisplay->getId());
267 EXPECT_TRUE(mDisplay->isSecure());
268 EXPECT_FALSE(mDisplay->isVirtual());
269 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
270 EXPECT_TRUE(mDisplay->getState().layerStackInternal);
271 EXPECT_FALSE(mDisplay->isValid());
272}
273
274TEST_F(DisplaySetConfigurationTest, configuresExternalInsecurePhysicalDisplay) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800275 mDisplay->setConfiguration(DisplayCreationArgsBuilder()
276 .setId(DEFAULT_DISPLAY_ID)
277 .setConnectionType(ui::DisplayConnectionType::External)
278 .setPixels(DEFAULT_RESOLUTION)
279 .setIsSecure(false)
280 .setLayerStackId(DEFAULT_LAYER_STACK)
281 .setPowerAdvisor(&mPowerAdvisor)
282 .setName(getDisplayNameFromCurrentTest())
283 .build());
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700284
285 EXPECT_EQ(DEFAULT_DISPLAY_ID, mDisplay->getId());
286 EXPECT_FALSE(mDisplay->isSecure());
287 EXPECT_FALSE(mDisplay->isVirtual());
288 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
289 EXPECT_FALSE(mDisplay->getState().layerStackInternal);
290 EXPECT_FALSE(mDisplay->isValid());
291}
292
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800293TEST_F(DisplaySetConfigurationTest, configuresHalVirtualDisplay) {
294 mDisplay->setConfiguration(DisplayCreationArgsBuilder()
295 .setId(HAL_VIRTUAL_DISPLAY_ID)
296 .setPixels(DEFAULT_RESOLUTION)
297 .setIsSecure(false)
298 .setLayerStackId(DEFAULT_LAYER_STACK)
299 .setPowerAdvisor(&mPowerAdvisor)
300 .setName(getDisplayNameFromCurrentTest())
301 .build());
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700302
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800303 EXPECT_EQ(HAL_VIRTUAL_DISPLAY_ID, mDisplay->getId());
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700304 EXPECT_FALSE(mDisplay->isSecure());
305 EXPECT_TRUE(mDisplay->isVirtual());
306 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
307 EXPECT_FALSE(mDisplay->getState().layerStackInternal);
308 EXPECT_FALSE(mDisplay->isValid());
309}
310
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800311TEST_F(DisplaySetConfigurationTest, configuresGpuVirtualDisplay) {
312 mDisplay->setConfiguration(DisplayCreationArgsBuilder()
313 .setId(GPU_VIRTUAL_DISPLAY_ID)
314 .setPixels(DEFAULT_RESOLUTION)
315 .setIsSecure(false)
316 .setLayerStackId(DEFAULT_LAYER_STACK)
317 .setPowerAdvisor(&mPowerAdvisor)
318 .setName(getDisplayNameFromCurrentTest())
319 .build());
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700320
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800321 EXPECT_EQ(GPU_VIRTUAL_DISPLAY_ID, mDisplay->getId());
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700322 EXPECT_FALSE(mDisplay->isSecure());
323 EXPECT_TRUE(mDisplay->isVirtual());
324 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
325 EXPECT_FALSE(mDisplay->getState().layerStackInternal);
326 EXPECT_FALSE(mDisplay->isValid());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700327}
328
Lloyd Pique66d68602019-02-13 14:23:31 -0800329/*
Lloyd Pique45a165a2018-10-19 11:54:47 -0700330 * Display::disconnect()
331 */
332
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700333using DisplayDisconnectTest = PartialMockDisplayTestCommon;
334
335TEST_F(DisplayDisconnectTest, disconnectsDisplay) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200336 // The first call to disconnect will disconnect the display with the HWC.
337 EXPECT_CALL(mHwComposer, disconnectDisplay(HalDisplayId(DEFAULT_DISPLAY_ID))).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700338 mDisplay->disconnect();
Lloyd Pique45a165a2018-10-19 11:54:47 -0700339
340 // Subsequent calls will do nothing,
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200341 EXPECT_CALL(mHwComposer, disconnectDisplay(HalDisplayId(DEFAULT_DISPLAY_ID))).Times(0);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700342 mDisplay->disconnect();
Lloyd Pique45a165a2018-10-19 11:54:47 -0700343}
344
Lloyd Pique66d68602019-02-13 14:23:31 -0800345/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700346 * Display::setColorTransform()
347 */
348
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700349using DisplaySetColorTransformTest = PartialMockDisplayTestCommon;
350
351TEST_F(DisplaySetColorTransformTest, setsTransform) {
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800352 // No change does nothing
353 CompositionRefreshArgs refreshArgs;
354 refreshArgs.colorTransformMatrix = std::nullopt;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700355 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800356
Lloyd Pique32cbe282018-10-19 13:09:22 -0700357 // Identity matrix sets an identity state value
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800358 const mat4 kIdentity;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700359
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200360 EXPECT_CALL(mHwComposer, setColorTransform(HalDisplayId(DEFAULT_DISPLAY_ID), kIdentity))
361 .Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700362
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800363 refreshArgs.colorTransformMatrix = kIdentity;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700364 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700365
366 // Non-identity matrix sets a non-identity state value
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800367 const mat4 kNonIdentity = mat4() * 2;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700368
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200369 EXPECT_CALL(mHwComposer, setColorTransform(HalDisplayId(DEFAULT_DISPLAY_ID), kNonIdentity))
370 .Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700371
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800372 refreshArgs.colorTransformMatrix = kNonIdentity;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700373 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700374}
375
Lloyd Pique66d68602019-02-13 14:23:31 -0800376/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700377 * Display::setColorMode()
378 */
379
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700380using DisplaySetColorModeTest = PartialMockDisplayTestCommon;
381
382TEST_F(DisplaySetColorModeTest, setsModeUnlessNoChange) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800383 using ColorProfile = Output::ColorProfile;
384
Lloyd Pique31cb2942018-10-19 17:23:03 -0700385 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700386 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piquef5275482019-01-29 18:42:42 -0800387 mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700388 mDisplay->setDisplayColorProfileForTest(std::unique_ptr<DisplayColorProfile>(colorProfile));
Lloyd Pique31cb2942018-10-19 17:23:03 -0700389
Lloyd Piquef5275482019-01-29 18:42:42 -0800390 EXPECT_CALL(*colorProfile, getTargetDataspace(_, _, _))
391 .WillRepeatedly(Return(ui::Dataspace::UNKNOWN));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700392
393 // These values are expected to be the initial state.
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700394 ASSERT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
395 ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
396 ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
397 ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700398
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700399 // Otherwise if the values are unchanged, nothing happens
400 mDisplay->setColorProfile(ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
401 ui::RenderIntent::COLORIMETRIC, ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700402
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700403 EXPECT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
404 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
405 EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
406 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700407
408 // Otherwise if the values are different, updates happen
Lloyd Piqueef958122019-02-05 18:00:12 -0800409 EXPECT_CALL(*renderSurface, setBufferDataspace(ui::Dataspace::DISPLAY_P3)).Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700410 EXPECT_CALL(mHwComposer,
Lloyd Piqueef958122019-02-05 18:00:12 -0800411 setActiveColorMode(DEFAULT_DISPLAY_ID, ui::ColorMode::DISPLAY_P3,
Lloyd Pique32cbe282018-10-19 13:09:22 -0700412 ui::RenderIntent::TONE_MAP_COLORIMETRIC))
413 .Times(1);
414
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700415 mDisplay->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
416 ui::RenderIntent::TONE_MAP_COLORIMETRIC,
417 ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700418
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700419 EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mDisplay->getState().colorMode);
420 EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mDisplay->getState().dataspace);
421 EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mDisplay->getState().renderIntent);
422 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700423}
424
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700425TEST_F(DisplaySetColorModeTest, doesNothingForVirtualDisplay) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800426 using ColorProfile = Output::ColorProfile;
427
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800428 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700429 std::shared_ptr<impl::Display> virtualDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700430
Lloyd Piquef5275482019-01-29 18:42:42 -0800431 mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700432 virtualDisplay->setDisplayColorProfileForTest(
Lloyd Piquef5275482019-01-29 18:42:42 -0800433 std::unique_ptr<DisplayColorProfile>(colorProfile));
434
435 EXPECT_CALL(*colorProfile,
436 getTargetDataspace(ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
437 ui::Dataspace::UNKNOWN))
438 .WillOnce(Return(ui::Dataspace::UNKNOWN));
439
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700440 virtualDisplay->setColorProfile(
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800441 ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
442 ui::RenderIntent::TONE_MAP_COLORIMETRIC, ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700443
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700444 EXPECT_EQ(ui::ColorMode::NATIVE, virtualDisplay->getState().colorMode);
445 EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().dataspace);
446 EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, virtualDisplay->getState().renderIntent);
447 EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700448}
449
Lloyd Pique66d68602019-02-13 14:23:31 -0800450/*
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700451 * Display::createDisplayColorProfile()
452 */
453
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700454using DisplayCreateColorProfileTest = PartialMockDisplayTestCommon;
455
456TEST_F(DisplayCreateColorProfileTest, setsDisplayColorProfile) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700457 EXPECT_TRUE(mDisplay->getDisplayColorProfile() == nullptr);
458 mDisplay->createDisplayColorProfile(
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700459 DisplayColorProfileCreationArgs{false, HdrCapabilities(), 0,
460 DisplayColorProfileCreationArgs::HwcColorModes()});
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700461 EXPECT_TRUE(mDisplay->getDisplayColorProfile() != nullptr);
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700462}
463
Lloyd Pique66d68602019-02-13 14:23:31 -0800464/*
Lloyd Pique31cb2942018-10-19 17:23:03 -0700465 * Display::createRenderSurface()
466 */
467
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700468using DisplayCreateRenderSurfaceTest = PartialMockDisplayTestCommon;
469
470TEST_F(DisplayCreateRenderSurfaceTest, setsRenderSurface) {
chaviw8beb4142019-04-11 13:09:05 -0700471 EXPECT_CALL(*mNativeWindow, disconnect(NATIVE_WINDOW_API_EGL)).WillRepeatedly(Return(NO_ERROR));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700472 EXPECT_TRUE(mDisplay->getRenderSurface() == nullptr);
Dominik Laskowski50121d52021-04-23 13:01:16 -0700473 mDisplay->createRenderSurface(RenderSurfaceCreationArgsBuilder()
474 .setDisplayWidth(640)
475 .setDisplayHeight(480)
476 .setNativeWindow(mNativeWindow)
477 .build());
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700478 EXPECT_TRUE(mDisplay->getRenderSurface() != nullptr);
Lloyd Pique31cb2942018-10-19 17:23:03 -0700479}
480
Lloyd Pique66d68602019-02-13 14:23:31 -0800481/*
Lloyd Piquedf336d92019-03-07 21:38:42 -0800482 * Display::createOutputLayer()
483 */
484
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700485using DisplayCreateOutputLayerTest = FullDisplayImplTestCommon;
486
487TEST_F(DisplayCreateOutputLayerTest, setsHwcLayer) {
Lloyd Piquedf336d92019-03-07 21:38:42 -0800488 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
Lloyd Piquea516c002021-05-07 14:36:58 -0700489 auto hwcLayer = std::make_shared<StrictMock<HWC2::mock::Layer>>();
Lloyd Piquedf336d92019-03-07 21:38:42 -0800490
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200491 EXPECT_CALL(mHwComposer, createLayer(HalDisplayId(DEFAULT_DISPLAY_ID)))
Lloyd Piquea516c002021-05-07 14:36:58 -0700492 .WillOnce(Return(hwcLayer));
Lloyd Piquedf336d92019-03-07 21:38:42 -0800493
Lloyd Piquede196652020-01-22 17:29:58 -0800494 auto outputLayer = mDisplay->createOutputLayer(layerFE);
Lloyd Piquedf336d92019-03-07 21:38:42 -0800495
Lloyd Piquea516c002021-05-07 14:36:58 -0700496 EXPECT_EQ(hwcLayer.get(), outputLayer->getHwcLayer());
Lloyd Piquedf336d92019-03-07 21:38:42 -0800497
Lloyd Piquedf336d92019-03-07 21:38:42 -0800498 outputLayer.reset();
499}
500
501/*
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800502 * Display::setReleasedLayers()
503 */
504
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700505using DisplaySetReleasedLayersTest = DisplayWithLayersTestCommon;
506
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800507TEST_F(DisplaySetReleasedLayersTest, doesNothingIfGpuDisplay) {
508 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
509 std::shared_ptr<impl::Display> gpuDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800510
511 sp<mock::LayerFE> layerXLayerFE = new StrictMock<mock::LayerFE>();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800512
513 {
514 Output::ReleasedLayers releasedLayers;
515 releasedLayers.emplace_back(layerXLayerFE);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800516 gpuDisplay->setReleasedLayers(std::move(releasedLayers));
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800517 }
518
519 CompositionRefreshArgs refreshArgs;
Lloyd Piquede196652020-01-22 17:29:58 -0800520 refreshArgs.layersWithQueuedFrames.push_back(layerXLayerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800521
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800522 gpuDisplay->setReleasedLayers(refreshArgs);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800523
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800524 const auto& releasedLayers = gpuDisplay->getReleasedLayersForTest();
525 ASSERT_EQ(1u, releasedLayers.size());
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800526}
527
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700528TEST_F(DisplaySetReleasedLayersTest, doesNothingIfNoLayersWithQueuedFrames) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800529 sp<mock::LayerFE> layerXLayerFE = new StrictMock<mock::LayerFE>();
530
531 {
532 Output::ReleasedLayers releasedLayers;
533 releasedLayers.emplace_back(layerXLayerFE);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700534 mDisplay->setReleasedLayers(std::move(releasedLayers));
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800535 }
536
537 CompositionRefreshArgs refreshArgs;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700538 mDisplay->setReleasedLayers(refreshArgs);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800539
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700540 const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800541 ASSERT_EQ(1u, releasedLayers.size());
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800542}
543
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700544TEST_F(DisplaySetReleasedLayersTest, setReleasedLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800545 sp<mock::LayerFE> unknownLayer = new StrictMock<mock::LayerFE>();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800546
547 CompositionRefreshArgs refreshArgs;
Lloyd Piquede196652020-01-22 17:29:58 -0800548 refreshArgs.layersWithQueuedFrames.push_back(mLayer1.layerFE);
549 refreshArgs.layersWithQueuedFrames.push_back(mLayer2.layerFE);
550 refreshArgs.layersWithQueuedFrames.push_back(unknownLayer);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800551
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700552 mDisplay->setReleasedLayers(refreshArgs);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800553
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700554 const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800555 ASSERT_EQ(2u, releasedLayers.size());
Lloyd Piquede196652020-01-22 17:29:58 -0800556 ASSERT_EQ(mLayer1.layerFE.get(), releasedLayers[0].promote().get());
557 ASSERT_EQ(mLayer2.layerFE.get(), releasedLayers[1].promote().get());
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800558}
559
560/*
Lloyd Pique66d68602019-02-13 14:23:31 -0800561 * Display::chooseCompositionStrategy()
562 */
563
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700564using DisplayChooseCompositionStrategyTest = PartialMockDisplayTestCommon;
Lloyd Pique66d68602019-02-13 14:23:31 -0800565
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800566TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutIfGpuDisplay) {
567 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
568 std::shared_ptr<Display> gpuDisplay =
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700569 createPartialMockDisplay<Display>(mCompositionEngine, args);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800570 EXPECT_TRUE(GpuVirtualDisplayId::tryCast(gpuDisplay->getId()));
Lloyd Pique66d68602019-02-13 14:23:31 -0800571
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800572 gpuDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800573
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800574 auto& state = gpuDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800575 EXPECT_TRUE(state.usesClientComposition);
576 EXPECT_FALSE(state.usesDeviceComposition);
577}
578
579TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutOnHwcError) {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700580 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition()).WillOnce(Return(false));
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200581 EXPECT_CALL(mHwComposer,
582 getDeviceCompositionChanges(HalDisplayId(DEFAULT_DISPLAY_ID), false, _))
Lloyd Pique66d68602019-02-13 14:23:31 -0800583 .WillOnce(Return(INVALID_OPERATION));
584
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700585 mDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800586
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700587 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800588 EXPECT_TRUE(state.usesClientComposition);
589 EXPECT_FALSE(state.usesDeviceComposition);
590}
591
592TEST_F(DisplayChooseCompositionStrategyTest, normalOperation) {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700593 // Since two calls are made to anyLayersRequireClientComposition with different return
594 // values, use a Sequence to control the matching so the values are returned in a known
595 // order.
Lloyd Pique66d68602019-02-13 14:23:31 -0800596 Sequence s;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700597 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
598 .InSequence(s)
599 .WillOnce(Return(true));
600 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
Lloyd Pique66d68602019-02-13 14:23:31 -0800601 .InSequence(s)
602 .WillOnce(Return(false));
603
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200604 EXPECT_CALL(mHwComposer, getDeviceCompositionChanges(HalDisplayId(DEFAULT_DISPLAY_ID), true, _))
Lloyd Pique66d68602019-02-13 14:23:31 -0800605 .WillOnce(Return(NO_ERROR));
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700606 EXPECT_CALL(*mDisplay, allLayersRequireClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800607
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700608 mDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800609
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700610 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800611 EXPECT_FALSE(state.usesClientComposition);
612 EXPECT_TRUE(state.usesDeviceComposition);
613}
614
615TEST_F(DisplayChooseCompositionStrategyTest, normalOperationWithChanges) {
616 android::HWComposer::DeviceRequestedChanges changes{
Peiyong Line9d809e2020-04-14 13:10:48 -0700617 {{nullptr, hal::Composition::CLIENT}},
618 hal::DisplayRequest::FLIP_CLIENT_TARGET,
619 {{nullptr, hal::LayerRequest::CLEAR_CLIENT_TARGET}},
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700620 {hal::PixelFormat::RGBA_8888, hal::Dataspace::UNKNOWN},
Lloyd Pique66d68602019-02-13 14:23:31 -0800621 };
622
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700623 // Since two calls are made to anyLayersRequireClientComposition with different return
624 // values, use a Sequence to control the matching so the values are returned in a known
625 // order.
Lloyd Pique66d68602019-02-13 14:23:31 -0800626 Sequence s;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700627 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
628 .InSequence(s)
629 .WillOnce(Return(true));
630 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
Lloyd Pique66d68602019-02-13 14:23:31 -0800631 .InSequence(s)
632 .WillOnce(Return(false));
633
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200634 EXPECT_CALL(mHwComposer, getDeviceCompositionChanges(HalDisplayId(DEFAULT_DISPLAY_ID), true, _))
Lloyd Pique66d68602019-02-13 14:23:31 -0800635 .WillOnce(DoAll(SetArgPointee<2>(changes), Return(NO_ERROR)));
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700636 EXPECT_CALL(*mDisplay, applyChangedTypesToLayers(changes.changedTypes)).Times(1);
637 EXPECT_CALL(*mDisplay, applyDisplayRequests(changes.displayRequests)).Times(1);
638 EXPECT_CALL(*mDisplay, applyLayerRequestsToLayers(changes.layerRequests)).Times(1);
639 EXPECT_CALL(*mDisplay, allLayersRequireClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800640
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700641 mDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800642
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700643 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800644 EXPECT_FALSE(state.usesClientComposition);
645 EXPECT_TRUE(state.usesDeviceComposition);
646}
647
648/*
Lloyd Pique688abd42019-02-15 15:42:24 -0800649 * Display::getSkipColorTransform()
650 */
651
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700652using DisplayGetSkipColorTransformTest = DisplayWithLayersTestCommon;
653
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800654TEST_F(DisplayGetSkipColorTransformTest, checksCapabilityIfGpuDisplay) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700655 EXPECT_CALL(mHwComposer, hasCapability(hal::Capability::SKIP_CLIENT_COLOR_TRANSFORM))
Dominik Laskowski1162e472020-04-02 19:02:47 -0700656 .WillOnce(Return(true));
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800657 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
658 auto gpuDisplay{impl::createDisplay(mCompositionEngine, args)};
659 EXPECT_TRUE(gpuDisplay->getSkipColorTransform());
Lloyd Pique688abd42019-02-15 15:42:24 -0800660}
661
Dominik Laskowski1162e472020-04-02 19:02:47 -0700662TEST_F(DisplayGetSkipColorTransformTest, checksDisplayCapability) {
Lloyd Pique688abd42019-02-15 15:42:24 -0800663 EXPECT_CALL(mHwComposer,
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200664 hasDisplayCapability(HalDisplayId(DEFAULT_DISPLAY_ID),
Peiyong Line9d809e2020-04-14 13:10:48 -0700665 hal::DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM))
Lloyd Pique688abd42019-02-15 15:42:24 -0800666 .WillOnce(Return(true));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700667 EXPECT_TRUE(mDisplay->getSkipColorTransform());
Lloyd Pique688abd42019-02-15 15:42:24 -0800668}
669
670/*
Lloyd Pique66d68602019-02-13 14:23:31 -0800671 * Display::anyLayersRequireClientComposition()
672 */
673
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700674using DisplayAnyLayersRequireClientCompositionTest = DisplayWithLayersTestCommon;
675
676TEST_F(DisplayAnyLayersRequireClientCompositionTest, returnsFalse) {
Lloyd Piquede196652020-01-22 17:29:58 -0800677 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(false));
678 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(false));
679 EXPECT_CALL(*mLayer3.outputLayer, requiresClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800680
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700681 EXPECT_FALSE(mDisplay->anyLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800682}
683
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700684TEST_F(DisplayAnyLayersRequireClientCompositionTest, returnsTrue) {
Lloyd Piquede196652020-01-22 17:29:58 -0800685 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(false));
686 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(true));
Lloyd Pique66d68602019-02-13 14:23:31 -0800687
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700688 EXPECT_TRUE(mDisplay->anyLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800689}
690
691/*
692 * Display::allLayersRequireClientComposition()
693 */
694
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700695using DisplayAllLayersRequireClientCompositionTest = DisplayWithLayersTestCommon;
696
697TEST_F(DisplayAllLayersRequireClientCompositionTest, returnsTrue) {
Lloyd Piquede196652020-01-22 17:29:58 -0800698 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(true));
699 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(true));
700 EXPECT_CALL(*mLayer3.outputLayer, requiresClientComposition()).WillOnce(Return(true));
Lloyd Pique66d68602019-02-13 14:23:31 -0800701
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700702 EXPECT_TRUE(mDisplay->allLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800703}
704
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700705TEST_F(DisplayAllLayersRequireClientCompositionTest, returnsFalse) {
Lloyd Piquede196652020-01-22 17:29:58 -0800706 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(true));
707 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800708
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700709 EXPECT_FALSE(mDisplay->allLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800710}
711
712/*
713 * Display::applyChangedTypesToLayers()
714 */
715
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700716using DisplayApplyChangedTypesToLayersTest = DisplayWithLayersTestCommon;
717
718TEST_F(DisplayApplyChangedTypesToLayersTest, takesEarlyOutIfNoChangedLayers) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700719 mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes());
Lloyd Pique66d68602019-02-13 14:23:31 -0800720}
721
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700722TEST_F(DisplayApplyChangedTypesToLayersTest, appliesChanges) {
Lloyd Piquede196652020-01-22 17:29:58 -0800723 EXPECT_CALL(*mLayer1.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800724 applyDeviceCompositionTypeChange(Hwc2::IComposerClient::Composition::CLIENT))
725 .Times(1);
Lloyd Piquede196652020-01-22 17:29:58 -0800726 EXPECT_CALL(*mLayer2.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800727 applyDeviceCompositionTypeChange(Hwc2::IComposerClient::Composition::DEVICE))
728 .Times(1);
729
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700730 mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes{
Peiyong Line9d809e2020-04-14 13:10:48 -0700731 {&mLayer1.hwc2Layer, hal::Composition::CLIENT},
732 {&mLayer2.hwc2Layer, hal::Composition::DEVICE},
733 {&hwc2LayerUnknown, hal::Composition::SOLID_COLOR},
Lloyd Pique66d68602019-02-13 14:23:31 -0800734 });
735}
736
737/*
738 * Display::applyDisplayRequests()
739 */
740
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700741using DisplayApplyDisplayRequestsTest = DisplayWithLayersTestCommon;
742
743TEST_F(DisplayApplyDisplayRequestsTest, handlesNoRequests) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700744 mDisplay->applyDisplayRequests(static_cast<hal::DisplayRequest>(0));
Lloyd Pique66d68602019-02-13 14:23:31 -0800745
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700746 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800747 EXPECT_FALSE(state.flipClientTarget);
748}
749
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700750TEST_F(DisplayApplyDisplayRequestsTest, handlesFlipClientTarget) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700751 mDisplay->applyDisplayRequests(hal::DisplayRequest::FLIP_CLIENT_TARGET);
Lloyd Pique66d68602019-02-13 14:23:31 -0800752
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700753 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800754 EXPECT_TRUE(state.flipClientTarget);
755}
756
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700757TEST_F(DisplayApplyDisplayRequestsTest, handlesWriteClientTargetToOutput) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700758 mDisplay->applyDisplayRequests(hal::DisplayRequest::WRITE_CLIENT_TARGET_TO_OUTPUT);
Lloyd Pique66d68602019-02-13 14:23:31 -0800759
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700760 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800761 EXPECT_FALSE(state.flipClientTarget);
762}
763
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700764TEST_F(DisplayApplyDisplayRequestsTest, handlesAllRequestFlagsSet) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700765 mDisplay->applyDisplayRequests(static_cast<hal::DisplayRequest>(~0));
Lloyd Pique66d68602019-02-13 14:23:31 -0800766
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700767 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800768 EXPECT_TRUE(state.flipClientTarget);
769}
770
771/*
772 * Display::applyLayerRequestsToLayers()
773 */
774
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700775using DisplayApplyLayerRequestsToLayersTest = DisplayWithLayersTestCommon;
776
777TEST_F(DisplayApplyLayerRequestsToLayersTest, preparesAllLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800778 EXPECT_CALL(*mLayer1.outputLayer, prepareForDeviceLayerRequests()).Times(1);
779 EXPECT_CALL(*mLayer2.outputLayer, prepareForDeviceLayerRequests()).Times(1);
780 EXPECT_CALL(*mLayer3.outputLayer, prepareForDeviceLayerRequests()).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800781
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700782 mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests());
Lloyd Pique66d68602019-02-13 14:23:31 -0800783}
784
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700785TEST_F(DisplayApplyLayerRequestsToLayersTest, appliesDeviceLayerRequests) {
Lloyd Piquede196652020-01-22 17:29:58 -0800786 EXPECT_CALL(*mLayer1.outputLayer, prepareForDeviceLayerRequests()).Times(1);
787 EXPECT_CALL(*mLayer2.outputLayer, prepareForDeviceLayerRequests()).Times(1);
788 EXPECT_CALL(*mLayer3.outputLayer, prepareForDeviceLayerRequests()).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800789
Lloyd Piquede196652020-01-22 17:29:58 -0800790 EXPECT_CALL(*mLayer1.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800791 applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest::CLEAR_CLIENT_TARGET))
792 .Times(1);
793
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700794 mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests{
Peiyong Line9d809e2020-04-14 13:10:48 -0700795 {&mLayer1.hwc2Layer, hal::LayerRequest::CLEAR_CLIENT_TARGET},
796 {&hwc2LayerUnknown, hal::LayerRequest::CLEAR_CLIENT_TARGET},
Lloyd Pique66d68602019-02-13 14:23:31 -0800797 });
798}
799
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800800/*
801 * Display::presentAndGetFrameFences()
802 */
803
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700804using DisplayPresentAndGetFrameFencesTest = DisplayWithLayersTestCommon;
805
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800806TEST_F(DisplayPresentAndGetFrameFencesTest, returnsNoFencesOnGpuDisplay) {
807 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
808 auto gpuDisplay{impl::createDisplay(mCompositionEngine, args)};
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800809
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800810 auto result = gpuDisplay->presentAndGetFrameFences();
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800811
812 ASSERT_TRUE(result.presentFence.get());
813 EXPECT_FALSE(result.presentFence->isValid());
814 EXPECT_EQ(0u, result.layerFences.size());
815}
816
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700817TEST_F(DisplayPresentAndGetFrameFencesTest, returnsPresentAndLayerFences) {
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800818 sp<Fence> presentFence = new Fence();
819 sp<Fence> layer1Fence = new Fence();
820 sp<Fence> layer2Fence = new Fence();
821
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200822 EXPECT_CALL(mHwComposer, presentAndGetReleaseFences(HalDisplayId(DEFAULT_DISPLAY_ID))).Times(1);
823 EXPECT_CALL(mHwComposer, getPresentFence(HalDisplayId(DEFAULT_DISPLAY_ID)))
824 .WillOnce(Return(presentFence));
825 EXPECT_CALL(mHwComposer,
826 getLayerReleaseFence(HalDisplayId(DEFAULT_DISPLAY_ID), &mLayer1.hwc2Layer))
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800827 .WillOnce(Return(layer1Fence));
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200828 EXPECT_CALL(mHwComposer,
829 getLayerReleaseFence(HalDisplayId(DEFAULT_DISPLAY_ID), &mLayer2.hwc2Layer))
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800830 .WillOnce(Return(layer2Fence));
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200831 EXPECT_CALL(mHwComposer, clearReleaseFences(HalDisplayId(DEFAULT_DISPLAY_ID))).Times(1);
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800832
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700833 auto result = mDisplay->presentAndGetFrameFences();
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800834
835 EXPECT_EQ(presentFence, result.presentFence);
836
837 EXPECT_EQ(2u, result.layerFences.size());
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800838 ASSERT_EQ(1u, result.layerFences.count(&mLayer1.hwc2Layer));
Lloyd Piquede196652020-01-22 17:29:58 -0800839 EXPECT_EQ(layer1Fence, result.layerFences[&mLayer1.hwc2Layer]);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800840 ASSERT_EQ(1u, result.layerFences.count(&mLayer2.hwc2Layer));
Lloyd Piquede196652020-01-22 17:29:58 -0800841 EXPECT_EQ(layer2Fence, result.layerFences[&mLayer2.hwc2Layer]);
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800842}
843
Lloyd Pique688abd42019-02-15 15:42:24 -0800844/*
845 * Display::setExpensiveRenderingExpected()
846 */
847
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700848using DisplaySetExpensiveRenderingExpectedTest = DisplayWithLayersTestCommon;
849
850TEST_F(DisplaySetExpensiveRenderingExpectedTest, forwardsToPowerAdvisor) {
Lloyd Pique688abd42019-02-15 15:42:24 -0800851 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, true)).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700852 mDisplay->setExpensiveRenderingExpected(true);
Lloyd Pique688abd42019-02-15 15:42:24 -0800853
854 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false)).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700855 mDisplay->setExpensiveRenderingExpected(false);
Lloyd Pique688abd42019-02-15 15:42:24 -0800856}
857
Lloyd Piqued3d69882019-02-28 16:03:46 -0800858/*
859 * Display::finishFrame()
860 */
861
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700862using DisplayFinishFrameTest = DisplayWithLayersTestCommon;
863
864TEST_F(DisplayFinishFrameTest, doesNotSkipCompositionIfNotDirtyOnHwcDisplay) {
Lloyd Piqued3d69882019-02-28 16:03:46 -0800865 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700866 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piqued3d69882019-02-28 16:03:46 -0800867
868 // We expect no calls to queueBuffer if composition was skipped.
869 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
870
Lloyd Piquea76ce462020-01-14 13:06:37 -0800871 // Expect a call to signal no expensive rendering since there is no client composition.
872 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false));
873
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700874 mDisplay->editState().isEnabled = true;
875 mDisplay->editState().usesClientComposition = false;
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200876 mDisplay->editState().layerStackSpace.content = Rect(0, 0, 1, 1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700877 mDisplay->editState().dirtyRegion = Region::INVALID_REGION;
Lloyd Piqued3d69882019-02-28 16:03:46 -0800878
879 CompositionRefreshArgs refreshArgs;
880 refreshArgs.repaintEverything = false;
881
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700882 mDisplay->finishFrame(refreshArgs);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800883}
884
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700885TEST_F(DisplayFinishFrameTest, skipsCompositionIfNotDirty) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800886 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
887 std::shared_ptr<impl::Display> gpuDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800888
889 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800890 gpuDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piqued3d69882019-02-28 16:03:46 -0800891
892 // We expect no calls to queueBuffer if composition was skipped.
893 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(0);
894
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800895 gpuDisplay->editState().isEnabled = true;
896 gpuDisplay->editState().usesClientComposition = false;
897 gpuDisplay->editState().layerStackSpace.content = Rect(0, 0, 1, 1);
898 gpuDisplay->editState().dirtyRegion = Region::INVALID_REGION;
Lloyd Piqued3d69882019-02-28 16:03:46 -0800899
900 CompositionRefreshArgs refreshArgs;
901 refreshArgs.repaintEverything = false;
902
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800903 gpuDisplay->finishFrame(refreshArgs);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800904}
905
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700906TEST_F(DisplayFinishFrameTest, performsCompositionIfDirty) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800907 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
908 std::shared_ptr<impl::Display> gpuDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800909
910 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800911 gpuDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piqued3d69882019-02-28 16:03:46 -0800912
913 // We expect a single call to queueBuffer when composition is not skipped.
914 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
915
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800916 gpuDisplay->editState().isEnabled = true;
917 gpuDisplay->editState().usesClientComposition = false;
918 gpuDisplay->editState().layerStackSpace.content = Rect(0, 0, 1, 1);
919 gpuDisplay->editState().dirtyRegion = Region(Rect(0, 0, 1, 1));
Lloyd Piqued3d69882019-02-28 16:03:46 -0800920
921 CompositionRefreshArgs refreshArgs;
922 refreshArgs.repaintEverything = false;
923
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800924 gpuDisplay->finishFrame(refreshArgs);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800925}
926
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700927TEST_F(DisplayFinishFrameTest, performsCompositionIfRepaintEverything) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800928 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
929 std::shared_ptr<impl::Display> gpuDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800930
931 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800932 gpuDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piqued3d69882019-02-28 16:03:46 -0800933
934 // We expect a single call to queueBuffer when composition is not skipped.
935 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
936
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800937 gpuDisplay->editState().isEnabled = true;
938 gpuDisplay->editState().usesClientComposition = false;
939 gpuDisplay->editState().layerStackSpace.content = Rect(0, 0, 1, 1);
940 gpuDisplay->editState().dirtyRegion = Region::INVALID_REGION;
Lloyd Piqued3d69882019-02-28 16:03:46 -0800941
942 CompositionRefreshArgs refreshArgs;
943 refreshArgs.repaintEverything = true;
944
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800945 gpuDisplay->finishFrame(refreshArgs);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800946}
947
Lloyd Piquec6607552019-12-02 17:57:39 -0800948/*
949 * Display functional tests
950 */
951
952struct DisplayFunctionalTest : public testing::Test {
953 class Display : public impl::Display {
954 public:
Lloyd Piquec6607552019-12-02 17:57:39 -0800955 using impl::Display::injectOutputLayerForTest;
956 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
957 };
958
Lloyd Piquec6607552019-12-02 17:57:39 -0800959 DisplayFunctionalTest() {
960 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
961
962 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
963 }
964
965 NiceMock<android::mock::HWComposer> mHwComposer;
966 NiceMock<Hwc2::mock::PowerAdvisor> mPowerAdvisor;
967 NiceMock<mock::CompositionEngine> mCompositionEngine;
968 sp<mock::NativeWindow> mNativeWindow = new NiceMock<mock::NativeWindow>();
969 sp<mock::DisplaySurface> mDisplaySurface = new NiceMock<mock::DisplaySurface>();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800970
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700971 std::shared_ptr<Display> mDisplay = impl::createDisplayTemplated<
972 Display>(mCompositionEngine,
973 DisplayCreationArgsBuilder()
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800974 .setId(DEFAULT_DISPLAY_ID)
975 .setConnectionType(ui::DisplayConnectionType::Internal)
976 .setPixels(DEFAULT_RESOLUTION)
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700977 .setIsSecure(true)
978 .setLayerStackId(DEFAULT_LAYER_STACK)
979 .setPowerAdvisor(&mPowerAdvisor)
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800980 .build());
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700981
Lloyd Piquec6607552019-12-02 17:57:39 -0800982 impl::RenderSurface* mRenderSurface =
983 new impl::RenderSurface{mCompositionEngine, *mDisplay,
Dominik Laskowski50121d52021-04-23 13:01:16 -0700984 RenderSurfaceCreationArgsBuilder()
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800985 .setDisplayWidth(DEFAULT_RESOLUTION.width)
986 .setDisplayHeight(DEFAULT_RESOLUTION.height)
Dominik Laskowski50121d52021-04-23 13:01:16 -0700987 .setNativeWindow(mNativeWindow)
988 .setDisplaySurface(mDisplaySurface)
989 .build()};
Lloyd Piquec6607552019-12-02 17:57:39 -0800990};
991
992TEST_F(DisplayFunctionalTest, postFramebufferCriticalCallsAreOrdered) {
993 InSequence seq;
994
995 mDisplay->editState().isEnabled = true;
996
997 EXPECT_CALL(mHwComposer, presentAndGetReleaseFences(_));
998 EXPECT_CALL(*mDisplaySurface, onFrameCommitted());
999
1000 mDisplay->postFramebuffer();
1001}
1002
Lloyd Pique45a165a2018-10-19 11:54:47 -07001003} // namespace
1004} // namespace android::compositionengine