blob: 16f7a4ef462dbde7dc06ec9ebbf34ed1439d74c2 [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 Pique45a165a2018-10-19 11:54:47 -070033
Lloyd Pique66d68602019-02-13 14:23:31 -080034#include "MockHWC2.h"
Lloyd Pique45a165a2018-10-19 11:54:47 -070035#include "MockHWComposer.h"
Lloyd Pique688abd42019-02-15 15:42:24 -080036#include "MockPowerAdvisor.h"
Lloyd Pique45a165a2018-10-19 11:54:47 -070037
38namespace android::compositionengine {
39namespace {
40
Lloyd Piquef5275482019-01-29 18:42:42 -080041using testing::_;
Lloyd Pique66d68602019-02-13 14:23:31 -080042using testing::DoAll;
Lloyd Piquec6607552019-12-02 17:57:39 -080043using testing::InSequence;
44using testing::NiceMock;
Lloyd Pique31cb2942018-10-19 17:23:03 -070045using testing::Return;
Lloyd Pique45a165a2018-10-19 11:54:47 -070046using testing::ReturnRef;
Lloyd Pique66d68602019-02-13 14:23:31 -080047using testing::Sequence;
48using testing::SetArgPointee;
Lloyd Pique45a165a2018-10-19 11:54:47 -070049using testing::StrictMock;
50
51constexpr DisplayId DEFAULT_DISPLAY_ID = DisplayId{42};
Lloyd Piquec6607552019-12-02 17:57:39 -080052constexpr int32_t DEFAULT_DISPLAY_WIDTH = 1920;
53constexpr int32_t DEFAULT_DISPLAY_HEIGHT = 1080;
Lloyd Pique45a165a2018-10-19 11:54:47 -070054
Lloyd Piquede196652020-01-22 17:29:58 -080055struct Layer {
56 Layer() {
57 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
58 EXPECT_CALL(*outputLayer, getHwcLayer()).WillRepeatedly(Return(&hwc2Layer));
59 }
60
61 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
62 StrictMock<mock::OutputLayer>* outputLayer = new StrictMock<mock::OutputLayer>();
63 StrictMock<HWC2::mock::Layer> hwc2Layer;
64};
65
66struct LayerNoHWC2Layer {
67 LayerNoHWC2Layer() {
68 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
69 EXPECT_CALL(*outputLayer, getHwcLayer()).WillRepeatedly(Return(nullptr));
70 }
71
72 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
73 StrictMock<mock::OutputLayer>* outputLayer = new StrictMock<mock::OutputLayer>();
74};
75
Lloyd Pique66d68602019-02-13 14:23:31 -080076struct DisplayTest : public testing::Test {
Lloyd Pique01c77c12019-04-17 12:48:32 -070077 class Display : public impl::Display {
78 public:
79 explicit Display(const compositionengine::DisplayCreationArgs& args)
80 : impl::Display(args) {}
81
82 using impl::Display::injectOutputLayerForTest;
83 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
84 };
85
86 static std::shared_ptr<Display> createDisplay(
87 const compositionengine::CompositionEngine& compositionEngine,
88 compositionengine::DisplayCreationArgs&& args) {
89 return impl::createDisplayTemplated<Display>(compositionEngine, args);
90 }
91
Lloyd Pique66d68602019-02-13 14:23:31 -080092 DisplayTest() {
93 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
Lloyd Pique66d68602019-02-13 14:23:31 -080094
Lloyd Pique01c77c12019-04-17 12:48:32 -070095 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -080096 std::unique_ptr<compositionengine::OutputLayer>(mLayer1.outputLayer));
Lloyd Pique01c77c12019-04-17 12:48:32 -070097 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -080098 std::unique_ptr<compositionengine::OutputLayer>(mLayer2.outputLayer));
Lloyd Pique01c77c12019-04-17 12:48:32 -070099 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -0800100 std::unique_ptr<compositionengine::OutputLayer>(mLayer3.outputLayer));
Lloyd Pique66d68602019-02-13 14:23:31 -0800101 }
Lloyd Pique45a165a2018-10-19 11:54:47 -0700102
103 StrictMock<android::mock::HWComposer> mHwComposer;
Lloyd Pique688abd42019-02-15 15:42:24 -0800104 StrictMock<Hwc2::mock::PowerAdvisor> mPowerAdvisor;
Lloyd Pique45a165a2018-10-19 11:54:47 -0700105 StrictMock<mock::CompositionEngine> mCompositionEngine;
chaviw8beb4142019-04-11 13:09:05 -0700106 sp<mock::NativeWindow> mNativeWindow = new StrictMock<mock::NativeWindow>();
Lloyd Piquede196652020-01-22 17:29:58 -0800107 Layer mLayer1;
108 Layer mLayer2;
109 LayerNoHWC2Layer mLayer3;
110 StrictMock<HWC2::mock::Layer> hwc2LayerUnknown;
111
Lloyd Pique01c77c12019-04-17 12:48:32 -0700112 std::shared_ptr<Display> mDisplay = createDisplay(mCompositionEngine,
113 DisplayCreationArgsBuilder()
114 .setDisplayId(DEFAULT_DISPLAY_ID)
115 .setPowerAdvisor(&mPowerAdvisor)
116 .build());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700117};
118
Lloyd Pique66d68602019-02-13 14:23:31 -0800119/*
Lloyd Pique45a165a2018-10-19 11:54:47 -0700120 * Basic construction
121 */
122
123TEST_F(DisplayTest, canInstantiateDisplay) {
124 {
125 constexpr DisplayId display1 = DisplayId{123u};
126 auto display =
127 impl::createDisplay(mCompositionEngine,
128 DisplayCreationArgsBuilder().setDisplayId(display1).build());
129 EXPECT_FALSE(display->isSecure());
130 EXPECT_FALSE(display->isVirtual());
131 EXPECT_EQ(display1, display->getId());
132 }
133
134 {
135 constexpr DisplayId display2 = DisplayId{546u};
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700136 auto display =
137 impl::createDisplay(mCompositionEngine,
138 DisplayCreationArgsBuilder().setDisplayId(display2).build());
139 EXPECT_FALSE(display->isSecure());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700140 EXPECT_FALSE(display->isVirtual());
141 EXPECT_EQ(display2, display->getId());
142 }
143
144 {
145 constexpr DisplayId display3 = DisplayId{789u};
146 auto display = impl::createDisplay(mCompositionEngine,
147 DisplayCreationArgsBuilder()
148 .setIsVirtual(true)
149 .setDisplayId(display3)
150 .build());
151 EXPECT_FALSE(display->isSecure());
152 EXPECT_TRUE(display->isVirtual());
153 EXPECT_EQ(display3, display->getId());
154 }
155}
156
Lloyd Pique66d68602019-02-13 14:23:31 -0800157/*
Lloyd Pique45a165a2018-10-19 11:54:47 -0700158 * Display::disconnect()
159 */
160
161TEST_F(DisplayTest, disconnectDisconnectsDisplay) {
Lloyd Pique45a165a2018-10-19 11:54:47 -0700162 // The first call to disconnect will disconnect the display with the HWC and
163 // set mHwcId to -1.
164 EXPECT_CALL(mHwComposer, disconnectDisplay(DEFAULT_DISPLAY_ID)).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700165 mDisplay->disconnect();
166 EXPECT_FALSE(mDisplay->getId());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700167
168 // Subsequent calls will do nothing,
169 EXPECT_CALL(mHwComposer, disconnectDisplay(DEFAULT_DISPLAY_ID)).Times(0);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700170 mDisplay->disconnect();
171 EXPECT_FALSE(mDisplay->getId());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700172}
173
Lloyd Pique66d68602019-02-13 14:23:31 -0800174/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700175 * Display::setColorTransform()
176 */
177
178TEST_F(DisplayTest, setColorTransformSetsTransform) {
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800179 // No change does nothing
180 CompositionRefreshArgs refreshArgs;
181 refreshArgs.colorTransformMatrix = std::nullopt;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700182 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800183
Lloyd Pique32cbe282018-10-19 13:09:22 -0700184 // Identity matrix sets an identity state value
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800185 const mat4 kIdentity;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700186
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800187 EXPECT_CALL(mHwComposer, setColorTransform(DEFAULT_DISPLAY_ID, kIdentity)).Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700188
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800189 refreshArgs.colorTransformMatrix = kIdentity;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700190 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700191
192 // Non-identity matrix sets a non-identity state value
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800193 const mat4 kNonIdentity = mat4() * 2;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700194
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800195 EXPECT_CALL(mHwComposer, setColorTransform(DEFAULT_DISPLAY_ID, kNonIdentity)).Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700196
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800197 refreshArgs.colorTransformMatrix = kNonIdentity;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700198 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700199}
200
Lloyd Pique66d68602019-02-13 14:23:31 -0800201/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700202 * Display::setColorMode()
203 */
204
205TEST_F(DisplayTest, setColorModeSetsModeUnlessNoChange) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800206 using ColorProfile = Output::ColorProfile;
207
Lloyd Pique31cb2942018-10-19 17:23:03 -0700208 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700209 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piquef5275482019-01-29 18:42:42 -0800210 mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700211 mDisplay->setDisplayColorProfileForTest(std::unique_ptr<DisplayColorProfile>(colorProfile));
Lloyd Pique31cb2942018-10-19 17:23:03 -0700212
Lloyd Piquef5275482019-01-29 18:42:42 -0800213 EXPECT_CALL(*colorProfile, getTargetDataspace(_, _, _))
214 .WillRepeatedly(Return(ui::Dataspace::UNKNOWN));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700215
216 // These values are expected to be the initial state.
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700217 ASSERT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
218 ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
219 ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
220 ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700221
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700222 // Otherwise if the values are unchanged, nothing happens
223 mDisplay->setColorProfile(ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
224 ui::RenderIntent::COLORIMETRIC, ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700225
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700226 EXPECT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
227 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
228 EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
229 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700230
231 // Otherwise if the values are different, updates happen
Lloyd Piqueef958122019-02-05 18:00:12 -0800232 EXPECT_CALL(*renderSurface, setBufferDataspace(ui::Dataspace::DISPLAY_P3)).Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700233 EXPECT_CALL(mHwComposer,
Lloyd Piqueef958122019-02-05 18:00:12 -0800234 setActiveColorMode(DEFAULT_DISPLAY_ID, ui::ColorMode::DISPLAY_P3,
Lloyd Pique32cbe282018-10-19 13:09:22 -0700235 ui::RenderIntent::TONE_MAP_COLORIMETRIC))
236 .Times(1);
237
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700238 mDisplay->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
239 ui::RenderIntent::TONE_MAP_COLORIMETRIC,
240 ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700241
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700242 EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mDisplay->getState().colorMode);
243 EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mDisplay->getState().dataspace);
244 EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mDisplay->getState().renderIntent);
245 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700246}
247
248TEST_F(DisplayTest, setColorModeDoesNothingForVirtualDisplay) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800249 using ColorProfile = Output::ColorProfile;
250
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700251 std::shared_ptr<impl::Display> virtualDisplay{
252 impl::createDisplay(mCompositionEngine, DisplayCreationArgs{true, DEFAULT_DISPLAY_ID})};
Lloyd Pique32cbe282018-10-19 13:09:22 -0700253
Lloyd Piquef5275482019-01-29 18:42:42 -0800254 mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700255 virtualDisplay->setDisplayColorProfileForTest(
Lloyd Piquef5275482019-01-29 18:42:42 -0800256 std::unique_ptr<DisplayColorProfile>(colorProfile));
257
258 EXPECT_CALL(*colorProfile,
259 getTargetDataspace(ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
260 ui::Dataspace::UNKNOWN))
261 .WillOnce(Return(ui::Dataspace::UNKNOWN));
262
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700263 virtualDisplay->setColorProfile(
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800264 ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
265 ui::RenderIntent::TONE_MAP_COLORIMETRIC, ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700266
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700267 EXPECT_EQ(ui::ColorMode::NATIVE, virtualDisplay->getState().colorMode);
268 EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().dataspace);
269 EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, virtualDisplay->getState().renderIntent);
270 EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700271}
272
Lloyd Pique66d68602019-02-13 14:23:31 -0800273/*
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700274 * Display::createDisplayColorProfile()
275 */
276
277TEST_F(DisplayTest, createDisplayColorProfileSetsDisplayColorProfile) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700278 EXPECT_TRUE(mDisplay->getDisplayColorProfile() == nullptr);
279 mDisplay->createDisplayColorProfile(
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700280 DisplayColorProfileCreationArgs{false, HdrCapabilities(), 0,
281 DisplayColorProfileCreationArgs::HwcColorModes()});
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700282 EXPECT_TRUE(mDisplay->getDisplayColorProfile() != nullptr);
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700283}
284
Lloyd Pique66d68602019-02-13 14:23:31 -0800285/*
Lloyd Pique31cb2942018-10-19 17:23:03 -0700286 * Display::createRenderSurface()
287 */
288
289TEST_F(DisplayTest, createRenderSurfaceSetsRenderSurface) {
chaviw8beb4142019-04-11 13:09:05 -0700290 EXPECT_CALL(*mNativeWindow, disconnect(NATIVE_WINDOW_API_EGL)).WillRepeatedly(Return(NO_ERROR));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700291 EXPECT_TRUE(mDisplay->getRenderSurface() == nullptr);
292 mDisplay->createRenderSurface(RenderSurfaceCreationArgs{640, 480, mNativeWindow, nullptr});
293 EXPECT_TRUE(mDisplay->getRenderSurface() != nullptr);
Lloyd Pique31cb2942018-10-19 17:23:03 -0700294}
295
Lloyd Pique66d68602019-02-13 14:23:31 -0800296/*
Lloyd Piquedf336d92019-03-07 21:38:42 -0800297 * Display::createOutputLayer()
298 */
299
300TEST_F(DisplayTest, createOutputLayerSetsHwcLayer) {
301 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
Lloyd Piquedf336d92019-03-07 21:38:42 -0800302 StrictMock<HWC2::mock::Layer> hwcLayer;
303
304 EXPECT_CALL(mHwComposer, createLayer(DEFAULT_DISPLAY_ID)).WillOnce(Return(&hwcLayer));
305
Lloyd Piquede196652020-01-22 17:29:58 -0800306 auto outputLayer = mDisplay->createOutputLayer(layerFE);
Lloyd Piquedf336d92019-03-07 21:38:42 -0800307
308 EXPECT_EQ(&hwcLayer, outputLayer->getHwcLayer());
309
310 EXPECT_CALL(mHwComposer, destroyLayer(DEFAULT_DISPLAY_ID, &hwcLayer));
311 outputLayer.reset();
312}
313
314/*
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800315 * Display::setReleasedLayers()
316 */
317
318TEST_F(DisplayTest, setReleasedLayersDoesNothingIfNotHwcDisplay) {
319 std::shared_ptr<impl::Display> nonHwcDisplay{
320 impl::createDisplay(mCompositionEngine, DisplayCreationArgsBuilder().build())};
321
322 sp<mock::LayerFE> layerXLayerFE = new StrictMock<mock::LayerFE>();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800323
324 {
325 Output::ReleasedLayers releasedLayers;
326 releasedLayers.emplace_back(layerXLayerFE);
327 nonHwcDisplay->setReleasedLayers(std::move(releasedLayers));
328 }
329
330 CompositionRefreshArgs refreshArgs;
Lloyd Piquede196652020-01-22 17:29:58 -0800331 refreshArgs.layersWithQueuedFrames.push_back(layerXLayerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800332
333 nonHwcDisplay->setReleasedLayers(refreshArgs);
334
335 const auto& releasedLayers = nonHwcDisplay->getReleasedLayersForTest();
336 ASSERT_EQ(1, releasedLayers.size());
337}
338
339TEST_F(DisplayTest, setReleasedLayersDoesNothingIfNoLayersWithQueuedFrames) {
340 sp<mock::LayerFE> layerXLayerFE = new StrictMock<mock::LayerFE>();
341
342 {
343 Output::ReleasedLayers releasedLayers;
344 releasedLayers.emplace_back(layerXLayerFE);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700345 mDisplay->setReleasedLayers(std::move(releasedLayers));
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800346 }
347
348 CompositionRefreshArgs refreshArgs;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700349 mDisplay->setReleasedLayers(refreshArgs);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800350
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700351 const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800352 ASSERT_EQ(1, releasedLayers.size());
353}
354
355TEST_F(DisplayTest, setReleasedLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800356 sp<mock::LayerFE> unknownLayer = new StrictMock<mock::LayerFE>();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800357
358 CompositionRefreshArgs refreshArgs;
Lloyd Piquede196652020-01-22 17:29:58 -0800359 refreshArgs.layersWithQueuedFrames.push_back(mLayer1.layerFE);
360 refreshArgs.layersWithQueuedFrames.push_back(mLayer2.layerFE);
361 refreshArgs.layersWithQueuedFrames.push_back(unknownLayer);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800362
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700363 mDisplay->setReleasedLayers(refreshArgs);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800364
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700365 const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800366 ASSERT_EQ(2, releasedLayers.size());
Lloyd Piquede196652020-01-22 17:29:58 -0800367 ASSERT_EQ(mLayer1.layerFE.get(), releasedLayers[0].promote().get());
368 ASSERT_EQ(mLayer2.layerFE.get(), releasedLayers[1].promote().get());
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800369}
370
371/*
Lloyd Pique66d68602019-02-13 14:23:31 -0800372 * Display::chooseCompositionStrategy()
373 */
374
375struct DisplayChooseCompositionStrategyTest : public testing::Test {
376 struct DisplayPartialMock : public impl::Display {
377 DisplayPartialMock(const compositionengine::CompositionEngine& compositionEngine,
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700378 const compositionengine::DisplayCreationArgs& args)
379 : impl::Display(args), mCompositionEngine(compositionEngine) {}
Lloyd Pique66d68602019-02-13 14:23:31 -0800380
381 // Sets up the helper functions called by chooseCompositionStrategy to
382 // use a mock implementations.
383 MOCK_CONST_METHOD0(anyLayersRequireClientComposition, bool());
384 MOCK_CONST_METHOD0(allLayersRequireClientComposition, bool());
385 MOCK_METHOD1(applyChangedTypesToLayers, void(const impl::Display::ChangedTypes&));
386 MOCK_METHOD1(applyDisplayRequests, void(const impl::Display::DisplayRequests&));
387 MOCK_METHOD1(applyLayerRequestsToLayers, void(const impl::Display::LayerRequests&));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700388
389 // compositionengine::Output overrides
390 const OutputCompositionState& getState() const override { return mState; }
391 OutputCompositionState& editState() override { return mState; }
392
393 // compositionengine::impl::Output overrides
394 const CompositionEngine& getCompositionEngine() const override {
395 return mCompositionEngine;
396 };
397
398 // These need implementations though are not expected to be called.
Lloyd Pique01c77c12019-04-17 12:48:32 -0700399 MOCK_CONST_METHOD0(getOutputLayerCount, size_t());
400 MOCK_CONST_METHOD1(getOutputLayerOrderedByZByIndex,
401 compositionengine::OutputLayer*(size_t));
Lloyd Piquede196652020-01-22 17:29:58 -0800402 MOCK_METHOD2(ensureOutputLayer,
403 compositionengine::OutputLayer*(std::optional<size_t>, const sp<LayerFE>&));
Lloyd Pique01c77c12019-04-17 12:48:32 -0700404 MOCK_METHOD0(finalizePendingOutputLayers, void());
405 MOCK_METHOD0(clearOutputLayers, void());
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700406 MOCK_CONST_METHOD1(dumpState, void(std::string&));
Lloyd Piquede196652020-01-22 17:29:58 -0800407 MOCK_METHOD1(injectOutputLayerForTest, compositionengine::OutputLayer*(const sp<LayerFE>&));
Lloyd Pique01c77c12019-04-17 12:48:32 -0700408 MOCK_METHOD1(injectOutputLayerForTest, void(std::unique_ptr<OutputLayer>));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700409
410 const compositionengine::CompositionEngine& mCompositionEngine;
411 impl::OutputCompositionState mState;
Lloyd Pique66d68602019-02-13 14:23:31 -0800412 };
413
414 DisplayChooseCompositionStrategyTest() {
415 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
416 }
417
418 StrictMock<android::mock::HWComposer> mHwComposer;
419 StrictMock<mock::CompositionEngine> mCompositionEngine;
420 StrictMock<DisplayPartialMock>
421 mDisplay{mCompositionEngine,
422 DisplayCreationArgsBuilder().setDisplayId(DEFAULT_DISPLAY_ID).build()};
423};
424
425TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutIfNotAHwcDisplay) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700426 std::shared_ptr<impl::Display> nonHwcDisplay{
427 impl::createDisplay(mCompositionEngine, DisplayCreationArgsBuilder().build())};
428 EXPECT_FALSE(nonHwcDisplay->getId());
Lloyd Pique66d68602019-02-13 14:23:31 -0800429
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700430 nonHwcDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800431
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700432 auto& state = nonHwcDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800433 EXPECT_TRUE(state.usesClientComposition);
434 EXPECT_FALSE(state.usesDeviceComposition);
435}
436
437TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutOnHwcError) {
438 EXPECT_CALL(mDisplay, anyLayersRequireClientComposition()).WillOnce(Return(false));
439 EXPECT_CALL(mHwComposer, getDeviceCompositionChanges(DEFAULT_DISPLAY_ID, false, _))
440 .WillOnce(Return(INVALID_OPERATION));
441
442 mDisplay.chooseCompositionStrategy();
443
444 auto& state = mDisplay.getState();
445 EXPECT_TRUE(state.usesClientComposition);
446 EXPECT_FALSE(state.usesDeviceComposition);
447}
448
449TEST_F(DisplayChooseCompositionStrategyTest, normalOperation) {
450 // Since two calls are made to anyLayersRequireClientComposition with different return values,
451 // use a Sequence to control the matching so the values are returned in a known order.
452 Sequence s;
453 EXPECT_CALL(mDisplay, anyLayersRequireClientComposition()).InSequence(s).WillOnce(Return(true));
454 EXPECT_CALL(mDisplay, anyLayersRequireClientComposition())
455 .InSequence(s)
456 .WillOnce(Return(false));
457
458 EXPECT_CALL(mHwComposer, getDeviceCompositionChanges(DEFAULT_DISPLAY_ID, true, _))
459 .WillOnce(Return(NO_ERROR));
460 EXPECT_CALL(mDisplay, allLayersRequireClientComposition()).WillOnce(Return(false));
461
462 mDisplay.chooseCompositionStrategy();
463
464 auto& state = mDisplay.getState();
465 EXPECT_FALSE(state.usesClientComposition);
466 EXPECT_TRUE(state.usesDeviceComposition);
467}
468
469TEST_F(DisplayChooseCompositionStrategyTest, normalOperationWithChanges) {
470 android::HWComposer::DeviceRequestedChanges changes{
471 {{nullptr, HWC2::Composition::Client}},
472 HWC2::DisplayRequest::FlipClientTarget,
473 {{nullptr, HWC2::LayerRequest::ClearClientTarget}},
474 };
475
476 // Since two calls are made to anyLayersRequireClientComposition with different return values,
477 // use a Sequence to control the matching so the values are returned in a known order.
478 Sequence s;
479 EXPECT_CALL(mDisplay, anyLayersRequireClientComposition()).InSequence(s).WillOnce(Return(true));
480 EXPECT_CALL(mDisplay, anyLayersRequireClientComposition())
481 .InSequence(s)
482 .WillOnce(Return(false));
483
484 EXPECT_CALL(mHwComposer, getDeviceCompositionChanges(DEFAULT_DISPLAY_ID, true, _))
485 .WillOnce(DoAll(SetArgPointee<2>(changes), Return(NO_ERROR)));
486 EXPECT_CALL(mDisplay, applyChangedTypesToLayers(changes.changedTypes)).Times(1);
487 EXPECT_CALL(mDisplay, applyDisplayRequests(changes.displayRequests)).Times(1);
488 EXPECT_CALL(mDisplay, applyLayerRequestsToLayers(changes.layerRequests)).Times(1);
489 EXPECT_CALL(mDisplay, allLayersRequireClientComposition()).WillOnce(Return(false));
490
491 mDisplay.chooseCompositionStrategy();
492
493 auto& state = mDisplay.getState();
494 EXPECT_FALSE(state.usesClientComposition);
495 EXPECT_TRUE(state.usesDeviceComposition);
496}
497
498/*
Lloyd Pique688abd42019-02-15 15:42:24 -0800499 * Display::getSkipColorTransform()
500 */
501
502TEST_F(DisplayTest, getSkipColorTransformDoesNothingIfNonHwcDisplay) {
503 auto nonHwcDisplay{
504 impl::createDisplay(mCompositionEngine, DisplayCreationArgsBuilder().build())};
505 EXPECT_FALSE(nonHwcDisplay->getSkipColorTransform());
506}
507
508TEST_F(DisplayTest, getSkipColorTransformChecksHwcCapability) {
509 EXPECT_CALL(mHwComposer,
510 hasDisplayCapability(std::make_optional(DEFAULT_DISPLAY_ID),
511 HWC2::DisplayCapability::SkipClientColorTransform))
512 .WillOnce(Return(true));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700513 EXPECT_TRUE(mDisplay->getSkipColorTransform());
Lloyd Pique688abd42019-02-15 15:42:24 -0800514}
515
516/*
Lloyd Pique66d68602019-02-13 14:23:31 -0800517 * Display::anyLayersRequireClientComposition()
518 */
519
520TEST_F(DisplayTest, anyLayersRequireClientCompositionReturnsFalse) {
Lloyd Piquede196652020-01-22 17:29:58 -0800521 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(false));
522 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(false));
523 EXPECT_CALL(*mLayer3.outputLayer, requiresClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800524
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700525 EXPECT_FALSE(mDisplay->anyLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800526}
527
528TEST_F(DisplayTest, anyLayersRequireClientCompositionReturnsTrue) {
Lloyd Piquede196652020-01-22 17:29:58 -0800529 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(false));
530 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(true));
Lloyd Pique66d68602019-02-13 14:23:31 -0800531
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700532 EXPECT_TRUE(mDisplay->anyLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800533}
534
535/*
536 * Display::allLayersRequireClientComposition()
537 */
538
539TEST_F(DisplayTest, allLayersRequireClientCompositionReturnsTrue) {
Lloyd Piquede196652020-01-22 17:29:58 -0800540 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(true));
541 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(true));
542 EXPECT_CALL(*mLayer3.outputLayer, requiresClientComposition()).WillOnce(Return(true));
Lloyd Pique66d68602019-02-13 14:23:31 -0800543
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700544 EXPECT_TRUE(mDisplay->allLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800545}
546
547TEST_F(DisplayTest, allLayersRequireClientCompositionReturnsFalse) {
Lloyd Piquede196652020-01-22 17:29:58 -0800548 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(true));
549 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800550
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700551 EXPECT_FALSE(mDisplay->allLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800552}
553
554/*
555 * Display::applyChangedTypesToLayers()
556 */
557
558TEST_F(DisplayTest, applyChangedTypesToLayersTakesEarlyOutIfNoChangedLayers) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700559 mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes());
Lloyd Pique66d68602019-02-13 14:23:31 -0800560}
561
562TEST_F(DisplayTest, applyChangedTypesToLayersAppliesChanges) {
Lloyd Piquede196652020-01-22 17:29:58 -0800563 EXPECT_CALL(*mLayer1.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800564 applyDeviceCompositionTypeChange(Hwc2::IComposerClient::Composition::CLIENT))
565 .Times(1);
Lloyd Piquede196652020-01-22 17:29:58 -0800566 EXPECT_CALL(*mLayer2.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800567 applyDeviceCompositionTypeChange(Hwc2::IComposerClient::Composition::DEVICE))
568 .Times(1);
569
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700570 mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes{
Lloyd Piquede196652020-01-22 17:29:58 -0800571 {&mLayer1.hwc2Layer, HWC2::Composition::Client},
572 {&mLayer2.hwc2Layer, HWC2::Composition::Device},
573 {&hwc2LayerUnknown, HWC2::Composition::SolidColor},
Lloyd Pique66d68602019-02-13 14:23:31 -0800574 });
575}
576
577/*
578 * Display::applyDisplayRequests()
579 */
580
581TEST_F(DisplayTest, applyDisplayRequestsToLayersHandlesNoRequests) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700582 mDisplay->applyDisplayRequests(static_cast<HWC2::DisplayRequest>(0));
Lloyd Pique66d68602019-02-13 14:23:31 -0800583
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700584 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800585 EXPECT_FALSE(state.flipClientTarget);
586}
587
588TEST_F(DisplayTest, applyDisplayRequestsToLayersHandlesFlipClientTarget) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700589 mDisplay->applyDisplayRequests(HWC2::DisplayRequest::FlipClientTarget);
Lloyd Pique66d68602019-02-13 14:23:31 -0800590
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700591 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800592 EXPECT_TRUE(state.flipClientTarget);
593}
594
595TEST_F(DisplayTest, applyDisplayRequestsToLayersHandlesWriteClientTargetToOutput) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700596 mDisplay->applyDisplayRequests(HWC2::DisplayRequest::WriteClientTargetToOutput);
Lloyd Pique66d68602019-02-13 14:23:31 -0800597
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700598 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800599 EXPECT_FALSE(state.flipClientTarget);
600}
601
602TEST_F(DisplayTest, applyDisplayRequestsToLayersHandlesAllRequestFlagsSet) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700603 mDisplay->applyDisplayRequests(static_cast<HWC2::DisplayRequest>(~0));
Lloyd Pique66d68602019-02-13 14:23:31 -0800604
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700605 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800606 EXPECT_TRUE(state.flipClientTarget);
607}
608
609/*
610 * Display::applyLayerRequestsToLayers()
611 */
612
613TEST_F(DisplayTest, applyLayerRequestsToLayersPreparesAllLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800614 EXPECT_CALL(*mLayer1.outputLayer, prepareForDeviceLayerRequests()).Times(1);
615 EXPECT_CALL(*mLayer2.outputLayer, prepareForDeviceLayerRequests()).Times(1);
616 EXPECT_CALL(*mLayer3.outputLayer, prepareForDeviceLayerRequests()).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800617
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700618 mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests());
Lloyd Pique66d68602019-02-13 14:23:31 -0800619}
620
621TEST_F(DisplayTest, applyLayerRequestsToLayers2) {
Lloyd Piquede196652020-01-22 17:29:58 -0800622 EXPECT_CALL(*mLayer1.outputLayer, prepareForDeviceLayerRequests()).Times(1);
623 EXPECT_CALL(*mLayer2.outputLayer, prepareForDeviceLayerRequests()).Times(1);
624 EXPECT_CALL(*mLayer3.outputLayer, prepareForDeviceLayerRequests()).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800625
Lloyd Piquede196652020-01-22 17:29:58 -0800626 EXPECT_CALL(*mLayer1.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800627 applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest::CLEAR_CLIENT_TARGET))
628 .Times(1);
629
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700630 mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests{
Lloyd Piquede196652020-01-22 17:29:58 -0800631 {&mLayer1.hwc2Layer, HWC2::LayerRequest::ClearClientTarget},
632 {&hwc2LayerUnknown, HWC2::LayerRequest::ClearClientTarget},
Lloyd Pique66d68602019-02-13 14:23:31 -0800633 });
634}
635
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800636/*
637 * Display::presentAndGetFrameFences()
638 */
639
640TEST_F(DisplayTest, presentAndGetFrameFencesReturnsNoFencesOnNonHwcDisplay) {
641 auto nonHwcDisplay{
642 impl::createDisplay(mCompositionEngine, DisplayCreationArgsBuilder().build())};
643
644 auto result = nonHwcDisplay->presentAndGetFrameFences();
645
646 ASSERT_TRUE(result.presentFence.get());
647 EXPECT_FALSE(result.presentFence->isValid());
648 EXPECT_EQ(0u, result.layerFences.size());
649}
650
651TEST_F(DisplayTest, presentAndGetFrameFencesReturnsPresentAndLayerFences) {
652 sp<Fence> presentFence = new Fence();
653 sp<Fence> layer1Fence = new Fence();
654 sp<Fence> layer2Fence = new Fence();
655
656 EXPECT_CALL(mHwComposer, presentAndGetReleaseFences(DEFAULT_DISPLAY_ID)).Times(1);
657 EXPECT_CALL(mHwComposer, getPresentFence(DEFAULT_DISPLAY_ID)).WillOnce(Return(presentFence));
Lloyd Piquede196652020-01-22 17:29:58 -0800658 EXPECT_CALL(mHwComposer, getLayerReleaseFence(DEFAULT_DISPLAY_ID, &mLayer1.hwc2Layer))
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800659 .WillOnce(Return(layer1Fence));
Lloyd Piquede196652020-01-22 17:29:58 -0800660 EXPECT_CALL(mHwComposer, getLayerReleaseFence(DEFAULT_DISPLAY_ID, &mLayer2.hwc2Layer))
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800661 .WillOnce(Return(layer2Fence));
662 EXPECT_CALL(mHwComposer, clearReleaseFences(DEFAULT_DISPLAY_ID)).Times(1);
663
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700664 auto result = mDisplay->presentAndGetFrameFences();
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800665
666 EXPECT_EQ(presentFence, result.presentFence);
667
668 EXPECT_EQ(2u, result.layerFences.size());
Lloyd Piquede196652020-01-22 17:29:58 -0800669 ASSERT_EQ(1, result.layerFences.count(&mLayer1.hwc2Layer));
670 EXPECT_EQ(layer1Fence, result.layerFences[&mLayer1.hwc2Layer]);
671 ASSERT_EQ(1, result.layerFences.count(&mLayer2.hwc2Layer));
672 EXPECT_EQ(layer2Fence, result.layerFences[&mLayer2.hwc2Layer]);
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800673}
674
Lloyd Pique688abd42019-02-15 15:42:24 -0800675/*
676 * Display::setExpensiveRenderingExpected()
677 */
678
679TEST_F(DisplayTest, setExpensiveRenderingExpectedForwardsToPowerAdvisor) {
680 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, true)).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700681 mDisplay->setExpensiveRenderingExpected(true);
Lloyd Pique688abd42019-02-15 15:42:24 -0800682
683 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false)).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700684 mDisplay->setExpensiveRenderingExpected(false);
Lloyd Pique688abd42019-02-15 15:42:24 -0800685}
686
Lloyd Piqued3d69882019-02-28 16:03:46 -0800687/*
688 * Display::finishFrame()
689 */
690
691TEST_F(DisplayTest, finishFrameDoesNotSkipCompositionIfNotDirtyOnHwcDisplay) {
692 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700693 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piqued3d69882019-02-28 16:03:46 -0800694
695 // We expect no calls to queueBuffer if composition was skipped.
696 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
697
Lloyd Piquea76ce462020-01-14 13:06:37 -0800698 // Expect a call to signal no expensive rendering since there is no client composition.
699 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false));
700
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700701 mDisplay->editState().isEnabled = true;
702 mDisplay->editState().usesClientComposition = false;
703 mDisplay->editState().viewport = Rect(0, 0, 1, 1);
704 mDisplay->editState().dirtyRegion = Region::INVALID_REGION;
Lloyd Piqued3d69882019-02-28 16:03:46 -0800705
706 CompositionRefreshArgs refreshArgs;
707 refreshArgs.repaintEverything = false;
708
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700709 mDisplay->finishFrame(refreshArgs);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800710}
711
712TEST_F(DisplayTest, finishFrameSkipsCompositionIfNotDirty) {
713 std::shared_ptr<impl::Display> nonHwcDisplay{
714 impl::createDisplay(mCompositionEngine, DisplayCreationArgsBuilder().build())};
715
716 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
717 nonHwcDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
718
719 // We expect no calls to queueBuffer if composition was skipped.
720 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(0);
721
722 nonHwcDisplay->editState().isEnabled = true;
723 nonHwcDisplay->editState().usesClientComposition = false;
724 nonHwcDisplay->editState().viewport = Rect(0, 0, 1, 1);
725 nonHwcDisplay->editState().dirtyRegion = Region::INVALID_REGION;
726
727 CompositionRefreshArgs refreshArgs;
728 refreshArgs.repaintEverything = false;
729
730 nonHwcDisplay->finishFrame(refreshArgs);
731}
732
733TEST_F(DisplayTest, finishFramePerformsCompositionIfDirty) {
734 std::shared_ptr<impl::Display> nonHwcDisplay{
735 impl::createDisplay(mCompositionEngine, DisplayCreationArgsBuilder().build())};
736
737 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
738 nonHwcDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
739
740 // We expect a single call to queueBuffer when composition is not skipped.
741 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
742
743 nonHwcDisplay->editState().isEnabled = true;
744 nonHwcDisplay->editState().usesClientComposition = false;
745 nonHwcDisplay->editState().viewport = Rect(0, 0, 1, 1);
746 nonHwcDisplay->editState().dirtyRegion = Region(Rect(0, 0, 1, 1));
747
748 CompositionRefreshArgs refreshArgs;
749 refreshArgs.repaintEverything = false;
750
751 nonHwcDisplay->finishFrame(refreshArgs);
752}
753
754TEST_F(DisplayTest, finishFramePerformsCompositionIfRepaintEverything) {
755 std::shared_ptr<impl::Display> nonHwcDisplay{
756 impl::createDisplay(mCompositionEngine, DisplayCreationArgsBuilder().build())};
757
758 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
759 nonHwcDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
760
761 // We expect a single call to queueBuffer when composition is not skipped.
762 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
763
764 nonHwcDisplay->editState().isEnabled = true;
765 nonHwcDisplay->editState().usesClientComposition = false;
766 nonHwcDisplay->editState().viewport = Rect(0, 0, 1, 1);
767 nonHwcDisplay->editState().dirtyRegion = Region::INVALID_REGION;
768
769 CompositionRefreshArgs refreshArgs;
770 refreshArgs.repaintEverything = true;
771
772 nonHwcDisplay->finishFrame(refreshArgs);
773}
774
Lloyd Piquec6607552019-12-02 17:57:39 -0800775/*
776 * Display functional tests
777 */
778
779struct DisplayFunctionalTest : public testing::Test {
780 class Display : public impl::Display {
781 public:
782 explicit Display(const compositionengine::DisplayCreationArgs& args)
783 : impl::Display(args) {}
784
785 using impl::Display::injectOutputLayerForTest;
786 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
787 };
788
789 static std::shared_ptr<Display> createDisplay(
790 const compositionengine::CompositionEngine& compositionEngine,
791 compositionengine::DisplayCreationArgs&& args) {
792 return impl::createDisplayTemplated<Display>(compositionEngine, args);
793 }
794
795 DisplayFunctionalTest() {
796 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
797
798 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
799 }
800
801 NiceMock<android::mock::HWComposer> mHwComposer;
802 NiceMock<Hwc2::mock::PowerAdvisor> mPowerAdvisor;
803 NiceMock<mock::CompositionEngine> mCompositionEngine;
804 sp<mock::NativeWindow> mNativeWindow = new NiceMock<mock::NativeWindow>();
805 sp<mock::DisplaySurface> mDisplaySurface = new NiceMock<mock::DisplaySurface>();
806 std::shared_ptr<Display> mDisplay = createDisplay(mCompositionEngine,
807 DisplayCreationArgsBuilder()
808 .setDisplayId(DEFAULT_DISPLAY_ID)
809 .setPowerAdvisor(&mPowerAdvisor)
810 .build());
811 impl::RenderSurface* mRenderSurface =
812 new impl::RenderSurface{mCompositionEngine, *mDisplay,
813 RenderSurfaceCreationArgs{DEFAULT_DISPLAY_WIDTH,
814 DEFAULT_DISPLAY_HEIGHT, mNativeWindow,
815 mDisplaySurface}};
816};
817
818TEST_F(DisplayFunctionalTest, postFramebufferCriticalCallsAreOrdered) {
819 InSequence seq;
820
821 mDisplay->editState().isEnabled = true;
822
823 EXPECT_CALL(mHwComposer, presentAndGetReleaseFences(_));
824 EXPECT_CALL(*mDisplaySurface, onFrameCommitted());
825
826 mDisplay->postFramebuffer();
827}
828
Lloyd Pique45a165a2018-10-19 11:54:47 -0700829} // namespace
830} // namespace android::compositionengine