1 /*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <cstdarg>
18 #include <cstdint>
19
20 #include <compositionengine/RenderSurfaceCreationArgs.h>
21 #include <compositionengine/impl/RenderSurface.h>
22 #include <compositionengine/mock/CompositionEngine.h>
23 #include <compositionengine/mock/Display.h>
24 #include <compositionengine/mock/DisplaySurface.h>
25 #include <compositionengine/mock/NativeWindow.h>
26 #include <compositionengine/mock/OutputLayer.h>
27 #include <gtest/gtest.h>
28 #include <renderengine/mock/RenderEngine.h>
29
30 #include "MockHWComposer.h"
31
32 namespace android::compositionengine {
33 namespace {
34
35 /* ------------------------------------------------------------------------
36 * RenderSurfaceTest
37 */
38
39 constexpr int32_t DEFAULT_DISPLAY_WIDTH = 1920;
40 constexpr int32_t DEFAULT_DISPLAY_HEIGHT = 1080;
41 constexpr std::optional<DisplayId> DEFAULT_DISPLAY_ID = std::make_optional(DisplayId{123u});
42 const std::string DEFAULT_DISPLAY_NAME = "Mock Display";
43
44 using testing::_;
45 using testing::ByMove;
46 using testing::DoAll;
47 using testing::Ref;
48 using testing::Return;
49 using testing::ReturnRef;
50 using testing::SetArgPointee;
51 using testing::StrictMock;
52
53 class RenderSurfaceTest : public testing::Test {
54 public:
RenderSurfaceTest()55 RenderSurfaceTest() {
56 EXPECT_CALL(mDisplay, getId()).WillRepeatedly(ReturnRef(DEFAULT_DISPLAY_ID));
57 EXPECT_CALL(mDisplay, getName()).WillRepeatedly(ReturnRef(DEFAULT_DISPLAY_NAME));
58 EXPECT_CALL(mCompositionEngine, getHwComposer).WillRepeatedly(ReturnRef(mHwComposer));
59 EXPECT_CALL(mCompositionEngine, getRenderEngine).WillRepeatedly(ReturnRef(mRenderEngine));
60 EXPECT_CALL(*mNativeWindow, disconnect(NATIVE_WINDOW_API_EGL))
61 .WillRepeatedly(Return(NO_ERROR));
62 }
63 ~RenderSurfaceTest() override = default;
64
65 StrictMock<android::mock::HWComposer> mHwComposer;
66 StrictMock<renderengine::mock::RenderEngine> mRenderEngine;
67 StrictMock<mock::CompositionEngine> mCompositionEngine;
68 StrictMock<mock::Display> mDisplay;
69 sp<mock::NativeWindow> mNativeWindow = new StrictMock<mock::NativeWindow>();
70 sp<mock::DisplaySurface> mDisplaySurface = new StrictMock<mock::DisplaySurface>();
71 impl::RenderSurface mSurface{mCompositionEngine, mDisplay,
72 RenderSurfaceCreationArgs{DEFAULT_DISPLAY_WIDTH,
73 DEFAULT_DISPLAY_HEIGHT, mNativeWindow,
74 mDisplaySurface}};
75 };
76
77 /* ------------------------------------------------------------------------
78 * Basic construction
79 */
80
TEST_F(RenderSurfaceTest,canInstantiate)81 TEST_F(RenderSurfaceTest, canInstantiate) {
82 EXPECT_TRUE(mSurface.isValid());
83 }
84
85 /* ------------------------------------------------------------------------
86 * RenderSurface::initialize()
87 */
88
TEST_F(RenderSurfaceTest,initializeConfiguresNativeWindow)89 TEST_F(RenderSurfaceTest, initializeConfiguresNativeWindow) {
90 EXPECT_CALL(*mNativeWindow, connect(NATIVE_WINDOW_API_EGL)).WillOnce(Return(NO_ERROR));
91 EXPECT_CALL(*mNativeWindow, setBuffersFormat(HAL_PIXEL_FORMAT_RGBA_8888))
92 .WillOnce(Return(NO_ERROR));
93 EXPECT_CALL(*mNativeWindow, setUsage(GRALLOC_USAGE_HW_RENDER)).WillOnce(Return(NO_ERROR));
94
95 mSurface.initialize();
96 }
97
98 /* ------------------------------------------------------------------------
99 * RenderSurface::getSize()
100 */
101
TEST_F(RenderSurfaceTest,sizeReturnsConstructedSize)102 TEST_F(RenderSurfaceTest, sizeReturnsConstructedSize) {
103 const ui::Size expected{DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT};
104
105 EXPECT_EQ(expected, mSurface.getSize());
106 }
107
108 /* ------------------------------------------------------------------------
109 * RenderSurface::getClientTargetAcquireFence()
110 */
111
TEST_F(RenderSurfaceTest,getClientTargetAcquireFenceForwardsCall)112 TEST_F(RenderSurfaceTest, getClientTargetAcquireFenceForwardsCall) {
113 sp<Fence> fence = new Fence();
114
115 EXPECT_CALL(*mDisplaySurface, getClientTargetAcquireFence()).WillOnce(ReturnRef(fence));
116
117 EXPECT_EQ(fence.get(), mSurface.getClientTargetAcquireFence().get());
118 }
119
120 /* ------------------------------------------------------------------------
121 * RenderSurface::setDisplaySize()
122 */
123
TEST_F(RenderSurfaceTest,setDisplaySizeAppliesChange)124 TEST_F(RenderSurfaceTest, setDisplaySizeAppliesChange) {
125 EXPECT_CALL(*mDisplaySurface, resizeBuffers(640, 480)).Times(1);
126
127 mSurface.setDisplaySize(ui::Size(640, 480));
128 }
129
130 /* ------------------------------------------------------------------------
131 * RenderSurface::setBufferDataspace()
132 */
133
TEST_F(RenderSurfaceTest,setBufferDataspaceAppliesChange)134 TEST_F(RenderSurfaceTest, setBufferDataspaceAppliesChange) {
135 EXPECT_CALL(*mNativeWindow, setBuffersDataSpace(ui::Dataspace::DISPLAY_P3))
136 .WillOnce(Return(NO_ERROR));
137
138 mSurface.setBufferDataspace(ui::Dataspace::DISPLAY_P3);
139 }
140
141 /* ------------------------------------------------------------------------
142 * RenderSurface::setProtected()
143 */
144
TEST_F(RenderSurfaceTest,setProtectedTrueEnablesProtection)145 TEST_F(RenderSurfaceTest, setProtectedTrueEnablesProtection) {
146 EXPECT_FALSE(mSurface.isProtected());
147 EXPECT_CALL(*mNativeWindow, setUsage(GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_PROTECTED))
148 .WillOnce(Return(NO_ERROR));
149
150 mSurface.setProtected(true);
151 EXPECT_TRUE(mSurface.isProtected());
152 }
153
TEST_F(RenderSurfaceTest,setProtectedFalseDisablesProtection)154 TEST_F(RenderSurfaceTest, setProtectedFalseDisablesProtection) {
155 EXPECT_FALSE(mSurface.isProtected());
156 EXPECT_CALL(*mNativeWindow, setUsage(GRALLOC_USAGE_HW_RENDER)).WillOnce(Return(NO_ERROR));
157
158 mSurface.setProtected(false);
159 EXPECT_FALSE(mSurface.isProtected());
160 }
161
TEST_F(RenderSurfaceTest,setProtectedEnableAndDisable)162 TEST_F(RenderSurfaceTest, setProtectedEnableAndDisable) {
163 EXPECT_FALSE(mSurface.isProtected());
164 EXPECT_CALL(*mNativeWindow, setUsage(GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_PROTECTED))
165 .WillOnce(Return(NO_ERROR));
166 EXPECT_CALL(*mNativeWindow, setUsage(GRALLOC_USAGE_HW_RENDER)).WillOnce(Return(NO_ERROR));
167
168 mSurface.setProtected(true);
169 EXPECT_TRUE(mSurface.isProtected());
170 mSurface.setProtected(false);
171 EXPECT_FALSE(mSurface.isProtected());
172 }
173
TEST_F(RenderSurfaceTest,setProtectedEnableWithError)174 TEST_F(RenderSurfaceTest, setProtectedEnableWithError) {
175 EXPECT_FALSE(mSurface.isProtected());
176 EXPECT_CALL(*mNativeWindow, setUsage(GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_PROTECTED))
177 .WillOnce(Return(INVALID_OPERATION));
178 mSurface.setProtected(true);
179 EXPECT_FALSE(mSurface.isProtected());
180 }
181
182 /* ------------------------------------------------------------------------
183 * RenderSurface::beginFrame()
184 */
185
TEST_F(RenderSurfaceTest,beginFrameAppliesChange)186 TEST_F(RenderSurfaceTest, beginFrameAppliesChange) {
187 EXPECT_CALL(*mDisplaySurface, beginFrame(true)).WillOnce(Return(NO_ERROR));
188
189 EXPECT_EQ(NO_ERROR, mSurface.beginFrame(true));
190 }
191
192 /* ------------------------------------------------------------------------
193 * RenderSurface::prepareFrame()
194 */
195
TEST_F(RenderSurfaceTest,prepareFramePassesOutputLayersToHwc)196 TEST_F(RenderSurfaceTest, prepareFramePassesOutputLayersToHwc) {
197 EXPECT_CALL(mHwComposer, prepare(*DEFAULT_DISPLAY_ID, Ref(mDisplay)))
198 .WillOnce(Return(INVALID_OPERATION));
199
200 EXPECT_EQ(INVALID_OPERATION, mSurface.prepareFrame());
201 }
202
TEST_F(RenderSurfaceTest,prepareFrameTakesEarlyOutOnHwcError)203 TEST_F(RenderSurfaceTest, prepareFrameTakesEarlyOutOnHwcError) {
204 EXPECT_CALL(mHwComposer, prepare(*DEFAULT_DISPLAY_ID, Ref(mDisplay)))
205 .WillOnce(Return(INVALID_OPERATION));
206
207 EXPECT_EQ(INVALID_OPERATION, mSurface.prepareFrame());
208 }
209
TEST_F(RenderSurfaceTest,prepareFrameHandlesMixedComposition)210 TEST_F(RenderSurfaceTest, prepareFrameHandlesMixedComposition) {
211 EXPECT_CALL(mHwComposer, prepare(*DEFAULT_DISPLAY_ID, Ref(mDisplay)))
212 .WillOnce(Return(NO_ERROR));
213 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(true));
214 EXPECT_CALL(mHwComposer, hasDeviceComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(true));
215
216 EXPECT_CALL(*mDisplaySurface, prepareFrame(DisplaySurface::COMPOSITION_MIXED))
217 .WillOnce(Return(INVALID_OPERATION));
218
219 EXPECT_EQ(INVALID_OPERATION, mSurface.prepareFrame());
220 }
221
TEST_F(RenderSurfaceTest,prepareFrameHandlesOnlyGlesComposition)222 TEST_F(RenderSurfaceTest, prepareFrameHandlesOnlyGlesComposition) {
223 EXPECT_CALL(mHwComposer, prepare(*DEFAULT_DISPLAY_ID, Ref(mDisplay)))
224 .WillOnce(Return(NO_ERROR));
225 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(true));
226 EXPECT_CALL(mHwComposer, hasDeviceComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(false));
227
228 EXPECT_CALL(*mDisplaySurface, prepareFrame(DisplaySurface::COMPOSITION_GLES))
229 .WillOnce(Return(NO_ERROR));
230
231 EXPECT_EQ(NO_ERROR, mSurface.prepareFrame());
232 }
233
TEST_F(RenderSurfaceTest,prepareFrameHandlesOnlyHwcComposition)234 TEST_F(RenderSurfaceTest, prepareFrameHandlesOnlyHwcComposition) {
235 EXPECT_CALL(mHwComposer, prepare(*DEFAULT_DISPLAY_ID, Ref(mDisplay)))
236 .WillOnce(Return(NO_ERROR));
237 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(false));
238 EXPECT_CALL(mHwComposer, hasDeviceComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(true));
239
240 EXPECT_CALL(*mDisplaySurface, prepareFrame(DisplaySurface::COMPOSITION_HWC))
241 .WillOnce(Return(NO_ERROR));
242
243 EXPECT_EQ(NO_ERROR, mSurface.prepareFrame());
244 }
245
TEST_F(RenderSurfaceTest,prepareFrameHandlesNoComposition)246 TEST_F(RenderSurfaceTest, prepareFrameHandlesNoComposition) {
247 EXPECT_CALL(mHwComposer, prepare(*DEFAULT_DISPLAY_ID, Ref(mDisplay)))
248 .WillOnce(Return(NO_ERROR));
249 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(false));
250 EXPECT_CALL(mHwComposer, hasDeviceComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(false));
251
252 EXPECT_CALL(*mDisplaySurface, prepareFrame(DisplaySurface::COMPOSITION_HWC))
253 .WillOnce(Return(NO_ERROR));
254
255 EXPECT_EQ(NO_ERROR, mSurface.prepareFrame());
256 }
257
258 /* ------------------------------------------------------------------------
259 * RenderSurface::dequeueBuffer()
260 */
261
TEST_F(RenderSurfaceTest,dequeueBufferObtainsABuffer)262 TEST_F(RenderSurfaceTest, dequeueBufferObtainsABuffer) {
263 sp<GraphicBuffer> buffer = new GraphicBuffer();
264
265 EXPECT_CALL(*mNativeWindow, dequeueBuffer(_, _))
266 .WillOnce(
267 DoAll(SetArgPointee<0>(buffer.get()), SetArgPointee<1>(-1), Return(NO_ERROR)));
268
269 base::unique_fd fence;
270 EXPECT_EQ(buffer.get(), mSurface.dequeueBuffer(&fence).get());
271
272 EXPECT_EQ(buffer.get(), mSurface.mutableGraphicBufferForTest().get());
273 }
274
275 /* ------------------------------------------------------------------------
276 * RenderSurface::queueBuffer()
277 */
278
TEST_F(RenderSurfaceTest,queueBufferHandlesNoClientComposition)279 TEST_F(RenderSurfaceTest, queueBufferHandlesNoClientComposition) {
280 sp<GraphicBuffer> buffer = new GraphicBuffer();
281 mSurface.mutableGraphicBufferForTest() = buffer;
282
283 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(false));
284 EXPECT_CALL(mHwComposer, hasFlipClientTargetRequest(DEFAULT_DISPLAY_ID))
285 .WillOnce(Return(false));
286 EXPECT_CALL(*mDisplaySurface, advanceFrame()).Times(1);
287
288 mSurface.queueBuffer(base::unique_fd());
289
290 EXPECT_EQ(buffer.get(), mSurface.mutableGraphicBufferForTest().get());
291 }
292
TEST_F(RenderSurfaceTest,queueBufferHandlesClientComposition)293 TEST_F(RenderSurfaceTest, queueBufferHandlesClientComposition) {
294 sp<GraphicBuffer> buffer = new GraphicBuffer();
295 mSurface.mutableGraphicBufferForTest() = buffer;
296
297 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(true));
298 EXPECT_CALL(*mNativeWindow, queueBuffer(buffer->getNativeBuffer(), -1))
299 .WillOnce(Return(NO_ERROR));
300 EXPECT_CALL(*mDisplaySurface, advanceFrame()).Times(1);
301
302 mSurface.queueBuffer(base::unique_fd());
303
304 EXPECT_EQ(nullptr, mSurface.mutableGraphicBufferForTest().get());
305 }
306
TEST_F(RenderSurfaceTest,queueBufferHandlesFlipClientTargetRequest)307 TEST_F(RenderSurfaceTest, queueBufferHandlesFlipClientTargetRequest) {
308 sp<GraphicBuffer> buffer = new GraphicBuffer();
309 mSurface.mutableGraphicBufferForTest() = buffer;
310
311 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(false));
312 EXPECT_CALL(mHwComposer, hasFlipClientTargetRequest(DEFAULT_DISPLAY_ID)).WillOnce(Return(true));
313 EXPECT_CALL(*mNativeWindow, queueBuffer(buffer->getNativeBuffer(), -1))
314 .WillOnce(Return(NO_ERROR));
315 EXPECT_CALL(*mDisplaySurface, advanceFrame()).Times(1);
316
317 mSurface.queueBuffer(base::unique_fd());
318
319 EXPECT_EQ(nullptr, mSurface.mutableGraphicBufferForTest().get());
320 }
321
TEST_F(RenderSurfaceTest,queueBufferHandlesFlipClientTargetRequestWithNoBufferYetDequeued)322 TEST_F(RenderSurfaceTest, queueBufferHandlesFlipClientTargetRequestWithNoBufferYetDequeued) {
323 sp<GraphicBuffer> buffer = new GraphicBuffer();
324
325 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(false));
326 EXPECT_CALL(mHwComposer, hasFlipClientTargetRequest(DEFAULT_DISPLAY_ID)).WillOnce(Return(true));
327 EXPECT_CALL(*mNativeWindow, dequeueBuffer(_, _))
328 .WillOnce(
329 DoAll(SetArgPointee<0>(buffer.get()), SetArgPointee<1>(-1), Return(NO_ERROR)));
330 EXPECT_CALL(*mNativeWindow, queueBuffer(buffer->getNativeBuffer(), -1))
331 .WillOnce(Return(NO_ERROR));
332 EXPECT_CALL(*mDisplaySurface, advanceFrame()).Times(1);
333
334 mSurface.queueBuffer(base::unique_fd());
335
336 EXPECT_EQ(nullptr, mSurface.mutableGraphicBufferForTest().get());
337 }
338
TEST_F(RenderSurfaceTest,queueBufferHandlesNativeWindowQueueBufferFailureOnVirtualDisplay)339 TEST_F(RenderSurfaceTest, queueBufferHandlesNativeWindowQueueBufferFailureOnVirtualDisplay) {
340 sp<GraphicBuffer> buffer = new GraphicBuffer();
341 mSurface.mutableGraphicBufferForTest() = buffer;
342
343 EXPECT_CALL(mHwComposer, hasClientComposition(DEFAULT_DISPLAY_ID)).WillOnce(Return(true));
344 EXPECT_CALL(*mNativeWindow, queueBuffer(buffer->getNativeBuffer(), -1))
345 .WillOnce(Return(INVALID_OPERATION));
346 EXPECT_CALL(mDisplay, isVirtual()).WillOnce(Return(true));
347 EXPECT_CALL(*mNativeWindow, cancelBuffer(buffer->getNativeBuffer(), -1))
348 .WillOnce(Return(NO_ERROR));
349 EXPECT_CALL(*mDisplaySurface, advanceFrame()).Times(1);
350
351 mSurface.queueBuffer(base::unique_fd());
352
353 EXPECT_EQ(nullptr, mSurface.mutableGraphicBufferForTest().get());
354 }
355
356 /* ------------------------------------------------------------------------
357 * RenderSurface::onPresentDisplayCompleted()
358 */
359
TEST_F(RenderSurfaceTest,onPresentDisplayCompletedForwardsSignal)360 TEST_F(RenderSurfaceTest, onPresentDisplayCompletedForwardsSignal) {
361 EXPECT_CALL(*mDisplaySurface, onFrameCommitted()).Times(1);
362
363 mSurface.onPresentDisplayCompleted();
364 }
365
366 /* ------------------------------------------------------------------------
367 * RenderSurface::setViewportAndProjection()
368 */
369
TEST_F(RenderSurfaceTest,setViewportAndProjectionAppliesChang)370 TEST_F(RenderSurfaceTest, setViewportAndProjectionAppliesChang) {
371 mSurface.setSizeForTest(ui::Size(100, 200));
372
373 EXPECT_CALL(mRenderEngine,
374 setViewportAndProjection(100, 200, Rect(100, 200), ui::Transform::ROT_0))
375 .Times(1);
376
377 mSurface.setViewportAndProjection();
378 }
379
380 /* ------------------------------------------------------------------------
381 * RenderSurface::flip()
382 */
383
TEST_F(RenderSurfaceTest,flipForwardsSignal)384 TEST_F(RenderSurfaceTest, flipForwardsSignal) {
385 mSurface.setPageFlipCountForTest(500);
386
387 mSurface.flip();
388
389 EXPECT_EQ(501, mSurface.getPageFlipCount());
390 }
391
392 } // namespace
393 } // namespace android::compositionengine
394