1 /*
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
17 #include <cmath>
18
19 #include <compositionengine/DisplayColorProfileCreationArgs.h>
20 #include <compositionengine/DisplayCreationArgs.h>
21 #include <compositionengine/DisplaySurface.h>
22 #include <compositionengine/RenderSurfaceCreationArgs.h>
23 #include <compositionengine/impl/Display.h>
24 #include <compositionengine/impl/RenderSurface.h>
25 #include <compositionengine/mock/CompositionEngine.h>
26 #include <compositionengine/mock/DisplayColorProfile.h>
27 #include <compositionengine/mock/DisplaySurface.h>
28 #include <compositionengine/mock/LayerFE.h>
29 #include <compositionengine/mock/NativeWindow.h>
30 #include <compositionengine/mock/OutputLayer.h>
31 #include <compositionengine/mock/RenderSurface.h>
32 #include <gtest/gtest.h>
33 #include <renderengine/mock/FakeExternalTexture.h>
34 #include <renderengine/mock/RenderEngine.h>
35
36 #include <ui/Rect.h>
37 #include <ui/StaticDisplayInfo.h>
38
39 #include "MockHWC2.h"
40 #include "MockHWComposer.h"
41 #include "MockPowerAdvisor.h"
42 #include "ftl/future.h"
43
44 #include <aidl/android/hardware/graphics/composer3/Composition.h>
45
46 using aidl::android::hardware::graphics::composer3::Capability;
47 using aidl::android::hardware::graphics::composer3::Composition;
48 using aidl::android::hardware::graphics::composer3::DimmingStage;
49
50 namespace android::compositionengine {
51 namespace {
52
53 namespace hal = android::hardware::graphics::composer::hal;
54
55 using testing::_;
56 using testing::ByMove;
57 using testing::DoAll;
58 using testing::Eq;
59 using testing::InSequence;
60 using testing::NiceMock;
61 using testing::Pointee;
62 using testing::Ref;
63 using testing::Return;
64 using testing::ReturnRef;
65 using testing::Sequence;
66 using testing::SetArgPointee;
67 using testing::StrictMock;
68
69 constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(123u);
70 constexpr HalVirtualDisplayId HAL_VIRTUAL_DISPLAY_ID{456u};
71 constexpr GpuVirtualDisplayId GPU_VIRTUAL_DISPLAY_ID{789u};
72
73 constexpr ui::Size DEFAULT_RESOLUTION{1920, 1080};
74
75 struct Layer {
Layerandroid::compositionengine::__anon4827906d0111::Layer76 Layer() {
77 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
78 EXPECT_CALL(*outputLayer, getHwcLayer()).WillRepeatedly(Return(&hwc2Layer));
79 }
80
81 sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();
82 StrictMock<mock::OutputLayer>* outputLayer = new StrictMock<mock::OutputLayer>();
83 StrictMock<HWC2::mock::Layer> hwc2Layer;
84 };
85
86 struct LayerNoHWC2Layer {
LayerNoHWC2Layerandroid::compositionengine::__anon4827906d0111::LayerNoHWC2Layer87 LayerNoHWC2Layer() {
88 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
89 EXPECT_CALL(*outputLayer, getHwcLayer()).WillRepeatedly(Return(nullptr));
90 }
91
92 sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();
93 StrictMock<mock::OutputLayer>* outputLayer = new StrictMock<mock::OutputLayer>();
94 };
95
96 struct DisplayTestCommon : public testing::Test {
97 // Uses the full implementation of a display
98 class FullImplDisplay : public impl::Display {
99 public:
100 using impl::Display::injectOutputLayerForTest;
101 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
102 };
103
104 // Uses a special implementation with key internal member functions set up
105 // as mock implementations, to allow for easier testing.
106 struct PartialMockDisplay : public impl::Display {
PartialMockDisplayandroid::compositionengine::__anon4827906d0111::DisplayTestCommon::PartialMockDisplay107 PartialMockDisplay(const compositionengine::CompositionEngine& compositionEngine)
108 : mCompositionEngine(compositionEngine) {}
109
110 // compositionengine::Output overrides
getStateandroid::compositionengine::__anon4827906d0111::DisplayTestCommon::PartialMockDisplay111 const OutputCompositionState& getState() const override { return mState; }
editStateandroid::compositionengine::__anon4827906d0111::DisplayTestCommon::PartialMockDisplay112 OutputCompositionState& editState() override { return mState; }
113
114 // compositionengine::impl::Output overrides
getCompositionEngineandroid::compositionengine::__anon4827906d0111::DisplayTestCommon::PartialMockDisplay115 const CompositionEngine& getCompositionEngine() const override {
116 return mCompositionEngine;
117 };
118
getOutputLayerCountandroid::compositionengine::__anon4827906d0111::DisplayTestCommon::PartialMockDisplay119 size_t getOutputLayerCount() const override { return 1u; }
120
121 // Mock implementation overrides
122 MOCK_CONST_METHOD1(getOutputLayerOrderedByZByIndex,
123 compositionengine::OutputLayer*(size_t));
124 MOCK_METHOD2(ensureOutputLayer,
125 compositionengine::OutputLayer*(std::optional<size_t>, const sp<LayerFE>&));
126 MOCK_METHOD0(finalizePendingOutputLayers, void());
127 MOCK_METHOD0(clearOutputLayers, void());
128 MOCK_CONST_METHOD1(dumpState, void(std::string&));
129 MOCK_METHOD1(injectOutputLayerForTest, compositionengine::OutputLayer*(const sp<LayerFE>&));
130 MOCK_METHOD1(injectOutputLayerForTest, void(std::unique_ptr<OutputLayer>));
131 MOCK_CONST_METHOD0(anyLayersRequireClientComposition, bool());
132 MOCK_CONST_METHOD0(allLayersRequireClientComposition, bool());
133 MOCK_METHOD1(applyChangedTypesToLayers, void(const impl::Display::ChangedTypes&));
134 MOCK_METHOD1(applyDisplayRequests, void(const impl::Display::DisplayRequests&));
135 MOCK_METHOD1(applyLayerRequestsToLayers, void(const impl::Display::LayerRequests&));
136
137 const compositionengine::CompositionEngine& mCompositionEngine;
138 impl::OutputCompositionState mState;
139 };
140
getDisplayNameFromCurrentTestandroid::compositionengine::__anon4827906d0111::DisplayTestCommon141 static std::string getDisplayNameFromCurrentTest() {
142 const ::testing::TestInfo* const test_info =
143 ::testing::UnitTest::GetInstance()->current_test_info();
144 return std::string("display for ") + test_info->test_case_name() + "." + test_info->name();
145 }
146
147 template <typename Display>
createDisplayandroid::compositionengine::__anon4827906d0111::DisplayTestCommon148 static std::shared_ptr<Display> createDisplay(
149 const compositionengine::CompositionEngine& compositionEngine,
150 compositionengine::DisplayCreationArgs args) {
151 args.name = getDisplayNameFromCurrentTest();
152 return impl::createDisplayTemplated<Display>(compositionEngine, args);
153 }
154
155 template <typename Display>
createPartialMockDisplayandroid::compositionengine::__anon4827906d0111::DisplayTestCommon156 static std::shared_ptr<StrictMock<Display>> createPartialMockDisplay(
157 const compositionengine::CompositionEngine& compositionEngine,
158 compositionengine::DisplayCreationArgs args) {
159 args.name = getDisplayNameFromCurrentTest();
160 auto display = std::make_shared<StrictMock<Display>>(compositionEngine);
161
162 display->setConfiguration(args);
163
164 return display;
165 }
166
DisplayTestCommonandroid::compositionengine::__anon4827906d0111::DisplayTestCommon167 DisplayTestCommon() {
168 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
169 EXPECT_CALL(mCompositionEngine, getRenderEngine()).WillRepeatedly(ReturnRef(mRenderEngine));
170 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
171 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
172 EXPECT_CALL(mPowerAdvisor, usePowerHintSession()).WillRepeatedly(Return(false));
173 }
174
getDisplayCreationArgsForPhysicalDisplayandroid::compositionengine::__anon4827906d0111::DisplayTestCommon175 DisplayCreationArgs getDisplayCreationArgsForPhysicalDisplay() {
176 return DisplayCreationArgsBuilder()
177 .setId(DEFAULT_DISPLAY_ID)
178 .setPixels(DEFAULT_RESOLUTION)
179 .setIsSecure(true)
180 .setPowerAdvisor(&mPowerAdvisor)
181 .build();
182 }
183
getDisplayCreationArgsForGpuVirtualDisplayandroid::compositionengine::__anon4827906d0111::DisplayTestCommon184 DisplayCreationArgs getDisplayCreationArgsForGpuVirtualDisplay() {
185 return DisplayCreationArgsBuilder()
186 .setId(GPU_VIRTUAL_DISPLAY_ID)
187 .setPixels(DEFAULT_RESOLUTION)
188 .setIsSecure(false)
189 .setPowerAdvisor(&mPowerAdvisor)
190 .build();
191 }
192
193 StrictMock<android::mock::HWComposer> mHwComposer;
194 StrictMock<Hwc2::mock::PowerAdvisor> mPowerAdvisor;
195 StrictMock<renderengine::mock::RenderEngine> mRenderEngine;
196 StrictMock<mock::CompositionEngine> mCompositionEngine;
197 sp<mock::NativeWindow> mNativeWindow = sp<StrictMock<mock::NativeWindow>>::make();
198 };
199
200 struct PartialMockDisplayTestCommon : public DisplayTestCommon {
201 using Display = DisplayTestCommon::PartialMockDisplay;
202 std::shared_ptr<Display> mDisplay =
203 createPartialMockDisplay<Display>(mCompositionEngine,
204 getDisplayCreationArgsForPhysicalDisplay());
205
206 android::HWComposer::DeviceRequestedChanges mDeviceRequestedChanges{
207 {{nullptr, Composition::CLIENT}},
208 hal::DisplayRequest::FLIP_CLIENT_TARGET,
209 {{nullptr, hal::LayerRequest::CLEAR_CLIENT_TARGET}},
210 {DEFAULT_DISPLAY_ID.value,
211 {aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888,
212 aidl::android::hardware::graphics::common::Dataspace::UNKNOWN},
213 -1.f,
214 DimmingStage::NONE},
215 };
216
chooseCompositionStrategyandroid::compositionengine::__anon4827906d0111::PartialMockDisplayTestCommon217 void chooseCompositionStrategy(Display* display) {
218 std::optional<android::HWComposer::DeviceRequestedChanges> changes;
219 bool success = display->chooseCompositionStrategy(&changes);
220 display->resetCompositionStrategy();
221 if (success) {
222 display->applyCompositionStrategy(changes);
223 }
224 }
225 };
226
227 struct FullDisplayImplTestCommon : public DisplayTestCommon {
228 using Display = DisplayTestCommon::FullImplDisplay;
229 std::shared_ptr<Display> mDisplay =
230 createDisplay<Display>(mCompositionEngine, getDisplayCreationArgsForPhysicalDisplay());
231 };
232
233 struct DisplayWithLayersTestCommon : public FullDisplayImplTestCommon {
DisplayWithLayersTestCommonandroid::compositionengine::__anon4827906d0111::DisplayWithLayersTestCommon234 DisplayWithLayersTestCommon() {
235 mDisplay->injectOutputLayerForTest(
236 std::unique_ptr<compositionengine::OutputLayer>(mLayer1.outputLayer));
237 mDisplay->injectOutputLayerForTest(
238 std::unique_ptr<compositionengine::OutputLayer>(mLayer2.outputLayer));
239 mDisplay->injectOutputLayerForTest(
240 std::unique_ptr<compositionengine::OutputLayer>(mLayer3.outputLayer));
241 mResultWithBuffer.buffer = std::make_shared<
242 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
243 1ULL /* bufferId */,
244 HAL_PIXEL_FORMAT_RGBA_8888,
245 0ULL /*usage*/);
246 }
247
248 Layer mLayer1;
249 Layer mLayer2;
250 LayerNoHWC2Layer mLayer3;
251 StrictMock<HWC2::mock::Layer> hwc2LayerUnknown;
252 std::shared_ptr<Display> mDisplay =
253 createDisplay<Display>(mCompositionEngine, getDisplayCreationArgsForPhysicalDisplay());
254 impl::GpuCompositionResult mResultWithBuffer;
255 impl::GpuCompositionResult mResultWithoutBuffer;
256 };
257
258 /*
259 * Basic construction
260 */
261
262 struct DisplayCreationTest : public DisplayTestCommon {
263 using Display = DisplayTestCommon::FullImplDisplay;
264 };
265
TEST_F(DisplayCreationTest,createPhysicalInternalDisplay)266 TEST_F(DisplayCreationTest, createPhysicalInternalDisplay) {
267 auto display =
268 impl::createDisplay(mCompositionEngine, getDisplayCreationArgsForPhysicalDisplay());
269 EXPECT_TRUE(display->isSecure());
270 EXPECT_FALSE(display->isVirtual());
271 EXPECT_EQ(DEFAULT_DISPLAY_ID, display->getId());
272 }
273
TEST_F(DisplayCreationTest,createGpuVirtualDisplay)274 TEST_F(DisplayCreationTest, createGpuVirtualDisplay) {
275 auto display =
276 impl::createDisplay(mCompositionEngine, getDisplayCreationArgsForGpuVirtualDisplay());
277 EXPECT_FALSE(display->isSecure());
278 EXPECT_TRUE(display->isVirtual());
279 EXPECT_TRUE(GpuVirtualDisplayId::tryCast(display->getId()));
280 }
281
282 /*
283 * Display::setConfiguration()
284 */
285
286 using DisplaySetConfigurationTest = PartialMockDisplayTestCommon;
287
TEST_F(DisplaySetConfigurationTest,configuresPhysicalDisplay)288 TEST_F(DisplaySetConfigurationTest, configuresPhysicalDisplay) {
289 mDisplay->setConfiguration(DisplayCreationArgsBuilder()
290 .setId(DEFAULT_DISPLAY_ID)
291 .setPixels(DEFAULT_RESOLUTION)
292 .setIsSecure(true)
293 .setPowerAdvisor(&mPowerAdvisor)
294 .setName(getDisplayNameFromCurrentTest())
295 .build());
296
297 EXPECT_EQ(DEFAULT_DISPLAY_ID, mDisplay->getId());
298 EXPECT_TRUE(mDisplay->isSecure());
299 EXPECT_FALSE(mDisplay->isVirtual());
300 EXPECT_FALSE(mDisplay->isValid());
301
302 const auto& filter = mDisplay->getState().layerFilter;
303 EXPECT_EQ(ui::INVALID_LAYER_STACK, filter.layerStack);
304 EXPECT_FALSE(filter.toInternalDisplay);
305 }
306
TEST_F(DisplaySetConfigurationTest,configuresHalVirtualDisplay)307 TEST_F(DisplaySetConfigurationTest, configuresHalVirtualDisplay) {
308 mDisplay->setConfiguration(DisplayCreationArgsBuilder()
309 .setId(HAL_VIRTUAL_DISPLAY_ID)
310 .setPixels(DEFAULT_RESOLUTION)
311 .setIsSecure(false)
312 .setPowerAdvisor(&mPowerAdvisor)
313 .setName(getDisplayNameFromCurrentTest())
314 .build());
315
316 EXPECT_EQ(HAL_VIRTUAL_DISPLAY_ID, mDisplay->getId());
317 EXPECT_FALSE(mDisplay->isSecure());
318 EXPECT_TRUE(mDisplay->isVirtual());
319 EXPECT_FALSE(mDisplay->isValid());
320
321 const auto& filter = mDisplay->getState().layerFilter;
322 EXPECT_EQ(ui::INVALID_LAYER_STACK, filter.layerStack);
323 EXPECT_FALSE(filter.toInternalDisplay);
324 }
325
TEST_F(DisplaySetConfigurationTest,configuresGpuVirtualDisplay)326 TEST_F(DisplaySetConfigurationTest, configuresGpuVirtualDisplay) {
327 mDisplay->setConfiguration(DisplayCreationArgsBuilder()
328 .setId(GPU_VIRTUAL_DISPLAY_ID)
329 .setPixels(DEFAULT_RESOLUTION)
330 .setIsSecure(false)
331 .setPowerAdvisor(&mPowerAdvisor)
332 .setName(getDisplayNameFromCurrentTest())
333 .build());
334
335 EXPECT_EQ(GPU_VIRTUAL_DISPLAY_ID, mDisplay->getId());
336 EXPECT_FALSE(mDisplay->isSecure());
337 EXPECT_TRUE(mDisplay->isVirtual());
338 EXPECT_FALSE(mDisplay->isValid());
339
340 const auto& filter = mDisplay->getState().layerFilter;
341 EXPECT_EQ(ui::INVALID_LAYER_STACK, filter.layerStack);
342 EXPECT_FALSE(filter.toInternalDisplay);
343 }
344
345 /*
346 * Display::disconnect()
347 */
348
349 using DisplayDisconnectTest = PartialMockDisplayTestCommon;
350
TEST_F(DisplayDisconnectTest,disconnectsDisplay)351 TEST_F(DisplayDisconnectTest, disconnectsDisplay) {
352 // The first call to disconnect will disconnect the display with the HWC.
353 EXPECT_CALL(mHwComposer, disconnectDisplay(HalDisplayId(DEFAULT_DISPLAY_ID))).Times(1);
354 mDisplay->disconnect();
355
356 // Subsequent calls will do nothing,
357 EXPECT_CALL(mHwComposer, disconnectDisplay(HalDisplayId(DEFAULT_DISPLAY_ID))).Times(0);
358 mDisplay->disconnect();
359 }
360
361 /*
362 * Display::setColorTransform()
363 */
364
365 using DisplaySetColorTransformTest = PartialMockDisplayTestCommon;
366
TEST_F(DisplaySetColorTransformTest,setsTransform)367 TEST_F(DisplaySetColorTransformTest, setsTransform) {
368 // No change does nothing
369 CompositionRefreshArgs refreshArgs;
370 refreshArgs.colorTransformMatrix = std::nullopt;
371 mDisplay->setColorTransform(refreshArgs);
372
373 // Identity matrix sets an identity state value
374 const mat4 kIdentity;
375
376 EXPECT_CALL(mHwComposer, setColorTransform(HalDisplayId(DEFAULT_DISPLAY_ID), kIdentity))
377 .Times(1);
378
379 refreshArgs.colorTransformMatrix = kIdentity;
380 mDisplay->setColorTransform(refreshArgs);
381
382 // Non-identity matrix sets a non-identity state value
383 const mat4 kNonIdentity = mat4() * 2;
384
385 EXPECT_CALL(mHwComposer, setColorTransform(HalDisplayId(DEFAULT_DISPLAY_ID), kNonIdentity))
386 .Times(1);
387
388 refreshArgs.colorTransformMatrix = kNonIdentity;
389 mDisplay->setColorTransform(refreshArgs);
390 }
391
392 /*
393 * Display::setColorMode()
394 */
395
396 using DisplaySetColorModeTest = PartialMockDisplayTestCommon;
397
TEST_F(DisplaySetColorModeTest,setsModeUnlessNoChange)398 TEST_F(DisplaySetColorModeTest, setsModeUnlessNoChange) {
399 using ColorProfile = Output::ColorProfile;
400
401 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
402 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
403 mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
404 mDisplay->setDisplayColorProfileForTest(std::unique_ptr<DisplayColorProfile>(colorProfile));
405
406 // These values are expected to be the initial state.
407 ASSERT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
408 ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
409 ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
410
411 // Otherwise if the values are unchanged, nothing happens
412 mDisplay->setColorProfile(ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
413 ui::RenderIntent::COLORIMETRIC});
414
415 EXPECT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
416 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
417 EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
418
419 // Otherwise if the values are different, updates happen
420 EXPECT_CALL(*renderSurface, setBufferDataspace(ui::Dataspace::DISPLAY_P3)).Times(1);
421 EXPECT_CALL(mHwComposer,
422 setActiveColorMode(DEFAULT_DISPLAY_ID, ui::ColorMode::DISPLAY_P3,
423 ui::RenderIntent::TONE_MAP_COLORIMETRIC))
424 .Times(1);
425
426 mDisplay->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
427 ui::RenderIntent::TONE_MAP_COLORIMETRIC});
428
429 EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mDisplay->getState().colorMode);
430 EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mDisplay->getState().dataspace);
431 EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mDisplay->getState().renderIntent);
432 }
433
TEST_F(DisplaySetColorModeTest,doesNothingForVirtualDisplay)434 TEST_F(DisplaySetColorModeTest, doesNothingForVirtualDisplay) {
435 using ColorProfile = Output::ColorProfile;
436
437 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
438 std::shared_ptr<impl::Display> virtualDisplay = impl::createDisplay(mCompositionEngine, args);
439
440 mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
441 virtualDisplay->setDisplayColorProfileForTest(
442 std::unique_ptr<DisplayColorProfile>(colorProfile));
443
444 virtualDisplay->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3,
445 ui::Dataspace::DISPLAY_P3,
446 ui::RenderIntent::TONE_MAP_COLORIMETRIC});
447
448 EXPECT_EQ(ui::ColorMode::NATIVE, virtualDisplay->getState().colorMode);
449 EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().dataspace);
450 EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, virtualDisplay->getState().renderIntent);
451 }
452
453 /*
454 * Display::createDisplayColorProfile()
455 */
456
457 using DisplayCreateColorProfileTest = PartialMockDisplayTestCommon;
458
TEST_F(DisplayCreateColorProfileTest,setsDisplayColorProfile)459 TEST_F(DisplayCreateColorProfileTest, setsDisplayColorProfile) {
460 EXPECT_TRUE(mDisplay->getDisplayColorProfile() == nullptr);
461 mDisplay->createDisplayColorProfile(
462 DisplayColorProfileCreationArgs{false, HdrCapabilities(), 0,
463 DisplayColorProfileCreationArgs::HwcColorModes()});
464 EXPECT_TRUE(mDisplay->getDisplayColorProfile() != nullptr);
465 }
466
467 /*
468 * Display::createRenderSurface()
469 */
470
471 using DisplayCreateRenderSurfaceTest = PartialMockDisplayTestCommon;
472
TEST_F(DisplayCreateRenderSurfaceTest,setsRenderSurface)473 TEST_F(DisplayCreateRenderSurfaceTest, setsRenderSurface) {
474 EXPECT_CALL(*mNativeWindow, disconnect(NATIVE_WINDOW_API_EGL)).WillRepeatedly(Return(NO_ERROR));
475 EXPECT_TRUE(mDisplay->getRenderSurface() == nullptr);
476 mDisplay->createRenderSurface(RenderSurfaceCreationArgsBuilder()
477 .setDisplayWidth(640)
478 .setDisplayHeight(480)
479 .setNativeWindow(mNativeWindow)
480 .build());
481 EXPECT_TRUE(mDisplay->getRenderSurface() != nullptr);
482 }
483
484 /*
485 * Display::createOutputLayer()
486 */
487
488 using DisplayCreateOutputLayerTest = FullDisplayImplTestCommon;
489
TEST_F(DisplayCreateOutputLayerTest,setsHwcLayer)490 TEST_F(DisplayCreateOutputLayerTest, setsHwcLayer) {
491 sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();
492 auto hwcLayer = std::make_shared<StrictMock<HWC2::mock::Layer>>();
493
494 EXPECT_CALL(mHwComposer, createLayer(HalDisplayId(DEFAULT_DISPLAY_ID)))
495 .WillOnce(Return(hwcLayer));
496
497 auto outputLayer = mDisplay->createOutputLayer(layerFE);
498
499 EXPECT_EQ(hwcLayer.get(), outputLayer->getHwcLayer());
500
501 outputLayer.reset();
502 }
503
504 /*
505 * Display::setReleasedLayers()
506 */
507
508 using DisplaySetReleasedLayersTest = DisplayWithLayersTestCommon;
509
TEST_F(DisplaySetReleasedLayersTest,doesNothingIfGpuDisplay)510 TEST_F(DisplaySetReleasedLayersTest, doesNothingIfGpuDisplay) {
511 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
512 std::shared_ptr<impl::Display> gpuDisplay = impl::createDisplay(mCompositionEngine, args);
513
514 sp<mock::LayerFE> layerXLayerFE = sp<StrictMock<mock::LayerFE>>::make();
515
516 {
517 Output::ReleasedLayers releasedLayers;
518 releasedLayers.emplace_back(layerXLayerFE);
519 gpuDisplay->setReleasedLayers(std::move(releasedLayers));
520 }
521
522 CompositionRefreshArgs refreshArgs;
523 refreshArgs.layersWithQueuedFrames.push_back(layerXLayerFE);
524
525 gpuDisplay->setReleasedLayers(refreshArgs);
526
527 const auto& releasedLayers = gpuDisplay->getReleasedLayersForTest();
528 ASSERT_EQ(1u, releasedLayers.size());
529 }
530
TEST_F(DisplaySetReleasedLayersTest,doesNothingIfNoLayersWithQueuedFrames)531 TEST_F(DisplaySetReleasedLayersTest, doesNothingIfNoLayersWithQueuedFrames) {
532 sp<mock::LayerFE> layerXLayerFE = sp<StrictMock<mock::LayerFE>>::make();
533
534 {
535 Output::ReleasedLayers releasedLayers;
536 releasedLayers.emplace_back(layerXLayerFE);
537 mDisplay->setReleasedLayers(std::move(releasedLayers));
538 }
539
540 CompositionRefreshArgs refreshArgs;
541 mDisplay->setReleasedLayers(refreshArgs);
542
543 const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
544 ASSERT_EQ(1u, releasedLayers.size());
545 }
546
TEST_F(DisplaySetReleasedLayersTest,setReleasedLayers)547 TEST_F(DisplaySetReleasedLayersTest, setReleasedLayers) {
548 sp<mock::LayerFE> unknownLayer = sp<StrictMock<mock::LayerFE>>::make();
549
550 CompositionRefreshArgs refreshArgs;
551 refreshArgs.layersWithQueuedFrames.push_back(mLayer1.layerFE);
552 refreshArgs.layersWithQueuedFrames.push_back(mLayer2.layerFE);
553 refreshArgs.layersWithQueuedFrames.push_back(unknownLayer);
554
555 mDisplay->setReleasedLayers(refreshArgs);
556
557 const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
558 ASSERT_EQ(2u, releasedLayers.size());
559 ASSERT_EQ(mLayer1.layerFE.get(), releasedLayers[0].promote().get());
560 ASSERT_EQ(mLayer2.layerFE.get(), releasedLayers[1].promote().get());
561 }
562
563 /*
564 * Display::chooseCompositionStrategy()
565 */
566
567 using DisplayChooseCompositionStrategyTest = PartialMockDisplayTestCommon;
568
TEST_F(DisplayChooseCompositionStrategyTest,takesEarlyOutIfGpuDisplay)569 TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutIfGpuDisplay) {
570 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
571 std::shared_ptr<Display> gpuDisplay =
572 createPartialMockDisplay<Display>(mCompositionEngine, args);
573 EXPECT_TRUE(GpuVirtualDisplayId::tryCast(gpuDisplay->getId()));
574
575 chooseCompositionStrategy(gpuDisplay.get());
576
577 auto& state = gpuDisplay->getState();
578 EXPECT_TRUE(state.usesClientComposition);
579 EXPECT_FALSE(state.usesDeviceComposition);
580 }
581
TEST_F(DisplayChooseCompositionStrategyTest,takesEarlyOutOnHwcError)582 TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutOnHwcError) {
583 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition()).WillOnce(Return(false));
584 EXPECT_CALL(mHwComposer,
585 getDeviceCompositionChanges(HalDisplayId(DEFAULT_DISPLAY_ID), false, _, _, _, _))
586 .WillOnce(Return(INVALID_OPERATION));
587
588 chooseCompositionStrategy(mDisplay.get());
589
590 auto& state = mDisplay->getState();
591 EXPECT_TRUE(state.usesClientComposition);
592 EXPECT_FALSE(state.usesDeviceComposition);
593 EXPECT_FALSE(state.previousDeviceRequestedChanges.has_value());
594 }
595
TEST_F(DisplayChooseCompositionStrategyTest,normalOperation)596 TEST_F(DisplayChooseCompositionStrategyTest, normalOperation) {
597 // Since two calls are made to anyLayersRequireClientComposition with different return
598 // values, use a Sequence to control the matching so the values are returned in a known
599 // order.
600 Sequence s;
601 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
602 .InSequence(s)
603 .WillOnce(Return(true));
604 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
605 .InSequence(s)
606 .WillOnce(Return(false));
607
608 EXPECT_CALL(mHwComposer,
609 getDeviceCompositionChanges(HalDisplayId(DEFAULT_DISPLAY_ID), true, _, _, _, _))
610 .WillOnce(testing::DoAll(testing::SetArgPointee<5>(mDeviceRequestedChanges),
611 Return(NO_ERROR)));
612 EXPECT_CALL(*mDisplay, applyChangedTypesToLayers(mDeviceRequestedChanges.changedTypes))
613 .Times(1);
614 EXPECT_CALL(*mDisplay, applyDisplayRequests(mDeviceRequestedChanges.displayRequests)).Times(1);
615 EXPECT_CALL(*mDisplay, applyLayerRequestsToLayers(mDeviceRequestedChanges.layerRequests))
616 .Times(1);
617 EXPECT_CALL(*mDisplay, allLayersRequireClientComposition()).WillOnce(Return(false));
618
619 chooseCompositionStrategy(mDisplay.get());
620
621 auto& state = mDisplay->getState();
622 EXPECT_FALSE(state.usesClientComposition);
623 EXPECT_TRUE(state.usesDeviceComposition);
624 }
625
TEST_F(DisplayChooseCompositionStrategyTest,normalOperationWithDisplayBrightness)626 TEST_F(DisplayChooseCompositionStrategyTest, normalOperationWithDisplayBrightness) {
627 // Since two calls are made to anyLayersRequireClientComposition with different return
628 // values, use a Sequence to control the matching so the values are returned in a known
629 // order.
630 constexpr float kDisplayBrightness = 0.5f;
631 constexpr float kDisplayBrightnessNits = 200.f;
632 EXPECT_CALL(mHwComposer,
633 setDisplayBrightness(DEFAULT_DISPLAY_ID, kDisplayBrightness, kDisplayBrightnessNits,
634 Hwc2::Composer::DisplayBrightnessOptions{.applyImmediately =
635 false}))
636 .WillOnce(Return(ByMove(ftl::yield<status_t>(NO_ERROR))));
637
638 mDisplay->setNextBrightness(kDisplayBrightness);
639 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
640 EXPECT_CALL(*renderSurface, beginFrame(_)).Times(1);
641 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
642 mDisplay->editState().displayBrightnessNits = kDisplayBrightnessNits;
643 mDisplay->beginFrame();
644
645 auto& state = mDisplay->getState();
646 EXPECT_FALSE(state.displayBrightness.has_value());
647 }
648
TEST_F(DisplayChooseCompositionStrategyTest,normalOperationWithChanges)649 TEST_F(DisplayChooseCompositionStrategyTest, normalOperationWithChanges) {
650 // Since two calls are made to anyLayersRequireClientComposition with different return
651 // values, use a Sequence to control the matching so the values are returned in a known
652 // order.
653 Sequence s;
654 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
655 .InSequence(s)
656 .WillOnce(Return(true));
657 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
658 .InSequence(s)
659 .WillOnce(Return(false));
660
661 EXPECT_CALL(mHwComposer,
662 getDeviceCompositionChanges(HalDisplayId(DEFAULT_DISPLAY_ID), true, _, _, _, _))
663 .WillOnce(DoAll(SetArgPointee<5>(mDeviceRequestedChanges), Return(NO_ERROR)));
664 EXPECT_CALL(*mDisplay, applyChangedTypesToLayers(mDeviceRequestedChanges.changedTypes))
665 .Times(1);
666 EXPECT_CALL(*mDisplay, applyDisplayRequests(mDeviceRequestedChanges.displayRequests)).Times(1);
667 EXPECT_CALL(*mDisplay, applyLayerRequestsToLayers(mDeviceRequestedChanges.layerRequests))
668 .Times(1);
669 EXPECT_CALL(*mDisplay, allLayersRequireClientComposition()).WillOnce(Return(false));
670
671 chooseCompositionStrategy(mDisplay.get());
672
673 auto& state = mDisplay->getState();
674 EXPECT_FALSE(state.usesClientComposition);
675 EXPECT_TRUE(state.usesDeviceComposition);
676 }
677
678 /*
679 * Display::getSkipColorTransform()
680 */
681
682 using DisplayGetSkipColorTransformTest = DisplayWithLayersTestCommon;
683 using aidl::android::hardware::graphics::composer3::DisplayCapability;
684
TEST_F(DisplayGetSkipColorTransformTest,checksCapabilityIfGpuDisplay)685 TEST_F(DisplayGetSkipColorTransformTest, checksCapabilityIfGpuDisplay) {
686 EXPECT_CALL(mHwComposer, hasCapability(Capability::SKIP_CLIENT_COLOR_TRANSFORM))
687 .WillOnce(Return(true));
688 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
689 auto gpuDisplay{impl::createDisplay(mCompositionEngine, args)};
690 EXPECT_TRUE(gpuDisplay->getSkipColorTransform());
691 }
692
TEST_F(DisplayGetSkipColorTransformTest,checksDisplayCapability)693 TEST_F(DisplayGetSkipColorTransformTest, checksDisplayCapability) {
694 EXPECT_CALL(mHwComposer,
695 hasDisplayCapability(HalDisplayId(DEFAULT_DISPLAY_ID),
696 DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM))
697 .WillOnce(Return(true));
698 EXPECT_TRUE(mDisplay->getSkipColorTransform());
699 }
700
701 /*
702 * Display::anyLayersRequireClientComposition()
703 */
704
705 using DisplayAnyLayersRequireClientCompositionTest = DisplayWithLayersTestCommon;
706
TEST_F(DisplayAnyLayersRequireClientCompositionTest,returnsFalse)707 TEST_F(DisplayAnyLayersRequireClientCompositionTest, returnsFalse) {
708 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(false));
709 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(false));
710 EXPECT_CALL(*mLayer3.outputLayer, requiresClientComposition()).WillOnce(Return(false));
711
712 EXPECT_FALSE(mDisplay->anyLayersRequireClientComposition());
713 }
714
TEST_F(DisplayAnyLayersRequireClientCompositionTest,returnsTrue)715 TEST_F(DisplayAnyLayersRequireClientCompositionTest, returnsTrue) {
716 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(false));
717 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(true));
718
719 EXPECT_TRUE(mDisplay->anyLayersRequireClientComposition());
720 }
721
722 /*
723 * Display::allLayersRequireClientComposition()
724 */
725
726 using DisplayAllLayersRequireClientCompositionTest = DisplayWithLayersTestCommon;
727
TEST_F(DisplayAllLayersRequireClientCompositionTest,returnsTrue)728 TEST_F(DisplayAllLayersRequireClientCompositionTest, returnsTrue) {
729 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(true));
730 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(true));
731 EXPECT_CALL(*mLayer3.outputLayer, requiresClientComposition()).WillOnce(Return(true));
732
733 EXPECT_TRUE(mDisplay->allLayersRequireClientComposition());
734 }
735
TEST_F(DisplayAllLayersRequireClientCompositionTest,returnsFalse)736 TEST_F(DisplayAllLayersRequireClientCompositionTest, returnsFalse) {
737 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(true));
738 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(false));
739
740 EXPECT_FALSE(mDisplay->allLayersRequireClientComposition());
741 }
742
743 /*
744 * Display::applyChangedTypesToLayers()
745 */
746
747 using DisplayApplyChangedTypesToLayersTest = DisplayWithLayersTestCommon;
748
TEST_F(DisplayApplyChangedTypesToLayersTest,takesEarlyOutIfNoChangedLayers)749 TEST_F(DisplayApplyChangedTypesToLayersTest, takesEarlyOutIfNoChangedLayers) {
750 mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes());
751 }
752
TEST_F(DisplayApplyChangedTypesToLayersTest,appliesChanges)753 TEST_F(DisplayApplyChangedTypesToLayersTest, appliesChanges) {
754 EXPECT_CALL(*mLayer1.outputLayer, applyDeviceCompositionTypeChange(Composition::CLIENT))
755 .Times(1);
756 EXPECT_CALL(*mLayer2.outputLayer, applyDeviceCompositionTypeChange(Composition::DEVICE))
757 .Times(1);
758
759 mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes{
760 {&mLayer1.hwc2Layer, Composition::CLIENT},
761 {&mLayer2.hwc2Layer, Composition::DEVICE},
762 {&hwc2LayerUnknown, Composition::SOLID_COLOR},
763 });
764 }
765
766 /*
767 * Display::applyDisplayRequests()
768 */
769
770 using DisplayApplyDisplayRequestsTest = DisplayWithLayersTestCommon;
771
TEST_F(DisplayApplyDisplayRequestsTest,handlesNoRequests)772 TEST_F(DisplayApplyDisplayRequestsTest, handlesNoRequests) {
773 mDisplay->applyDisplayRequests(static_cast<hal::DisplayRequest>(0));
774
775 auto& state = mDisplay->getState();
776 EXPECT_FALSE(state.flipClientTarget);
777 }
778
TEST_F(DisplayApplyDisplayRequestsTest,handlesFlipClientTarget)779 TEST_F(DisplayApplyDisplayRequestsTest, handlesFlipClientTarget) {
780 mDisplay->applyDisplayRequests(hal::DisplayRequest::FLIP_CLIENT_TARGET);
781
782 auto& state = mDisplay->getState();
783 EXPECT_TRUE(state.flipClientTarget);
784 }
785
TEST_F(DisplayApplyDisplayRequestsTest,handlesWriteClientTargetToOutput)786 TEST_F(DisplayApplyDisplayRequestsTest, handlesWriteClientTargetToOutput) {
787 mDisplay->applyDisplayRequests(hal::DisplayRequest::WRITE_CLIENT_TARGET_TO_OUTPUT);
788
789 auto& state = mDisplay->getState();
790 EXPECT_FALSE(state.flipClientTarget);
791 }
792
TEST_F(DisplayApplyDisplayRequestsTest,handlesAllRequestFlagsSet)793 TEST_F(DisplayApplyDisplayRequestsTest, handlesAllRequestFlagsSet) {
794 mDisplay->applyDisplayRequests(static_cast<hal::DisplayRequest>(~0));
795
796 auto& state = mDisplay->getState();
797 EXPECT_TRUE(state.flipClientTarget);
798 }
799
800 /*
801 * Display::applyLayerRequestsToLayers()
802 */
803
804 using DisplayApplyLayerRequestsToLayersTest = DisplayWithLayersTestCommon;
805
TEST_F(DisplayApplyLayerRequestsToLayersTest,preparesAllLayers)806 TEST_F(DisplayApplyLayerRequestsToLayersTest, preparesAllLayers) {
807 EXPECT_CALL(*mLayer1.outputLayer, prepareForDeviceLayerRequests()).Times(1);
808 EXPECT_CALL(*mLayer2.outputLayer, prepareForDeviceLayerRequests()).Times(1);
809 EXPECT_CALL(*mLayer3.outputLayer, prepareForDeviceLayerRequests()).Times(1);
810
811 mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests());
812 }
813
TEST_F(DisplayApplyLayerRequestsToLayersTest,appliesDeviceLayerRequests)814 TEST_F(DisplayApplyLayerRequestsToLayersTest, appliesDeviceLayerRequests) {
815 EXPECT_CALL(*mLayer1.outputLayer, prepareForDeviceLayerRequests()).Times(1);
816 EXPECT_CALL(*mLayer2.outputLayer, prepareForDeviceLayerRequests()).Times(1);
817 EXPECT_CALL(*mLayer3.outputLayer, prepareForDeviceLayerRequests()).Times(1);
818
819 EXPECT_CALL(*mLayer1.outputLayer,
820 applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest::CLEAR_CLIENT_TARGET))
821 .Times(1);
822
823 mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests{
824 {&mLayer1.hwc2Layer, hal::LayerRequest::CLEAR_CLIENT_TARGET},
825 {&hwc2LayerUnknown, hal::LayerRequest::CLEAR_CLIENT_TARGET},
826 });
827 }
828
829 /*
830 * Display::applyClientTargetRequests()
831 */
832
833 using DisplayApplyClientTargetRequests = DisplayWithLayersTestCommon;
834
TEST_F(DisplayApplyLayerRequestsToLayersTest,applyClientTargetRequests)835 TEST_F(DisplayApplyLayerRequestsToLayersTest, applyClientTargetRequests) {
836 static constexpr float kWhitePointNits = 800.f;
837
838 Display::ClientTargetProperty clientTargetProperty = {
839 .clientTargetProperty =
840 {
841 .pixelFormat =
842 aidl::android::hardware::graphics::common::PixelFormat::RGB_565,
843 .dataspace = aidl::android::hardware::graphics::common::Dataspace::
844 STANDARD_BT470M,
845 },
846 .brightness = kWhitePointNits,
847 .dimmingStage = aidl::android::hardware::graphics::composer3::DimmingStage::GAMMA_OETF,
848 };
849
850 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
851 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
852
853 EXPECT_CALL(*renderSurface,
854 setBufferPixelFormat(static_cast<ui::PixelFormat>(
855 clientTargetProperty.clientTargetProperty.pixelFormat)));
856 EXPECT_CALL(*renderSurface,
857 setBufferDataspace(static_cast<ui::Dataspace>(
858 clientTargetProperty.clientTargetProperty.dataspace)));
859 mDisplay->applyClientTargetRequests(clientTargetProperty);
860
861 auto& state = mDisplay->getState();
862 EXPECT_EQ(clientTargetProperty.clientTargetProperty.dataspace,
863 static_cast<aidl::android::hardware::graphics::common::Dataspace>(state.dataspace));
864 EXPECT_EQ(kWhitePointNits, state.clientTargetBrightness);
865 EXPECT_EQ(aidl::android::hardware::graphics::composer3::DimmingStage::GAMMA_OETF,
866 state.clientTargetDimmingStage);
867 }
868
869 /*
870 * Display::presentFrame()
871 */
872
873 using DisplayPresentAndGetFrameFencesTest = DisplayWithLayersTestCommon;
874
TEST_F(DisplayPresentAndGetFrameFencesTest,returnsNoFencesOnGpuDisplay)875 TEST_F(DisplayPresentAndGetFrameFencesTest, returnsNoFencesOnGpuDisplay) {
876 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
877 auto gpuDisplay{impl::createDisplay(mCompositionEngine, args)};
878
879 auto result = gpuDisplay->presentFrame();
880
881 ASSERT_TRUE(result.presentFence.get());
882 EXPECT_FALSE(result.presentFence->isValid());
883 EXPECT_EQ(0u, result.layerFences.size());
884 }
885
TEST_F(DisplayPresentAndGetFrameFencesTest,returnsPresentAndLayerFences)886 TEST_F(DisplayPresentAndGetFrameFencesTest, returnsPresentAndLayerFences) {
887 sp<Fence> presentFence = sp<Fence>::make();
888 sp<Fence> layer1Fence = sp<Fence>::make();
889 sp<Fence> layer2Fence = sp<Fence>::make();
890
891 EXPECT_CALL(mHwComposer, presentAndGetReleaseFences(HalDisplayId(DEFAULT_DISPLAY_ID), _))
892 .Times(1);
893 EXPECT_CALL(mHwComposer, getPresentFence(HalDisplayId(DEFAULT_DISPLAY_ID)))
894 .WillOnce(Return(presentFence));
895 EXPECT_CALL(mHwComposer,
896 getLayerReleaseFence(HalDisplayId(DEFAULT_DISPLAY_ID), &mLayer1.hwc2Layer))
897 .WillOnce(Return(layer1Fence));
898 EXPECT_CALL(mHwComposer,
899 getLayerReleaseFence(HalDisplayId(DEFAULT_DISPLAY_ID), &mLayer2.hwc2Layer))
900 .WillOnce(Return(layer2Fence));
901 EXPECT_CALL(mHwComposer, clearReleaseFences(HalDisplayId(DEFAULT_DISPLAY_ID))).Times(1);
902
903 auto result = mDisplay->presentFrame();
904
905 EXPECT_EQ(presentFence, result.presentFence);
906
907 EXPECT_EQ(2u, result.layerFences.size());
908 ASSERT_EQ(1u, result.layerFences.count(&mLayer1.hwc2Layer));
909 EXPECT_EQ(layer1Fence, result.layerFences[&mLayer1.hwc2Layer]);
910 ASSERT_EQ(1u, result.layerFences.count(&mLayer2.hwc2Layer));
911 EXPECT_EQ(layer2Fence, result.layerFences[&mLayer2.hwc2Layer]);
912 }
913
914 /*
915 * Display::setExpensiveRenderingExpected()
916 */
917
918 using DisplaySetExpensiveRenderingExpectedTest = DisplayWithLayersTestCommon;
919
TEST_F(DisplaySetExpensiveRenderingExpectedTest,forwardsToPowerAdvisor)920 TEST_F(DisplaySetExpensiveRenderingExpectedTest, forwardsToPowerAdvisor) {
921 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, true)).Times(1);
922 mDisplay->setExpensiveRenderingExpected(true);
923
924 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false)).Times(1);
925 mDisplay->setExpensiveRenderingExpected(false);
926 }
927
928 /*
929 * Display::finishFrame()
930 */
931
932 using DisplayFinishFrameTest = DisplayWithLayersTestCommon;
933
TEST_F(DisplayFinishFrameTest,doesNotSkipCompositionIfNotDirtyOnHwcDisplay)934 TEST_F(DisplayFinishFrameTest, doesNotSkipCompositionIfNotDirtyOnHwcDisplay) {
935 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
936 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
937
938 // We expect no calls to queueBuffer if composition was skipped.
939 EXPECT_CALL(*renderSurface, queueBuffer(_, _)).Times(1);
940
941 // Expect a call to signal no expensive rendering since there is no client composition.
942 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false));
943
944 mDisplay->editState().isEnabled = true;
945 mDisplay->editState().usesClientComposition = false;
946 mDisplay->editState().layerStackSpace.setContent(Rect(0, 0, 1, 1));
947 mDisplay->editState().dirtyRegion = Region::INVALID_REGION;
948
949 mDisplay->finishFrame(std::move(mResultWithBuffer));
950 }
951
TEST_F(DisplayFinishFrameTest,skipsCompositionIfNotDirty)952 TEST_F(DisplayFinishFrameTest, skipsCompositionIfNotDirty) {
953 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
954 std::shared_ptr<impl::Display> gpuDisplay = impl::createDisplay(mCompositionEngine, args);
955
956 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
957 gpuDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
958
959 // We expect no calls to queueBuffer if composition was skipped.
960 EXPECT_CALL(*renderSurface, queueBuffer(_, _)).Times(0);
961 EXPECT_CALL(*renderSurface, beginFrame(false));
962
963 gpuDisplay->editState().isEnabled = true;
964 gpuDisplay->editState().usesClientComposition = false;
965 gpuDisplay->editState().layerStackSpace.setContent(Rect(0, 0, 1, 1));
966 gpuDisplay->editState().dirtyRegion = Region::INVALID_REGION;
967 gpuDisplay->editState().lastCompositionHadVisibleLayers = true;
968
969 gpuDisplay->beginFrame();
970 gpuDisplay->finishFrame(std::move(mResultWithoutBuffer));
971 }
972
TEST_F(DisplayFinishFrameTest,skipsCompositionIfEmpty)973 TEST_F(DisplayFinishFrameTest, skipsCompositionIfEmpty) {
974 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
975 std::shared_ptr<impl::Display> gpuDisplay = impl::createDisplay(mCompositionEngine, args);
976
977 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
978 gpuDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
979
980 // We expect no calls to queueBuffer if composition was skipped.
981 EXPECT_CALL(*renderSurface, queueBuffer(_, _)).Times(0);
982 EXPECT_CALL(*renderSurface, beginFrame(false));
983
984 gpuDisplay->editState().isEnabled = true;
985 gpuDisplay->editState().usesClientComposition = false;
986 gpuDisplay->editState().layerStackSpace.setContent(Rect(0, 0, 1, 1));
987 gpuDisplay->editState().dirtyRegion = Region(Rect(0, 0, 1, 1));
988 gpuDisplay->editState().lastCompositionHadVisibleLayers = false;
989
990 gpuDisplay->beginFrame();
991 gpuDisplay->finishFrame(std::move(mResultWithoutBuffer));
992 }
993
TEST_F(DisplayFinishFrameTest,performsCompositionIfDirtyAndNotEmpty)994 TEST_F(DisplayFinishFrameTest, performsCompositionIfDirtyAndNotEmpty) {
995 auto args = getDisplayCreationArgsForGpuVirtualDisplay();
996 std::shared_ptr<impl::Display> gpuDisplay = impl::createDisplay(mCompositionEngine, args);
997
998 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
999 gpuDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
1000
1001 // We expect a single call to queueBuffer when composition is not skipped.
1002 EXPECT_CALL(*renderSurface, queueBuffer(_, _)).Times(1);
1003 EXPECT_CALL(*renderSurface, beginFrame(true));
1004
1005 gpuDisplay->editState().isEnabled = true;
1006 gpuDisplay->editState().usesClientComposition = false;
1007 gpuDisplay->editState().layerStackSpace.setContent(Rect(0, 0, 1, 1));
1008 gpuDisplay->editState().dirtyRegion = Region(Rect(0, 0, 1, 1));
1009 gpuDisplay->editState().lastCompositionHadVisibleLayers = true;
1010
1011 gpuDisplay->beginFrame();
1012 gpuDisplay->finishFrame(std::move(mResultWithBuffer));
1013 }
1014
1015 /*
1016 * Display functional tests
1017 */
1018
1019 struct DisplayFunctionalTest : public testing::Test {
1020 class Display : public impl::Display {
1021 public:
1022 using impl::Display::injectOutputLayerForTest;
1023 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
1024 };
1025
DisplayFunctionalTestandroid::compositionengine::__anon4827906d0111::DisplayFunctionalTest1026 DisplayFunctionalTest() {
1027 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
1028 mDisplay = createDisplay();
1029 mRenderSurface = createRenderSurface();
1030 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
1031 }
1032
1033 NiceMock<android::mock::HWComposer> mHwComposer;
1034 NiceMock<Hwc2::mock::PowerAdvisor> mPowerAdvisor;
1035 NiceMock<mock::CompositionEngine> mCompositionEngine;
1036 sp<mock::NativeWindow> mNativeWindow = sp<NiceMock<mock::NativeWindow>>::make();
1037 sp<mock::DisplaySurface> mDisplaySurface = sp<NiceMock<mock::DisplaySurface>>::make();
1038 std::shared_ptr<Display> mDisplay;
1039 impl::RenderSurface* mRenderSurface;
1040
createDisplayandroid::compositionengine::__anon4827906d0111::DisplayFunctionalTest1041 std::shared_ptr<Display> createDisplay() {
1042 return impl::createDisplayTemplated<Display>(mCompositionEngine,
1043 DisplayCreationArgsBuilder()
1044 .setId(DEFAULT_DISPLAY_ID)
1045 .setPixels(DEFAULT_RESOLUTION)
1046 .setIsSecure(true)
1047 .setPowerAdvisor(&mPowerAdvisor)
1048 .build());
1049 ;
1050 }
1051
createRenderSurfaceandroid::compositionengine::__anon4827906d0111::DisplayFunctionalTest1052 impl::RenderSurface* createRenderSurface() {
1053 return new impl::RenderSurface{mCompositionEngine, *mDisplay,
1054 RenderSurfaceCreationArgsBuilder()
1055 .setDisplayWidth(DEFAULT_RESOLUTION.width)
1056 .setDisplayHeight(DEFAULT_RESOLUTION.height)
1057 .setNativeWindow(mNativeWindow)
1058 .setDisplaySurface(mDisplaySurface)
1059 .build()};
1060 }
1061 };
1062
TEST_F(DisplayFunctionalTest,presentFrameAndReleaseLayersCriticalCallsAreOrdered)1063 TEST_F(DisplayFunctionalTest, presentFrameAndReleaseLayersCriticalCallsAreOrdered) {
1064 InSequence seq;
1065
1066 mDisplay->editState().isEnabled = true;
1067
1068 EXPECT_CALL(mHwComposer, presentAndGetReleaseFences(_, _));
1069 EXPECT_CALL(*mDisplaySurface, onFrameCommitted());
1070 constexpr bool kFlushEvenWhenDisabled = false;
1071 mDisplay->presentFrameAndReleaseLayers(kFlushEvenWhenDisabled);
1072 }
1073
1074 } // namespace
1075 } // namespace android::compositionengine
1076