blob: 88f2686aca6b154ffd5887b90c86fde2222cbb46 [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 Piqueaad4ebf2019-10-03 17:58:30 -070033#include <ui/DisplayInfo.h>
34#include <ui/Rect.h>
Lloyd Pique45a165a2018-10-19 11:54:47 -070035
Lloyd Pique66d68602019-02-13 14:23:31 -080036#include "MockHWC2.h"
Lloyd Pique45a165a2018-10-19 11:54:47 -070037#include "MockHWComposer.h"
Lloyd Pique688abd42019-02-15 15:42:24 -080038#include "MockPowerAdvisor.h"
Lloyd Pique45a165a2018-10-19 11:54:47 -070039
40namespace android::compositionengine {
41namespace {
42
Lloyd Piquef5275482019-01-29 18:42:42 -080043using testing::_;
Lloyd Pique66d68602019-02-13 14:23:31 -080044using testing::DoAll;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070045using testing::Eq;
Lloyd Piquec6607552019-12-02 17:57:39 -080046using testing::InSequence;
47using testing::NiceMock;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070048using testing::Pointee;
49using testing::Ref;
Lloyd Pique31cb2942018-10-19 17:23:03 -070050using testing::Return;
Lloyd Pique45a165a2018-10-19 11:54:47 -070051using testing::ReturnRef;
Lloyd Pique66d68602019-02-13 14:23:31 -080052using testing::Sequence;
53using testing::SetArgPointee;
Lloyd Pique45a165a2018-10-19 11:54:47 -070054using testing::StrictMock;
55
56constexpr DisplayId DEFAULT_DISPLAY_ID = DisplayId{42};
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070057constexpr DisplayId VIRTUAL_DISPLAY_ID = DisplayId{43};
Lloyd Piquec6607552019-12-02 17:57:39 -080058constexpr int32_t DEFAULT_DISPLAY_WIDTH = 1920;
59constexpr int32_t DEFAULT_DISPLAY_HEIGHT = 1080;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070060constexpr int32_t DEFAULT_LAYER_STACK = 123;
Lloyd Pique45a165a2018-10-19 11:54:47 -070061
Lloyd Piquede196652020-01-22 17:29:58 -080062struct Layer {
63 Layer() {
64 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
65 EXPECT_CALL(*outputLayer, getHwcLayer()).WillRepeatedly(Return(&hwc2Layer));
66 }
67
68 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
69 StrictMock<mock::OutputLayer>* outputLayer = new StrictMock<mock::OutputLayer>();
70 StrictMock<HWC2::mock::Layer> hwc2Layer;
71};
72
73struct LayerNoHWC2Layer {
74 LayerNoHWC2Layer() {
75 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
76 EXPECT_CALL(*outputLayer, getHwcLayer()).WillRepeatedly(Return(nullptr));
77 }
78
79 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
80 StrictMock<mock::OutputLayer>* outputLayer = new StrictMock<mock::OutputLayer>();
81};
82
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070083struct DisplayTestCommon : public testing::Test {
84 // Uses the full implementation of a display
85 class FullImplDisplay : public impl::Display {
Lloyd Pique01c77c12019-04-17 12:48:32 -070086 public:
Lloyd Pique01c77c12019-04-17 12:48:32 -070087 using impl::Display::injectOutputLayerForTest;
88 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070089
90 using impl::Display::maybeAllocateDisplayIdForVirtualDisplay;
Lloyd Pique01c77c12019-04-17 12:48:32 -070091 };
92
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070093 // Uses a special implementation with key internal member functions set up
94 // as mock implementations, to allow for easier testing.
95 struct PartialMockDisplay : public impl::Display {
96 PartialMockDisplay(const compositionengine::CompositionEngine& compositionEngine)
97 : mCompositionEngine(compositionEngine) {}
98
99 // compositionengine::Output overrides
100 const OutputCompositionState& getState() const override { return mState; }
101 OutputCompositionState& editState() override { return mState; }
102
103 // compositionengine::impl::Output overrides
104 const CompositionEngine& getCompositionEngine() const override {
105 return mCompositionEngine;
106 };
107
108 // Mock implementation overrides
109 MOCK_CONST_METHOD0(getOutputLayerCount, size_t());
110 MOCK_CONST_METHOD1(getOutputLayerOrderedByZByIndex,
111 compositionengine::OutputLayer*(size_t));
112 MOCK_METHOD2(ensureOutputLayer,
113 compositionengine::OutputLayer*(std::optional<size_t>, const sp<LayerFE>&));
114 MOCK_METHOD0(finalizePendingOutputLayers, void());
115 MOCK_METHOD0(clearOutputLayers, void());
116 MOCK_CONST_METHOD1(dumpState, void(std::string&));
117 MOCK_METHOD1(injectOutputLayerForTest, compositionengine::OutputLayer*(const sp<LayerFE>&));
118 MOCK_METHOD1(injectOutputLayerForTest, void(std::unique_ptr<OutputLayer>));
119 MOCK_CONST_METHOD0(anyLayersRequireClientComposition, bool());
120 MOCK_CONST_METHOD0(allLayersRequireClientComposition, bool());
121 MOCK_METHOD1(applyChangedTypesToLayers, void(const impl::Display::ChangedTypes&));
122 MOCK_METHOD1(applyDisplayRequests, void(const impl::Display::DisplayRequests&));
123 MOCK_METHOD1(applyLayerRequestsToLayers, void(const impl::Display::LayerRequests&));
124
125 const compositionengine::CompositionEngine& mCompositionEngine;
126 impl::OutputCompositionState mState;
127 };
128
129 static std::string getDisplayNameFromCurrentTest() {
130 const ::testing::TestInfo* const test_info =
131 ::testing::UnitTest::GetInstance()->current_test_info();
132 return std::string("display for ") + test_info->test_case_name() + "." + test_info->name();
133 }
134
135 template <typename Display>
Lloyd Pique01c77c12019-04-17 12:48:32 -0700136 static std::shared_ptr<Display> createDisplay(
137 const compositionengine::CompositionEngine& compositionEngine,
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700138 compositionengine::DisplayCreationArgs args) {
139 args.name = getDisplayNameFromCurrentTest();
Lloyd Pique01c77c12019-04-17 12:48:32 -0700140 return impl::createDisplayTemplated<Display>(compositionEngine, args);
141 }
142
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700143 template <typename Display>
144 static std::shared_ptr<StrictMock<Display>> createPartialMockDisplay(
145 const compositionengine::CompositionEngine& compositionEngine,
146 compositionengine::DisplayCreationArgs args) {
147 args.name = getDisplayNameFromCurrentTest();
148 auto display = std::make_shared<StrictMock<Display>>(compositionEngine);
Lloyd Pique66d68602019-02-13 14:23:31 -0800149
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700150 display->setConfiguration(args);
151
152 return display;
153 }
154
155 DisplayTestCommon() {
156 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
157 }
158
159 DisplayCreationArgs getDisplayCreationArgsForPhysicalHWCDisplay() {
160 return DisplayCreationArgsBuilder()
161 .setPhysical({DEFAULT_DISPLAY_ID, DisplayConnectionType::Internal})
162 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
163 .setPixelFormat(static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888))
164 .setIsSecure(true)
165 .setLayerStackId(DEFAULT_LAYER_STACK)
166 .setPowerAdvisor(&mPowerAdvisor)
167 .build();
168 }
169
170 DisplayCreationArgs getDisplayCreationArgsForNonHWCVirtualDisplay() {
171 return DisplayCreationArgsBuilder()
172 .setUseHwcVirtualDisplays(false)
173 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
174 .setPixelFormat(static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888))
175 .setIsSecure(false)
176 .setLayerStackId(DEFAULT_LAYER_STACK)
177 .setPowerAdvisor(&mPowerAdvisor)
178 .build();
179 }
180
181 StrictMock<android::mock::HWComposer> mHwComposer;
182 StrictMock<Hwc2::mock::PowerAdvisor> mPowerAdvisor;
183 StrictMock<mock::CompositionEngine> mCompositionEngine;
184 sp<mock::NativeWindow> mNativeWindow = new StrictMock<mock::NativeWindow>();
185};
186
187struct PartialMockDisplayTestCommon : public DisplayTestCommon {
188 using Display = DisplayTestCommon::PartialMockDisplay;
189 std::shared_ptr<Display> mDisplay =
190 createPartialMockDisplay<Display>(mCompositionEngine,
191 getDisplayCreationArgsForPhysicalHWCDisplay());
192};
193
194struct FullDisplayImplTestCommon : public DisplayTestCommon {
195 using Display = DisplayTestCommon::FullImplDisplay;
196 std::shared_ptr<Display> mDisplay =
197 createDisplay<Display>(mCompositionEngine,
198 getDisplayCreationArgsForPhysicalHWCDisplay());
199};
200
201struct DisplayWithLayersTestCommon : public FullDisplayImplTestCommon {
202 DisplayWithLayersTestCommon() {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700203 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -0800204 std::unique_ptr<compositionengine::OutputLayer>(mLayer1.outputLayer));
Lloyd Pique01c77c12019-04-17 12:48:32 -0700205 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -0800206 std::unique_ptr<compositionengine::OutputLayer>(mLayer2.outputLayer));
Lloyd Pique01c77c12019-04-17 12:48:32 -0700207 mDisplay->injectOutputLayerForTest(
Lloyd Piquede196652020-01-22 17:29:58 -0800208 std::unique_ptr<compositionengine::OutputLayer>(mLayer3.outputLayer));
Lloyd Pique66d68602019-02-13 14:23:31 -0800209 }
Lloyd Pique45a165a2018-10-19 11:54:47 -0700210
Lloyd Piquede196652020-01-22 17:29:58 -0800211 Layer mLayer1;
212 Layer mLayer2;
213 LayerNoHWC2Layer mLayer3;
214 StrictMock<HWC2::mock::Layer> hwc2LayerUnknown;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700215 std::shared_ptr<Display> mDisplay =
216 createDisplay<Display>(mCompositionEngine,
217 getDisplayCreationArgsForPhysicalHWCDisplay());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700218};
219
Lloyd Pique66d68602019-02-13 14:23:31 -0800220/*
Lloyd Pique45a165a2018-10-19 11:54:47 -0700221 * Basic construction
222 */
223
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700224struct DisplayCreationTest : public DisplayTestCommon {
225 using Display = DisplayTestCommon::FullImplDisplay;
226};
Lloyd Pique45a165a2018-10-19 11:54:47 -0700227
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700228TEST_F(DisplayCreationTest, createPhysicalInternalDisplay) {
229 auto display =
230 impl::createDisplay(mCompositionEngine, getDisplayCreationArgsForPhysicalHWCDisplay());
231 EXPECT_TRUE(display->isSecure());
232 EXPECT_FALSE(display->isVirtual());
233 EXPECT_EQ(DEFAULT_DISPLAY_ID, display->getId());
234}
Lloyd Pique45a165a2018-10-19 11:54:47 -0700235
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700236TEST_F(DisplayCreationTest, createNonHwcVirtualDisplay) {
237 auto display = impl::createDisplay(mCompositionEngine,
238 getDisplayCreationArgsForNonHWCVirtualDisplay());
239 EXPECT_FALSE(display->isSecure());
240 EXPECT_TRUE(display->isVirtual());
241 EXPECT_EQ(std::nullopt, display->getId());
242}
243
244/*
245 * Display::setConfiguration()
246 */
247
248using DisplaySetConfigurationTest = PartialMockDisplayTestCommon;
249
250TEST_F(DisplaySetConfigurationTest, configuresInternalSecurePhysicalDisplay) {
251 mDisplay->setConfiguration(
252 DisplayCreationArgsBuilder()
253 .setUseHwcVirtualDisplays(true)
254 .setPhysical({DEFAULT_DISPLAY_ID, DisplayConnectionType::Internal})
255 .setPixels(ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_WIDTH))
256 .setPixelFormat(static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888))
257 .setIsSecure(true)
258 .setLayerStackId(DEFAULT_LAYER_STACK)
259 .setPowerAdvisor(&mPowerAdvisor)
260 .setName(getDisplayNameFromCurrentTest())
261 .build());
262
263 EXPECT_EQ(DEFAULT_DISPLAY_ID, mDisplay->getId());
264 EXPECT_TRUE(mDisplay->isSecure());
265 EXPECT_FALSE(mDisplay->isVirtual());
266 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
267 EXPECT_TRUE(mDisplay->getState().layerStackInternal);
268 EXPECT_FALSE(mDisplay->isValid());
269}
270
271TEST_F(DisplaySetConfigurationTest, configuresExternalInsecurePhysicalDisplay) {
272 mDisplay->setConfiguration(
273 DisplayCreationArgsBuilder()
274 .setUseHwcVirtualDisplays(true)
275 .setPhysical({DEFAULT_DISPLAY_ID, DisplayConnectionType::External})
276 .setPixels(ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_WIDTH))
277 .setPixelFormat(static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888))
278 .setIsSecure(false)
279 .setLayerStackId(DEFAULT_LAYER_STACK)
280 .setPowerAdvisor(&mPowerAdvisor)
281 .setName(getDisplayNameFromCurrentTest())
282 .build());
283
284 EXPECT_EQ(DEFAULT_DISPLAY_ID, mDisplay->getId());
285 EXPECT_FALSE(mDisplay->isSecure());
286 EXPECT_FALSE(mDisplay->isVirtual());
287 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
288 EXPECT_FALSE(mDisplay->getState().layerStackInternal);
289 EXPECT_FALSE(mDisplay->isValid());
290}
291
292TEST_F(DisplaySetConfigurationTest, configuresHwcBackedVirtualDisplay) {
293 EXPECT_CALL(mHwComposer,
294 allocateVirtualDisplay(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_WIDTH,
295 Pointee(Eq(static_cast<ui::PixelFormat>(
296 PIXEL_FORMAT_RGBA_8888)))))
297 .WillOnce(Return(VIRTUAL_DISPLAY_ID));
298
299 mDisplay->setConfiguration(
300 DisplayCreationArgsBuilder()
301 .setUseHwcVirtualDisplays(true)
302 .setPixels(ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_WIDTH))
303 .setPixelFormat(static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888))
304 .setIsSecure(false)
305 .setLayerStackId(DEFAULT_LAYER_STACK)
306 .setPowerAdvisor(&mPowerAdvisor)
307 .setName(getDisplayNameFromCurrentTest())
308 .build());
309
310 EXPECT_EQ(VIRTUAL_DISPLAY_ID, mDisplay->getId());
311 EXPECT_FALSE(mDisplay->isSecure());
312 EXPECT_TRUE(mDisplay->isVirtual());
313 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
314 EXPECT_FALSE(mDisplay->getState().layerStackInternal);
315 EXPECT_FALSE(mDisplay->isValid());
316}
317
318TEST_F(DisplaySetConfigurationTest, configuresNonHwcBackedVirtualDisplayIfHwcAllocationFails) {
319 EXPECT_CALL(mHwComposer,
320 allocateVirtualDisplay(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_WIDTH,
321 Pointee(Eq(static_cast<ui::PixelFormat>(
322 PIXEL_FORMAT_RGBA_8888)))))
323 .WillOnce(Return(std::nullopt));
324
325 mDisplay->setConfiguration(
326 DisplayCreationArgsBuilder()
327 .setUseHwcVirtualDisplays(true)
328 .setPixels(ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_WIDTH))
329 .setPixelFormat(static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888))
330 .setIsSecure(false)
331 .setLayerStackId(DEFAULT_LAYER_STACK)
332 .setPowerAdvisor(&mPowerAdvisor)
333 .setName(getDisplayNameFromCurrentTest())
334 .build());
335
336 EXPECT_EQ(std::nullopt, mDisplay->getId());
337 EXPECT_FALSE(mDisplay->isSecure());
338 EXPECT_TRUE(mDisplay->isVirtual());
339 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
340 EXPECT_FALSE(mDisplay->getState().layerStackInternal);
341 EXPECT_FALSE(mDisplay->isValid());
342}
343
344TEST_F(DisplaySetConfigurationTest, configuresNonHwcBackedVirtualDisplayIfShouldNotUseHwc) {
345 mDisplay->setConfiguration(
346 DisplayCreationArgsBuilder()
347 .setUseHwcVirtualDisplays(false)
348 .setPixels(ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_WIDTH))
349 .setPixelFormat(static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888))
350 .setIsSecure(false)
351 .setLayerStackId(DEFAULT_LAYER_STACK)
352 .setPowerAdvisor(&mPowerAdvisor)
353 .setName(getDisplayNameFromCurrentTest())
354 .build());
355
356 EXPECT_EQ(std::nullopt, mDisplay->getId());
357 EXPECT_FALSE(mDisplay->isSecure());
358 EXPECT_TRUE(mDisplay->isVirtual());
359 EXPECT_EQ(DEFAULT_LAYER_STACK, mDisplay->getState().layerStackId);
360 EXPECT_FALSE(mDisplay->getState().layerStackInternal);
361 EXPECT_FALSE(mDisplay->isValid());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700362}
363
Lloyd Pique66d68602019-02-13 14:23:31 -0800364/*
Lloyd Pique45a165a2018-10-19 11:54:47 -0700365 * Display::disconnect()
366 */
367
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700368using DisplayDisconnectTest = PartialMockDisplayTestCommon;
369
370TEST_F(DisplayDisconnectTest, disconnectsDisplay) {
Lloyd Pique45a165a2018-10-19 11:54:47 -0700371 // The first call to disconnect will disconnect the display with the HWC and
372 // set mHwcId to -1.
373 EXPECT_CALL(mHwComposer, disconnectDisplay(DEFAULT_DISPLAY_ID)).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700374 mDisplay->disconnect();
375 EXPECT_FALSE(mDisplay->getId());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700376
377 // Subsequent calls will do nothing,
378 EXPECT_CALL(mHwComposer, disconnectDisplay(DEFAULT_DISPLAY_ID)).Times(0);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700379 mDisplay->disconnect();
380 EXPECT_FALSE(mDisplay->getId());
Lloyd Pique45a165a2018-10-19 11:54:47 -0700381}
382
Lloyd Pique66d68602019-02-13 14:23:31 -0800383/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700384 * Display::setColorTransform()
385 */
386
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700387using DisplaySetColorTransformTest = PartialMockDisplayTestCommon;
388
389TEST_F(DisplaySetColorTransformTest, setsTransform) {
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800390 // No change does nothing
391 CompositionRefreshArgs refreshArgs;
392 refreshArgs.colorTransformMatrix = std::nullopt;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700393 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800394
Lloyd Pique32cbe282018-10-19 13:09:22 -0700395 // Identity matrix sets an identity state value
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800396 const mat4 kIdentity;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700397
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800398 EXPECT_CALL(mHwComposer, setColorTransform(DEFAULT_DISPLAY_ID, kIdentity)).Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700399
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800400 refreshArgs.colorTransformMatrix = kIdentity;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700401 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700402
403 // Non-identity matrix sets a non-identity state value
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800404 const mat4 kNonIdentity = mat4() * 2;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700405
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800406 EXPECT_CALL(mHwComposer, setColorTransform(DEFAULT_DISPLAY_ID, kNonIdentity)).Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700407
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800408 refreshArgs.colorTransformMatrix = kNonIdentity;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700409 mDisplay->setColorTransform(refreshArgs);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700410}
411
Lloyd Pique66d68602019-02-13 14:23:31 -0800412/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700413 * Display::setColorMode()
414 */
415
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700416using DisplaySetColorModeTest = PartialMockDisplayTestCommon;
417
418TEST_F(DisplaySetColorModeTest, setsModeUnlessNoChange) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800419 using ColorProfile = Output::ColorProfile;
420
Lloyd Pique31cb2942018-10-19 17:23:03 -0700421 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700422 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piquef5275482019-01-29 18:42:42 -0800423 mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700424 mDisplay->setDisplayColorProfileForTest(std::unique_ptr<DisplayColorProfile>(colorProfile));
Lloyd Pique31cb2942018-10-19 17:23:03 -0700425
Lloyd Piquef5275482019-01-29 18:42:42 -0800426 EXPECT_CALL(*colorProfile, getTargetDataspace(_, _, _))
427 .WillRepeatedly(Return(ui::Dataspace::UNKNOWN));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700428
429 // These values are expected to be the initial state.
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700430 ASSERT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
431 ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
432 ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
433 ASSERT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700434
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700435 // Otherwise if the values are unchanged, nothing happens
436 mDisplay->setColorProfile(ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
437 ui::RenderIntent::COLORIMETRIC, ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700438
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700439 EXPECT_EQ(ui::ColorMode::NATIVE, mDisplay->getState().colorMode);
440 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().dataspace);
441 EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, mDisplay->getState().renderIntent);
442 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700443
444 // Otherwise if the values are different, updates happen
Lloyd Piqueef958122019-02-05 18:00:12 -0800445 EXPECT_CALL(*renderSurface, setBufferDataspace(ui::Dataspace::DISPLAY_P3)).Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700446 EXPECT_CALL(mHwComposer,
Lloyd Piqueef958122019-02-05 18:00:12 -0800447 setActiveColorMode(DEFAULT_DISPLAY_ID, ui::ColorMode::DISPLAY_P3,
Lloyd Pique32cbe282018-10-19 13:09:22 -0700448 ui::RenderIntent::TONE_MAP_COLORIMETRIC))
449 .Times(1);
450
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700451 mDisplay->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
452 ui::RenderIntent::TONE_MAP_COLORIMETRIC,
453 ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700454
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700455 EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mDisplay->getState().colorMode);
456 EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mDisplay->getState().dataspace);
457 EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mDisplay->getState().renderIntent);
458 EXPECT_EQ(ui::Dataspace::UNKNOWN, mDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700459}
460
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700461TEST_F(DisplaySetColorModeTest, doesNothingForVirtualDisplay) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800462 using ColorProfile = Output::ColorProfile;
463
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700464 auto args = getDisplayCreationArgsForNonHWCVirtualDisplay();
465 std::shared_ptr<impl::Display> virtualDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700466
Lloyd Piquef5275482019-01-29 18:42:42 -0800467 mock::DisplayColorProfile* colorProfile = new StrictMock<mock::DisplayColorProfile>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700468 virtualDisplay->setDisplayColorProfileForTest(
Lloyd Piquef5275482019-01-29 18:42:42 -0800469 std::unique_ptr<DisplayColorProfile>(colorProfile));
470
471 EXPECT_CALL(*colorProfile,
472 getTargetDataspace(ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
473 ui::Dataspace::UNKNOWN))
474 .WillOnce(Return(ui::Dataspace::UNKNOWN));
475
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700476 virtualDisplay->setColorProfile(
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800477 ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
478 ui::RenderIntent::TONE_MAP_COLORIMETRIC, ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700479
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700480 EXPECT_EQ(ui::ColorMode::NATIVE, virtualDisplay->getState().colorMode);
481 EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().dataspace);
482 EXPECT_EQ(ui::RenderIntent::COLORIMETRIC, virtualDisplay->getState().renderIntent);
483 EXPECT_EQ(ui::Dataspace::UNKNOWN, virtualDisplay->getState().targetDataspace);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700484}
485
Lloyd Pique66d68602019-02-13 14:23:31 -0800486/*
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700487 * Display::createDisplayColorProfile()
488 */
489
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700490using DisplayCreateColorProfileTest = PartialMockDisplayTestCommon;
491
492TEST_F(DisplayCreateColorProfileTest, setsDisplayColorProfile) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700493 EXPECT_TRUE(mDisplay->getDisplayColorProfile() == nullptr);
494 mDisplay->createDisplayColorProfile(
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700495 DisplayColorProfileCreationArgs{false, HdrCapabilities(), 0,
496 DisplayColorProfileCreationArgs::HwcColorModes()});
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700497 EXPECT_TRUE(mDisplay->getDisplayColorProfile() != nullptr);
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700498}
499
Lloyd Pique66d68602019-02-13 14:23:31 -0800500/*
Lloyd Pique31cb2942018-10-19 17:23:03 -0700501 * Display::createRenderSurface()
502 */
503
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700504using DisplayCreateRenderSurfaceTest = PartialMockDisplayTestCommon;
505
506TEST_F(DisplayCreateRenderSurfaceTest, setsRenderSurface) {
chaviw8beb4142019-04-11 13:09:05 -0700507 EXPECT_CALL(*mNativeWindow, disconnect(NATIVE_WINDOW_API_EGL)).WillRepeatedly(Return(NO_ERROR));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700508 EXPECT_TRUE(mDisplay->getRenderSurface() == nullptr);
509 mDisplay->createRenderSurface(RenderSurfaceCreationArgs{640, 480, mNativeWindow, nullptr});
510 EXPECT_TRUE(mDisplay->getRenderSurface() != nullptr);
Lloyd Pique31cb2942018-10-19 17:23:03 -0700511}
512
Lloyd Pique66d68602019-02-13 14:23:31 -0800513/*
Lloyd Piquedf336d92019-03-07 21:38:42 -0800514 * Display::createOutputLayer()
515 */
516
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700517using DisplayCreateOutputLayerTest = FullDisplayImplTestCommon;
518
519TEST_F(DisplayCreateOutputLayerTest, setsHwcLayer) {
Lloyd Piquedf336d92019-03-07 21:38:42 -0800520 sp<mock::LayerFE> layerFE = new StrictMock<mock::LayerFE>();
Lloyd Piquedf336d92019-03-07 21:38:42 -0800521 StrictMock<HWC2::mock::Layer> hwcLayer;
522
523 EXPECT_CALL(mHwComposer, createLayer(DEFAULT_DISPLAY_ID)).WillOnce(Return(&hwcLayer));
524
Lloyd Piquede196652020-01-22 17:29:58 -0800525 auto outputLayer = mDisplay->createOutputLayer(layerFE);
Lloyd Piquedf336d92019-03-07 21:38:42 -0800526
527 EXPECT_EQ(&hwcLayer, outputLayer->getHwcLayer());
528
529 EXPECT_CALL(mHwComposer, destroyLayer(DEFAULT_DISPLAY_ID, &hwcLayer));
530 outputLayer.reset();
531}
532
533/*
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800534 * Display::setReleasedLayers()
535 */
536
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700537using DisplaySetReleasedLayersTest = DisplayWithLayersTestCommon;
538
539TEST_F(DisplaySetReleasedLayersTest, doesNothingIfNotHwcDisplay) {
540 auto args = getDisplayCreationArgsForNonHWCVirtualDisplay();
541 std::shared_ptr<impl::Display> nonHwcDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800542
543 sp<mock::LayerFE> layerXLayerFE = new StrictMock<mock::LayerFE>();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800544
545 {
546 Output::ReleasedLayers releasedLayers;
547 releasedLayers.emplace_back(layerXLayerFE);
548 nonHwcDisplay->setReleasedLayers(std::move(releasedLayers));
549 }
550
551 CompositionRefreshArgs refreshArgs;
Lloyd Piquede196652020-01-22 17:29:58 -0800552 refreshArgs.layersWithQueuedFrames.push_back(layerXLayerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800553
554 nonHwcDisplay->setReleasedLayers(refreshArgs);
555
556 const auto& releasedLayers = nonHwcDisplay->getReleasedLayersForTest();
557 ASSERT_EQ(1, releasedLayers.size());
558}
559
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700560TEST_F(DisplaySetReleasedLayersTest, doesNothingIfNoLayersWithQueuedFrames) {
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800561 sp<mock::LayerFE> layerXLayerFE = new StrictMock<mock::LayerFE>();
562
563 {
564 Output::ReleasedLayers releasedLayers;
565 releasedLayers.emplace_back(layerXLayerFE);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700566 mDisplay->setReleasedLayers(std::move(releasedLayers));
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800567 }
568
569 CompositionRefreshArgs refreshArgs;
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700570 mDisplay->setReleasedLayers(refreshArgs);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800571
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700572 const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800573 ASSERT_EQ(1, releasedLayers.size());
574}
575
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700576TEST_F(DisplaySetReleasedLayersTest, setReleasedLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800577 sp<mock::LayerFE> unknownLayer = new StrictMock<mock::LayerFE>();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800578
579 CompositionRefreshArgs refreshArgs;
Lloyd Piquede196652020-01-22 17:29:58 -0800580 refreshArgs.layersWithQueuedFrames.push_back(mLayer1.layerFE);
581 refreshArgs.layersWithQueuedFrames.push_back(mLayer2.layerFE);
582 refreshArgs.layersWithQueuedFrames.push_back(unknownLayer);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800583
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700584 mDisplay->setReleasedLayers(refreshArgs);
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800585
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700586 const auto& releasedLayers = mDisplay->getReleasedLayersForTest();
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800587 ASSERT_EQ(2, releasedLayers.size());
Lloyd Piquede196652020-01-22 17:29:58 -0800588 ASSERT_EQ(mLayer1.layerFE.get(), releasedLayers[0].promote().get());
589 ASSERT_EQ(mLayer2.layerFE.get(), releasedLayers[1].promote().get());
Lloyd Piquec29e4c62019-03-07 21:48:19 -0800590}
591
592/*
Lloyd Pique66d68602019-02-13 14:23:31 -0800593 * Display::chooseCompositionStrategy()
594 */
595
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700596using DisplayChooseCompositionStrategyTest = PartialMockDisplayTestCommon;
Lloyd Pique66d68602019-02-13 14:23:31 -0800597
598TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutIfNotAHwcDisplay) {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700599 auto args = getDisplayCreationArgsForNonHWCVirtualDisplay();
600 std::shared_ptr<Display> nonHwcDisplay =
601 createPartialMockDisplay<Display>(mCompositionEngine, args);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700602 EXPECT_FALSE(nonHwcDisplay->getId());
Lloyd Pique66d68602019-02-13 14:23:31 -0800603
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700604 nonHwcDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800605
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700606 auto& state = nonHwcDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800607 EXPECT_TRUE(state.usesClientComposition);
608 EXPECT_FALSE(state.usesDeviceComposition);
609}
610
611TEST_F(DisplayChooseCompositionStrategyTest, takesEarlyOutOnHwcError) {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700612 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800613 EXPECT_CALL(mHwComposer, getDeviceCompositionChanges(DEFAULT_DISPLAY_ID, false, _))
614 .WillOnce(Return(INVALID_OPERATION));
615
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700616 mDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800617
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700618 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800619 EXPECT_TRUE(state.usesClientComposition);
620 EXPECT_FALSE(state.usesDeviceComposition);
621}
622
623TEST_F(DisplayChooseCompositionStrategyTest, normalOperation) {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700624 // Since two calls are made to anyLayersRequireClientComposition with different return
625 // values, use a Sequence to control the matching so the values are returned in a known
626 // order.
Lloyd Pique66d68602019-02-13 14:23:31 -0800627 Sequence s;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700628 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
629 .InSequence(s)
630 .WillOnce(Return(true));
631 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
Lloyd Pique66d68602019-02-13 14:23:31 -0800632 .InSequence(s)
633 .WillOnce(Return(false));
634
635 EXPECT_CALL(mHwComposer, getDeviceCompositionChanges(DEFAULT_DISPLAY_ID, true, _))
636 .WillOnce(Return(NO_ERROR));
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700637 EXPECT_CALL(*mDisplay, allLayersRequireClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800638
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700639 mDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800640
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700641 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800642 EXPECT_FALSE(state.usesClientComposition);
643 EXPECT_TRUE(state.usesDeviceComposition);
644}
645
646TEST_F(DisplayChooseCompositionStrategyTest, normalOperationWithChanges) {
647 android::HWComposer::DeviceRequestedChanges changes{
648 {{nullptr, HWC2::Composition::Client}},
649 HWC2::DisplayRequest::FlipClientTarget,
650 {{nullptr, HWC2::LayerRequest::ClearClientTarget}},
651 };
652
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700653 // Since two calls are made to anyLayersRequireClientComposition with different return
654 // values, use a Sequence to control the matching so the values are returned in a known
655 // order.
Lloyd Pique66d68602019-02-13 14:23:31 -0800656 Sequence s;
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700657 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
658 .InSequence(s)
659 .WillOnce(Return(true));
660 EXPECT_CALL(*mDisplay, anyLayersRequireClientComposition())
Lloyd Pique66d68602019-02-13 14:23:31 -0800661 .InSequence(s)
662 .WillOnce(Return(false));
663
664 EXPECT_CALL(mHwComposer, getDeviceCompositionChanges(DEFAULT_DISPLAY_ID, true, _))
665 .WillOnce(DoAll(SetArgPointee<2>(changes), Return(NO_ERROR)));
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700666 EXPECT_CALL(*mDisplay, applyChangedTypesToLayers(changes.changedTypes)).Times(1);
667 EXPECT_CALL(*mDisplay, applyDisplayRequests(changes.displayRequests)).Times(1);
668 EXPECT_CALL(*mDisplay, applyLayerRequestsToLayers(changes.layerRequests)).Times(1);
669 EXPECT_CALL(*mDisplay, allLayersRequireClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800670
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700671 mDisplay->chooseCompositionStrategy();
Lloyd Pique66d68602019-02-13 14:23:31 -0800672
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700673 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800674 EXPECT_FALSE(state.usesClientComposition);
675 EXPECT_TRUE(state.usesDeviceComposition);
676}
677
678/*
Lloyd Pique688abd42019-02-15 15:42:24 -0800679 * Display::getSkipColorTransform()
680 */
681
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700682using DisplayGetSkipColorTransformTest = DisplayWithLayersTestCommon;
683
684TEST_F(DisplayGetSkipColorTransformTest, doesNothingIfNonHwcDisplay) {
685 auto args = getDisplayCreationArgsForNonHWCVirtualDisplay();
686 auto nonHwcDisplay{impl::createDisplay(mCompositionEngine, args)};
Lloyd Pique688abd42019-02-15 15:42:24 -0800687 EXPECT_FALSE(nonHwcDisplay->getSkipColorTransform());
688}
689
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700690TEST_F(DisplayGetSkipColorTransformTest, checksHwcCapability) {
Lloyd Pique688abd42019-02-15 15:42:24 -0800691 EXPECT_CALL(mHwComposer,
692 hasDisplayCapability(std::make_optional(DEFAULT_DISPLAY_ID),
693 HWC2::DisplayCapability::SkipClientColorTransform))
694 .WillOnce(Return(true));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700695 EXPECT_TRUE(mDisplay->getSkipColorTransform());
Lloyd Pique688abd42019-02-15 15:42:24 -0800696}
697
698/*
Lloyd Pique66d68602019-02-13 14:23:31 -0800699 * Display::anyLayersRequireClientComposition()
700 */
701
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700702using DisplayAnyLayersRequireClientCompositionTest = DisplayWithLayersTestCommon;
703
704TEST_F(DisplayAnyLayersRequireClientCompositionTest, returnsFalse) {
Lloyd Piquede196652020-01-22 17:29:58 -0800705 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(false));
706 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(false));
707 EXPECT_CALL(*mLayer3.outputLayer, requiresClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800708
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700709 EXPECT_FALSE(mDisplay->anyLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800710}
711
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700712TEST_F(DisplayAnyLayersRequireClientCompositionTest, returnsTrue) {
Lloyd Piquede196652020-01-22 17:29:58 -0800713 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(false));
714 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(true));
Lloyd Pique66d68602019-02-13 14:23:31 -0800715
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700716 EXPECT_TRUE(mDisplay->anyLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800717}
718
719/*
720 * Display::allLayersRequireClientComposition()
721 */
722
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700723using DisplayAllLayersRequireClientCompositionTest = DisplayWithLayersTestCommon;
724
725TEST_F(DisplayAllLayersRequireClientCompositionTest, returnsTrue) {
Lloyd Piquede196652020-01-22 17:29:58 -0800726 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(true));
727 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(true));
728 EXPECT_CALL(*mLayer3.outputLayer, requiresClientComposition()).WillOnce(Return(true));
Lloyd Pique66d68602019-02-13 14:23:31 -0800729
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700730 EXPECT_TRUE(mDisplay->allLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800731}
732
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700733TEST_F(DisplayAllLayersRequireClientCompositionTest, returnsFalse) {
Lloyd Piquede196652020-01-22 17:29:58 -0800734 EXPECT_CALL(*mLayer1.outputLayer, requiresClientComposition()).WillOnce(Return(true));
735 EXPECT_CALL(*mLayer2.outputLayer, requiresClientComposition()).WillOnce(Return(false));
Lloyd Pique66d68602019-02-13 14:23:31 -0800736
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700737 EXPECT_FALSE(mDisplay->allLayersRequireClientComposition());
Lloyd Pique66d68602019-02-13 14:23:31 -0800738}
739
740/*
741 * Display::applyChangedTypesToLayers()
742 */
743
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700744using DisplayApplyChangedTypesToLayersTest = DisplayWithLayersTestCommon;
745
746TEST_F(DisplayApplyChangedTypesToLayersTest, takesEarlyOutIfNoChangedLayers) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700747 mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes());
Lloyd Pique66d68602019-02-13 14:23:31 -0800748}
749
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700750TEST_F(DisplayApplyChangedTypesToLayersTest, appliesChanges) {
Lloyd Piquede196652020-01-22 17:29:58 -0800751 EXPECT_CALL(*mLayer1.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800752 applyDeviceCompositionTypeChange(Hwc2::IComposerClient::Composition::CLIENT))
753 .Times(1);
Lloyd Piquede196652020-01-22 17:29:58 -0800754 EXPECT_CALL(*mLayer2.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800755 applyDeviceCompositionTypeChange(Hwc2::IComposerClient::Composition::DEVICE))
756 .Times(1);
757
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700758 mDisplay->applyChangedTypesToLayers(impl::Display::ChangedTypes{
Lloyd Piquede196652020-01-22 17:29:58 -0800759 {&mLayer1.hwc2Layer, HWC2::Composition::Client},
760 {&mLayer2.hwc2Layer, HWC2::Composition::Device},
761 {&hwc2LayerUnknown, HWC2::Composition::SolidColor},
Lloyd Pique66d68602019-02-13 14:23:31 -0800762 });
763}
764
765/*
766 * Display::applyDisplayRequests()
767 */
768
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700769using DisplayApplyDisplayRequestsTest = DisplayWithLayersTestCommon;
770
771TEST_F(DisplayApplyDisplayRequestsTest, handlesNoRequests) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700772 mDisplay->applyDisplayRequests(static_cast<HWC2::DisplayRequest>(0));
Lloyd Pique66d68602019-02-13 14:23:31 -0800773
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700774 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800775 EXPECT_FALSE(state.flipClientTarget);
776}
777
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700778TEST_F(DisplayApplyDisplayRequestsTest, handlesFlipClientTarget) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700779 mDisplay->applyDisplayRequests(HWC2::DisplayRequest::FlipClientTarget);
Lloyd Pique66d68602019-02-13 14:23:31 -0800780
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700781 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800782 EXPECT_TRUE(state.flipClientTarget);
783}
784
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700785TEST_F(DisplayApplyDisplayRequestsTest, handlesWriteClientTargetToOutput) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700786 mDisplay->applyDisplayRequests(HWC2::DisplayRequest::WriteClientTargetToOutput);
Lloyd Pique66d68602019-02-13 14:23:31 -0800787
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700788 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800789 EXPECT_FALSE(state.flipClientTarget);
790}
791
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700792TEST_F(DisplayApplyDisplayRequestsTest, handlesAllRequestFlagsSet) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700793 mDisplay->applyDisplayRequests(static_cast<HWC2::DisplayRequest>(~0));
Lloyd Pique66d68602019-02-13 14:23:31 -0800794
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700795 auto& state = mDisplay->getState();
Lloyd Pique66d68602019-02-13 14:23:31 -0800796 EXPECT_TRUE(state.flipClientTarget);
797}
798
799/*
800 * Display::applyLayerRequestsToLayers()
801 */
802
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700803using DisplayApplyLayerRequestsToLayersTest = DisplayWithLayersTestCommon;
804
805TEST_F(DisplayApplyLayerRequestsToLayersTest, preparesAllLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800806 EXPECT_CALL(*mLayer1.outputLayer, prepareForDeviceLayerRequests()).Times(1);
807 EXPECT_CALL(*mLayer2.outputLayer, prepareForDeviceLayerRequests()).Times(1);
808 EXPECT_CALL(*mLayer3.outputLayer, prepareForDeviceLayerRequests()).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800809
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700810 mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests());
Lloyd Pique66d68602019-02-13 14:23:31 -0800811}
812
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700813TEST_F(DisplayApplyLayerRequestsToLayersTest, appliesDeviceLayerRequests) {
Lloyd Piquede196652020-01-22 17:29:58 -0800814 EXPECT_CALL(*mLayer1.outputLayer, prepareForDeviceLayerRequests()).Times(1);
815 EXPECT_CALL(*mLayer2.outputLayer, prepareForDeviceLayerRequests()).Times(1);
816 EXPECT_CALL(*mLayer3.outputLayer, prepareForDeviceLayerRequests()).Times(1);
Lloyd Pique66d68602019-02-13 14:23:31 -0800817
Lloyd Piquede196652020-01-22 17:29:58 -0800818 EXPECT_CALL(*mLayer1.outputLayer,
Lloyd Pique66d68602019-02-13 14:23:31 -0800819 applyDeviceLayerRequest(Hwc2::IComposerClient::LayerRequest::CLEAR_CLIENT_TARGET))
820 .Times(1);
821
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700822 mDisplay->applyLayerRequestsToLayers(impl::Display::LayerRequests{
Lloyd Piquede196652020-01-22 17:29:58 -0800823 {&mLayer1.hwc2Layer, HWC2::LayerRequest::ClearClientTarget},
824 {&hwc2LayerUnknown, HWC2::LayerRequest::ClearClientTarget},
Lloyd Pique66d68602019-02-13 14:23:31 -0800825 });
826}
827
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800828/*
829 * Display::presentAndGetFrameFences()
830 */
831
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700832using DisplayPresentAndGetFrameFencesTest = DisplayWithLayersTestCommon;
833
834TEST_F(DisplayPresentAndGetFrameFencesTest, returnsNoFencesOnNonHwcDisplay) {
835 auto args = getDisplayCreationArgsForNonHWCVirtualDisplay();
836 auto nonHwcDisplay{impl::createDisplay(mCompositionEngine, args)};
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800837
838 auto result = nonHwcDisplay->presentAndGetFrameFences();
839
840 ASSERT_TRUE(result.presentFence.get());
841 EXPECT_FALSE(result.presentFence->isValid());
842 EXPECT_EQ(0u, result.layerFences.size());
843}
844
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700845TEST_F(DisplayPresentAndGetFrameFencesTest, returnsPresentAndLayerFences) {
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800846 sp<Fence> presentFence = new Fence();
847 sp<Fence> layer1Fence = new Fence();
848 sp<Fence> layer2Fence = new Fence();
849
850 EXPECT_CALL(mHwComposer, presentAndGetReleaseFences(DEFAULT_DISPLAY_ID)).Times(1);
851 EXPECT_CALL(mHwComposer, getPresentFence(DEFAULT_DISPLAY_ID)).WillOnce(Return(presentFence));
Lloyd Piquede196652020-01-22 17:29:58 -0800852 EXPECT_CALL(mHwComposer, getLayerReleaseFence(DEFAULT_DISPLAY_ID, &mLayer1.hwc2Layer))
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800853 .WillOnce(Return(layer1Fence));
Lloyd Piquede196652020-01-22 17:29:58 -0800854 EXPECT_CALL(mHwComposer, getLayerReleaseFence(DEFAULT_DISPLAY_ID, &mLayer2.hwc2Layer))
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800855 .WillOnce(Return(layer2Fence));
856 EXPECT_CALL(mHwComposer, clearReleaseFences(DEFAULT_DISPLAY_ID)).Times(1);
857
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700858 auto result = mDisplay->presentAndGetFrameFences();
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800859
860 EXPECT_EQ(presentFence, result.presentFence);
861
862 EXPECT_EQ(2u, result.layerFences.size());
Lloyd Piquede196652020-01-22 17:29:58 -0800863 ASSERT_EQ(1, result.layerFences.count(&mLayer1.hwc2Layer));
864 EXPECT_EQ(layer1Fence, result.layerFences[&mLayer1.hwc2Layer]);
865 ASSERT_EQ(1, result.layerFences.count(&mLayer2.hwc2Layer));
866 EXPECT_EQ(layer2Fence, result.layerFences[&mLayer2.hwc2Layer]);
Lloyd Pique35fca9d2019-02-13 14:24:11 -0800867}
868
Lloyd Pique688abd42019-02-15 15:42:24 -0800869/*
870 * Display::setExpensiveRenderingExpected()
871 */
872
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700873using DisplaySetExpensiveRenderingExpectedTest = DisplayWithLayersTestCommon;
874
875TEST_F(DisplaySetExpensiveRenderingExpectedTest, forwardsToPowerAdvisor) {
Lloyd Pique688abd42019-02-15 15:42:24 -0800876 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, true)).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700877 mDisplay->setExpensiveRenderingExpected(true);
Lloyd Pique688abd42019-02-15 15:42:24 -0800878
879 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false)).Times(1);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700880 mDisplay->setExpensiveRenderingExpected(false);
Lloyd Pique688abd42019-02-15 15:42:24 -0800881}
882
Lloyd Piqued3d69882019-02-28 16:03:46 -0800883/*
884 * Display::finishFrame()
885 */
886
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700887using DisplayFinishFrameTest = DisplayWithLayersTestCommon;
888
889TEST_F(DisplayFinishFrameTest, doesNotSkipCompositionIfNotDirtyOnHwcDisplay) {
Lloyd Piqued3d69882019-02-28 16:03:46 -0800890 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700891 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Piqued3d69882019-02-28 16:03:46 -0800892
893 // We expect no calls to queueBuffer if composition was skipped.
894 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
895
Lloyd Piquea76ce462020-01-14 13:06:37 -0800896 // Expect a call to signal no expensive rendering since there is no client composition.
897 EXPECT_CALL(mPowerAdvisor, setExpensiveRenderingExpected(DEFAULT_DISPLAY_ID, false));
898
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700899 mDisplay->editState().isEnabled = true;
900 mDisplay->editState().usesClientComposition = false;
901 mDisplay->editState().viewport = Rect(0, 0, 1, 1);
902 mDisplay->editState().dirtyRegion = Region::INVALID_REGION;
Lloyd Piqued3d69882019-02-28 16:03:46 -0800903
904 CompositionRefreshArgs refreshArgs;
905 refreshArgs.repaintEverything = false;
906
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700907 mDisplay->finishFrame(refreshArgs);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800908}
909
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700910TEST_F(DisplayFinishFrameTest, skipsCompositionIfNotDirty) {
911 auto args = getDisplayCreationArgsForNonHWCVirtualDisplay();
912 std::shared_ptr<impl::Display> nonHwcDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800913
914 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
915 nonHwcDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
916
917 // We expect no calls to queueBuffer if composition was skipped.
918 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(0);
919
920 nonHwcDisplay->editState().isEnabled = true;
921 nonHwcDisplay->editState().usesClientComposition = false;
922 nonHwcDisplay->editState().viewport = Rect(0, 0, 1, 1);
923 nonHwcDisplay->editState().dirtyRegion = Region::INVALID_REGION;
924
925 CompositionRefreshArgs refreshArgs;
926 refreshArgs.repaintEverything = false;
927
928 nonHwcDisplay->finishFrame(refreshArgs);
929}
930
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700931TEST_F(DisplayFinishFrameTest, performsCompositionIfDirty) {
932 auto args = getDisplayCreationArgsForNonHWCVirtualDisplay();
933 std::shared_ptr<impl::Display> nonHwcDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800934
935 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
936 nonHwcDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
937
938 // We expect a single call to queueBuffer when composition is not skipped.
939 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
940
941 nonHwcDisplay->editState().isEnabled = true;
942 nonHwcDisplay->editState().usesClientComposition = false;
943 nonHwcDisplay->editState().viewport = Rect(0, 0, 1, 1);
944 nonHwcDisplay->editState().dirtyRegion = Region(Rect(0, 0, 1, 1));
945
946 CompositionRefreshArgs refreshArgs;
947 refreshArgs.repaintEverything = false;
948
949 nonHwcDisplay->finishFrame(refreshArgs);
950}
951
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700952TEST_F(DisplayFinishFrameTest, performsCompositionIfRepaintEverything) {
953 auto args = getDisplayCreationArgsForNonHWCVirtualDisplay();
954 std::shared_ptr<impl::Display> nonHwcDisplay = impl::createDisplay(mCompositionEngine, args);
Lloyd Piqued3d69882019-02-28 16:03:46 -0800955
956 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
957 nonHwcDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(renderSurface));
958
959 // We expect a single call to queueBuffer when composition is not skipped.
960 EXPECT_CALL(*renderSurface, queueBuffer(_)).Times(1);
961
962 nonHwcDisplay->editState().isEnabled = true;
963 nonHwcDisplay->editState().usesClientComposition = false;
964 nonHwcDisplay->editState().viewport = Rect(0, 0, 1, 1);
965 nonHwcDisplay->editState().dirtyRegion = Region::INVALID_REGION;
966
967 CompositionRefreshArgs refreshArgs;
968 refreshArgs.repaintEverything = true;
969
970 nonHwcDisplay->finishFrame(refreshArgs);
971}
972
Lloyd Piquec6607552019-12-02 17:57:39 -0800973/*
974 * Display functional tests
975 */
976
977struct DisplayFunctionalTest : public testing::Test {
978 class Display : public impl::Display {
979 public:
Lloyd Piquec6607552019-12-02 17:57:39 -0800980 using impl::Display::injectOutputLayerForTest;
981 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
982 };
983
Lloyd Piquec6607552019-12-02 17:57:39 -0800984 DisplayFunctionalTest() {
985 EXPECT_CALL(mCompositionEngine, getHwComposer()).WillRepeatedly(ReturnRef(mHwComposer));
986
987 mDisplay->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
988 }
989
990 NiceMock<android::mock::HWComposer> mHwComposer;
991 NiceMock<Hwc2::mock::PowerAdvisor> mPowerAdvisor;
992 NiceMock<mock::CompositionEngine> mCompositionEngine;
993 sp<mock::NativeWindow> mNativeWindow = new NiceMock<mock::NativeWindow>();
994 sp<mock::DisplaySurface> mDisplaySurface = new NiceMock<mock::DisplaySurface>();
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -0700995 std::shared_ptr<Display> mDisplay = impl::createDisplayTemplated<
996 Display>(mCompositionEngine,
997 DisplayCreationArgsBuilder()
998 .setPhysical({DEFAULT_DISPLAY_ID, DisplayConnectionType::Internal})
999 .setPixels({DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT})
1000 .setPixelFormat(static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888))
1001 .setIsSecure(true)
1002 .setLayerStackId(DEFAULT_LAYER_STACK)
1003 .setPowerAdvisor(&mPowerAdvisor)
1004 .build()
1005
1006 );
Lloyd Piquec6607552019-12-02 17:57:39 -08001007 impl::RenderSurface* mRenderSurface =
1008 new impl::RenderSurface{mCompositionEngine, *mDisplay,
1009 RenderSurfaceCreationArgs{DEFAULT_DISPLAY_WIDTH,
1010 DEFAULT_DISPLAY_HEIGHT, mNativeWindow,
1011 mDisplaySurface}};
1012};
1013
1014TEST_F(DisplayFunctionalTest, postFramebufferCriticalCallsAreOrdered) {
1015 InSequence seq;
1016
1017 mDisplay->editState().isEnabled = true;
1018
1019 EXPECT_CALL(mHwComposer, presentAndGetReleaseFences(_));
1020 EXPECT_CALL(*mDisplaySurface, onFrameCommitted());
1021
1022 mDisplay->postFramebuffer();
1023}
1024
Lloyd Pique45a165a2018-10-19 11:54:47 -07001025} // namespace
1026} // namespace android::compositionengine