1 /*
2 * Copyright 2021 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 #undef LOG_TAG
18 #define LOG_TAG "LibSurfaceFlingerUnittests"
19
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22 #include <gui/SurfaceComposerClient.h>
23 #include <log/log.h>
24 #include <renderengine/ExternalTexture.h>
25 #include <renderengine/mock/FakeExternalTexture.h>
26 #include <renderengine/mock/RenderEngine.h>
27 #include <utils/String8.h>
28
29 #include "TestableSurfaceFlinger.h"
30 #include "mock/DisplayHardware/MockComposer.h"
31
32 namespace android {
33
34 using testing::_;
35 using testing::Mock;
36 using testing::Return;
37
38 using PresentState = frametimeline::SurfaceFrame::PresentState;
39
40 class TransactionSurfaceFrameTest : public testing::Test {
41 public:
TransactionSurfaceFrameTest()42 TransactionSurfaceFrameTest() {
43 const ::testing::TestInfo* const test_info =
44 ::testing::UnitTest::GetInstance()->current_test_info();
45 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
46 mFlinger.setupMockScheduler();
47 mFlinger.setupComposer(std::make_unique<Hwc2::mock::Composer>());
48 mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
49 }
50
~TransactionSurfaceFrameTest()51 ~TransactionSurfaceFrameTest() {
52 const ::testing::TestInfo* const test_info =
53 ::testing::UnitTest::GetInstance()->current_test_info();
54 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
55 }
56
createLayer()57 sp<Layer> createLayer() {
58 sp<Client> client;
59 LayerCreationArgs args(mFlinger.flinger(), client, "layer", 0, LayerMetadata());
60 return sp<Layer>::make(args);
61 }
62
commitTransaction(Layer * layer)63 void commitTransaction(Layer* layer) { layer->commitTransaction(); }
64
65 TestableSurfaceFlinger mFlinger;
66 renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine();
67
68 FenceToFenceTimeMap fenceFactory;
69
PresentedSurfaceFrameForBufferlessTransaction()70 void PresentedSurfaceFrameForBufferlessTransaction() {
71 sp<Layer> layer = createLayer();
72 FrameTimelineInfo ftInfo;
73 ftInfo.vsyncId = 1;
74 ftInfo.inputEventId = 0;
75 layer->setFrameTimelineVsyncForBufferlessTransaction(ftInfo, 10,
76 gui::GameMode::Unsupported);
77 EXPECT_EQ(1u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
78 ASSERT_TRUE(layer->mDrawingState.bufferSurfaceFrameTX == nullptr);
79 const auto surfaceFrame = layer->mDrawingState.bufferlessSurfaceFramesTX.at(/*token*/ 1);
80 commitTransaction(layer.get());
81 EXPECT_EQ(1, surfaceFrame->getToken());
82 EXPECT_EQ(false, surfaceFrame->getIsBuffer());
83 EXPECT_EQ(PresentState::Presented, surfaceFrame->getPresentState());
84 }
85
PresentedSurfaceFrameForBufferTransaction()86 void PresentedSurfaceFrameForBufferTransaction() {
87 sp<Layer> layer = createLayer();
88 sp<Fence> fence(sp<Fence>::make());
89 auto acquireFence = fenceFactory.createFenceTimeForTest(fence);
90 BufferData bufferData;
91 bufferData.acquireFence = fence;
92 bufferData.frameNumber = 1;
93 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
94 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
95 std::shared_ptr<renderengine::ExternalTexture> externalTexture = std::make_shared<
96 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
97 1ULL /* bufferId */,
98 HAL_PIXEL_FORMAT_RGBA_8888,
99 0ULL /*usage*/);
100 FrameTimelineInfo ftInfo;
101 ftInfo.vsyncId = 1;
102 ftInfo.inputEventId = 0;
103 layer->setBuffer(externalTexture, bufferData, 10, 20, false, ftInfo,
104 gui::GameMode::Unsupported);
105 acquireFence->signalForTest(12);
106
107 commitTransaction(layer.get());
108 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
109 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
110 const auto surfaceFrame = layer->mDrawingState.bufferSurfaceFrameTX;
111 // Buffers are presented only at latch time.
112 EXPECT_EQ(PresentState::Unknown, surfaceFrame->getPresentState());
113
114 layer->updateTexImage(15);
115
116 EXPECT_EQ(1, surfaceFrame->getToken());
117 EXPECT_EQ(true, surfaceFrame->getIsBuffer());
118 EXPECT_EQ(PresentState::Presented, surfaceFrame->getPresentState());
119 }
120
DroppedSurfaceFrameForBufferTransaction()121 void DroppedSurfaceFrameForBufferTransaction() {
122 sp<Layer> layer = createLayer();
123
124 sp<Fence> fence1(sp<Fence>::make());
125 auto acquireFence1 = fenceFactory.createFenceTimeForTest(fence1);
126 BufferData bufferData;
127 bufferData.acquireFence = fence1;
128 bufferData.frameNumber = 1;
129 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
130 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
131 std::shared_ptr<renderengine::ExternalTexture> externalTexture1 = std::make_shared<
132 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
133 1ULL /* bufferId */,
134 HAL_PIXEL_FORMAT_RGBA_8888,
135 0ULL /*usage*/);
136 FrameTimelineInfo ftInfo;
137 ftInfo.vsyncId = 1;
138 ftInfo.inputEventId = 0;
139 layer->setBuffer(externalTexture1, bufferData, 10, 20, false, ftInfo,
140 gui::GameMode::Unsupported);
141 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
142 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
143 const auto droppedSurfaceFrame = layer->mDrawingState.bufferSurfaceFrameTX;
144
145 sp<Fence> fence2(sp<Fence>::make());
146 auto acquireFence2 = fenceFactory.createFenceTimeForTest(fence2);
147 nsecs_t start = systemTime();
148 bufferData.acquireFence = fence2;
149 bufferData.frameNumber = 1;
150 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
151 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
152 std::shared_ptr<renderengine::ExternalTexture> externalTexture2 = std::make_shared<
153 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
154 2ULL /* bufferId */,
155 HAL_PIXEL_FORMAT_RGBA_8888,
156 0ULL /*usage*/);
157 layer->setBuffer(externalTexture2, bufferData, 10, 20, false, ftInfo,
158 gui::GameMode::Unsupported);
159 nsecs_t end = systemTime();
160 acquireFence2->signalForTest(12);
161
162 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
163 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
164 const auto presentedSurfaceFrame = layer->mDrawingState.bufferSurfaceFrameTX;
165
166 commitTransaction(layer.get());
167 layer->updateTexImage(15);
168
169 EXPECT_EQ(1, droppedSurfaceFrame->getToken());
170 EXPECT_EQ(true, droppedSurfaceFrame->getIsBuffer());
171 EXPECT_EQ(PresentState::Dropped, droppedSurfaceFrame->getPresentState());
172 EXPECT_EQ(0u, droppedSurfaceFrame->getActuals().endTime);
173 auto dropTime = droppedSurfaceFrame->getDropTime();
174 EXPECT_TRUE(dropTime > start && dropTime < end);
175
176 EXPECT_EQ(1, presentedSurfaceFrame->getToken());
177 EXPECT_EQ(true, presentedSurfaceFrame->getIsBuffer());
178 EXPECT_EQ(PresentState::Presented, presentedSurfaceFrame->getPresentState());
179 }
180
BufferlessSurfaceFramePromotedToBufferSurfaceFrame()181 void BufferlessSurfaceFramePromotedToBufferSurfaceFrame() {
182 sp<Layer> layer = createLayer();
183 FrameTimelineInfo ftInfo;
184 ftInfo.vsyncId = 1;
185 ftInfo.inputEventId = 0;
186
187 layer->setFrameTimelineVsyncForBufferlessTransaction(ftInfo, 10,
188 gui::GameMode::Unsupported);
189
190 EXPECT_EQ(1u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
191 ASSERT_EQ(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
192
193 sp<Fence> fence(sp<Fence>::make());
194 auto acquireFence = fenceFactory.createFenceTimeForTest(fence);
195 BufferData bufferData;
196 bufferData.acquireFence = fence;
197 bufferData.frameNumber = 1;
198 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
199 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
200 std::shared_ptr<renderengine::ExternalTexture> externalTexture = std::make_shared<
201 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
202 1ULL /* bufferId */,
203 HAL_PIXEL_FORMAT_RGBA_8888,
204 0ULL /*usage*/);
205 layer->setBuffer(externalTexture, bufferData, 10, 20, false, ftInfo,
206 gui::GameMode::Unsupported);
207 acquireFence->signalForTest(12);
208
209 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
210 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
211 const auto surfaceFrame = layer->mDrawingState.bufferSurfaceFrameTX;
212
213 commitTransaction(layer.get());
214 EXPECT_EQ(1, surfaceFrame->getToken());
215 EXPECT_EQ(true, surfaceFrame->getIsBuffer());
216 // Buffers are presented only at latch time.
217 EXPECT_EQ(PresentState::Unknown, surfaceFrame->getPresentState());
218
219 layer->updateTexImage(15);
220
221 EXPECT_EQ(PresentState::Presented, surfaceFrame->getPresentState());
222 }
223
BufferlessSurfaceFrameNotCreatedIfBufferSufaceFrameExists()224 void BufferlessSurfaceFrameNotCreatedIfBufferSufaceFrameExists() {
225 sp<Layer> layer = createLayer();
226 sp<Fence> fence(sp<Fence>::make());
227 auto acquireFence = fenceFactory.createFenceTimeForTest(fence);
228 BufferData bufferData;
229 bufferData.acquireFence = fence;
230 bufferData.frameNumber = 1;
231 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
232 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
233 std::shared_ptr<renderengine::ExternalTexture> externalTexture = std::make_shared<
234 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
235 1ULL /* bufferId */,
236 HAL_PIXEL_FORMAT_RGBA_8888,
237 0ULL /*usage*/);
238 FrameTimelineInfo ftInfo;
239 ftInfo.vsyncId = 1;
240 ftInfo.inputEventId = 0;
241 layer->setBuffer(externalTexture, bufferData, 10, 20, false, ftInfo,
242 gui::GameMode::Unsupported);
243 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
244 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
245
246 layer->setFrameTimelineVsyncForBufferlessTransaction(ftInfo, 10,
247 gui::GameMode::Unsupported);
248 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
249 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
250 }
251
MultipleSurfaceFramesPresentedTogether()252 void MultipleSurfaceFramesPresentedTogether() {
253 sp<Layer> layer = createLayer();
254 FrameTimelineInfo ftInfo;
255 ftInfo.vsyncId = 1;
256 ftInfo.inputEventId = 0;
257 layer->setFrameTimelineVsyncForBufferlessTransaction(ftInfo, 10,
258 gui::GameMode::Unsupported);
259 EXPECT_EQ(1u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
260 ASSERT_EQ(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
261 const auto bufferlessSurfaceFrame1 =
262 layer->mDrawingState.bufferlessSurfaceFramesTX.at(/*token*/ 1);
263
264 FrameTimelineInfo ftInfo2;
265 ftInfo2.vsyncId = 4;
266 ftInfo2.inputEventId = 0;
267 layer->setFrameTimelineVsyncForBufferlessTransaction(ftInfo2, 10,
268 gui::GameMode::Unsupported);
269 EXPECT_EQ(2u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
270 ASSERT_EQ(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
271 const auto bufferlessSurfaceFrame2 = layer->mDrawingState.bufferlessSurfaceFramesTX[4];
272
273 sp<Fence> fence(sp<Fence>::make());
274 auto acquireFence = fenceFactory.createFenceTimeForTest(fence);
275 BufferData bufferData;
276 bufferData.acquireFence = fence;
277 bufferData.frameNumber = 1;
278 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
279 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
280 std::shared_ptr<renderengine::ExternalTexture> externalTexture = std::make_shared<
281 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
282 1ULL /* bufferId */,
283 HAL_PIXEL_FORMAT_RGBA_8888,
284 0ULL /*usage*/);
285 FrameTimelineInfo ftInfo3;
286 ftInfo3.vsyncId = 3;
287 ftInfo3.inputEventId = 0;
288 layer->setBuffer(externalTexture, bufferData, 10, 20, false, ftInfo3,
289 gui::GameMode::Unsupported);
290 EXPECT_EQ(2u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
291 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
292 const auto bufferSurfaceFrameTX = layer->mDrawingState.bufferSurfaceFrameTX;
293
294 acquireFence->signalForTest(12);
295
296 commitTransaction(layer.get());
297
298 EXPECT_EQ(1, bufferlessSurfaceFrame1->getToken());
299 EXPECT_EQ(false, bufferlessSurfaceFrame1->getIsBuffer());
300 EXPECT_EQ(PresentState::Presented, bufferlessSurfaceFrame1->getPresentState());
301
302 EXPECT_EQ(4, bufferlessSurfaceFrame2->getToken());
303 EXPECT_EQ(false, bufferlessSurfaceFrame2->getIsBuffer());
304 EXPECT_EQ(PresentState::Presented, bufferlessSurfaceFrame2->getPresentState());
305
306 EXPECT_EQ(3, bufferSurfaceFrameTX->getToken());
307 EXPECT_EQ(true, bufferSurfaceFrameTX->getIsBuffer());
308 // Buffers are presented only at latch time.
309 EXPECT_EQ(PresentState::Unknown, bufferSurfaceFrameTX->getPresentState());
310
311 layer->updateTexImage(15);
312
313 EXPECT_EQ(PresentState::Presented, bufferSurfaceFrameTX->getPresentState());
314 }
315
BufferSurfaceFrame_ReplaceValidTokenBufferWithInvalidTokenBuffer()316 void BufferSurfaceFrame_ReplaceValidTokenBufferWithInvalidTokenBuffer() {
317 sp<Layer> layer = createLayer();
318
319 sp<Fence> fence1(sp<Fence>::make());
320 auto acquireFence1 = fenceFactory.createFenceTimeForTest(fence1);
321 BufferData bufferData;
322 bufferData.acquireFence = fence1;
323 bufferData.frameNumber = 1;
324 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
325 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
326 std::shared_ptr<renderengine::ExternalTexture> externalTexture1 = std::make_shared<
327 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
328 1ULL /* bufferId */,
329 HAL_PIXEL_FORMAT_RGBA_8888,
330 0ULL /*usage*/);
331 FrameTimelineInfo ftInfo;
332 ftInfo.vsyncId = 1;
333 ftInfo.inputEventId = 0;
334 layer->setBuffer(externalTexture1, bufferData, 10, 20, false, ftInfo,
335 gui::GameMode::Unsupported);
336 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
337 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
338 const auto droppedSurfaceFrame1 = layer->mDrawingState.bufferSurfaceFrameTX;
339
340 sp<Fence> fence2(sp<Fence>::make());
341 auto acquireFence2 = fenceFactory.createFenceTimeForTest(fence2);
342 auto dropStartTime1 = systemTime();
343 bufferData.acquireFence = fence2;
344 bufferData.frameNumber = 1;
345 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
346 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
347 std::shared_ptr<renderengine::ExternalTexture> externalTexture2 = std::make_shared<
348 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
349 1ULL /* bufferId */,
350 HAL_PIXEL_FORMAT_RGBA_8888,
351 0ULL /*usage*/);
352 FrameTimelineInfo ftInfoInv;
353 ftInfoInv.vsyncId = FrameTimelineInfo::INVALID_VSYNC_ID;
354 ftInfoInv.inputEventId = 0;
355 layer->setBuffer(externalTexture2, bufferData, 10, 20, false, ftInfoInv,
356 gui::GameMode::Unsupported);
357 auto dropEndTime1 = systemTime();
358 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
359 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
360 const auto droppedSurfaceFrame2 = layer->mDrawingState.bufferSurfaceFrameTX;
361
362 sp<Fence> fence3(sp<Fence>::make());
363 auto acquireFence3 = fenceFactory.createFenceTimeForTest(fence3);
364 auto dropStartTime2 = systemTime();
365 bufferData.acquireFence = fence3;
366 bufferData.frameNumber = 1;
367 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
368 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
369 std::shared_ptr<renderengine::ExternalTexture> externalTexture3 = std::make_shared<
370 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
371 1ULL /* bufferId */,
372 HAL_PIXEL_FORMAT_RGBA_8888,
373 0ULL /*usage*/);
374 FrameTimelineInfo ftInfo2;
375 ftInfo2.vsyncId = 2;
376 ftInfo2.inputEventId = 0;
377 layer->setBuffer(externalTexture3, bufferData, 10, 20, false, ftInfo2,
378 gui::GameMode::Unsupported);
379 auto dropEndTime2 = systemTime();
380 acquireFence3->signalForTest(12);
381
382 EXPECT_EQ(0u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
383 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
384 const auto presentedSurfaceFrame = layer->mDrawingState.bufferSurfaceFrameTX;
385
386 commitTransaction(layer.get());
387 layer->updateTexImage(15);
388
389 EXPECT_EQ(1, droppedSurfaceFrame1->getToken());
390 EXPECT_EQ(true, droppedSurfaceFrame1->getIsBuffer());
391 EXPECT_EQ(PresentState::Dropped, droppedSurfaceFrame1->getPresentState());
392 EXPECT_EQ(0u, droppedSurfaceFrame1->getActuals().endTime);
393 auto dropTime1 = droppedSurfaceFrame1->getDropTime();
394 EXPECT_TRUE(dropTime1 > dropStartTime1 && dropTime1 < dropEndTime1);
395
396 EXPECT_EQ(FrameTimelineInfo::INVALID_VSYNC_ID, droppedSurfaceFrame2->getToken());
397 EXPECT_EQ(true, droppedSurfaceFrame2->getIsBuffer());
398 EXPECT_EQ(PresentState::Dropped, droppedSurfaceFrame2->getPresentState());
399 EXPECT_EQ(0u, droppedSurfaceFrame2->getActuals().endTime);
400 auto dropTime2 = droppedSurfaceFrame2->getDropTime();
401 EXPECT_TRUE(dropTime2 > dropStartTime2 && dropTime2 < dropEndTime2);
402
403 EXPECT_EQ(2, presentedSurfaceFrame->getToken());
404 EXPECT_EQ(true, presentedSurfaceFrame->getIsBuffer());
405 EXPECT_EQ(PresentState::Presented, presentedSurfaceFrame->getPresentState());
406 }
407
MultipleCommitsBeforeLatch()408 void MultipleCommitsBeforeLatch() {
409 sp<Layer> layer = createLayer();
410 std::vector<std::shared_ptr<frametimeline::SurfaceFrame>> surfaceFrames;
411 for (int i = 0; i < 10; i += 2) {
412 sp<Fence> fence(sp<Fence>::make());
413 BufferData bufferData;
414 bufferData.acquireFence = fence;
415 bufferData.frameNumber = 1;
416 bufferData.flags |= BufferData::BufferDataChange::fenceChanged;
417 bufferData.flags |= BufferData::BufferDataChange::frameNumberChanged;
418 std::shared_ptr<renderengine::ExternalTexture> externalTexture = std::make_shared<
419 renderengine::mock::FakeExternalTexture>(1U /*width*/, 1U /*height*/,
420 1ULL /* bufferId */,
421 HAL_PIXEL_FORMAT_RGBA_8888,
422 0ULL /*usage*/);
423 FrameTimelineInfo ftInfo;
424 ftInfo.vsyncId = 1;
425 ftInfo.inputEventId = 0;
426 layer->setBuffer(externalTexture, bufferData, 10, 20, false, ftInfo,
427 gui::GameMode::Unsupported);
428 FrameTimelineInfo ftInfo2;
429 ftInfo2.vsyncId = 2;
430 ftInfo2.inputEventId = 0;
431 layer->setFrameTimelineVsyncForBufferlessTransaction(ftInfo2, 10,
432 gui::GameMode::Unsupported);
433 ASSERT_NE(nullptr, layer->mDrawingState.bufferSurfaceFrameTX);
434 EXPECT_EQ(1u, layer->mDrawingState.bufferlessSurfaceFramesTX.size());
435
436 surfaceFrames.push_back(layer->mDrawingState.bufferSurfaceFrameTX);
437 surfaceFrames.push_back(
438 layer->mDrawingState.bufferlessSurfaceFramesTX.at(/*vsyncId*/ 2));
439
440 commitTransaction(layer.get());
441 }
442
443 auto presentedBufferSurfaceFrame = layer->mDrawingState.bufferSurfaceFrameTX;
444 layer->updateTexImage(15);
445 // BufferlessSurfaceFrames are immediately set to presented and added to the DisplayFrame.
446 // Since we don't have access to DisplayFrame here, trigger an onPresent directly.
447 // The odd indices are the bufferless frames.
448 for (uint32_t i = 1; i < 10; i += 2) {
449 surfaceFrames[i]->onPresent(20, JankType::None, 90_Hz, 90_Hz,
450 /*displayDeadlineDelta*/ 0, /*displayPresentDelta*/ 0);
451 }
452 presentedBufferSurfaceFrame->onPresent(20, JankType::None, 90_Hz, 90_Hz,
453 /*displayDeadlineDelta*/ 0,
454 /*displayPresentDelta*/ 0);
455
456 // For the frames upto 8, the bufferSurfaceFrame should have been dropped while the
457 // bufferlessSurfaceFrame presented
458 for (uint32_t i = 0; i < 8; i += 2) {
459 auto bufferSurfaceFrame = surfaceFrames[i];
460 auto bufferlessSurfaceFrame = surfaceFrames[i + 1];
461 EXPECT_EQ(bufferSurfaceFrame->getPresentState(), PresentState::Dropped);
462 EXPECT_EQ(bufferlessSurfaceFrame->getPresentState(), PresentState::Presented);
463 }
464 {
465 auto bufferSurfaceFrame = surfaceFrames[8];
466 auto bufferlessSurfaceFrame = surfaceFrames[9];
467 EXPECT_EQ(bufferSurfaceFrame->getPresentState(), PresentState::Presented);
468 EXPECT_EQ(bufferlessSurfaceFrame->getPresentState(), PresentState::Presented);
469 }
470
471 layer->releasePendingBuffer(25);
472 }
473 };
474
TEST_F(TransactionSurfaceFrameTest,PresentedBufferlessSurfaceFrame)475 TEST_F(TransactionSurfaceFrameTest, PresentedBufferlessSurfaceFrame) {
476 PresentedSurfaceFrameForBufferlessTransaction();
477 }
478
TEST_F(TransactionSurfaceFrameTest,PresentedBufferSurfaceFrame)479 TEST_F(TransactionSurfaceFrameTest, PresentedBufferSurfaceFrame) {
480 PresentedSurfaceFrameForBufferTransaction();
481 }
482
TEST_F(TransactionSurfaceFrameTest,DroppedBufferSurfaceFrame)483 TEST_F(TransactionSurfaceFrameTest, DroppedBufferSurfaceFrame) {
484 DroppedSurfaceFrameForBufferTransaction();
485 }
486
TEST_F(TransactionSurfaceFrameTest,BufferlessSurfaceFramePromotedToBufferSurfaceFrame)487 TEST_F(TransactionSurfaceFrameTest, BufferlessSurfaceFramePromotedToBufferSurfaceFrame) {
488 BufferlessSurfaceFramePromotedToBufferSurfaceFrame();
489 }
490
TEST_F(TransactionSurfaceFrameTest,BufferlessSurfaceFrameNotCreatedIfBufferSufaceFrameExists)491 TEST_F(TransactionSurfaceFrameTest, BufferlessSurfaceFrameNotCreatedIfBufferSufaceFrameExists) {
492 BufferlessSurfaceFrameNotCreatedIfBufferSufaceFrameExists();
493 }
494
TEST_F(TransactionSurfaceFrameTest,MultipleSurfaceFramesPresentedTogether)495 TEST_F(TransactionSurfaceFrameTest, MultipleSurfaceFramesPresentedTogether) {
496 MultipleSurfaceFramesPresentedTogether();
497 }
498
TEST_F(TransactionSurfaceFrameTest,BufferSurfaceFrame_ReplaceValidTokenBufferWithInvalidTokenBuffer)499 TEST_F(TransactionSurfaceFrameTest,
500 BufferSurfaceFrame_ReplaceValidTokenBufferWithInvalidTokenBuffer) {
501 BufferSurfaceFrame_ReplaceValidTokenBufferWithInvalidTokenBuffer();
502 }
503
TEST_F(TransactionSurfaceFrameTest,MultipleCommitsBeforeLatch)504 TEST_F(TransactionSurfaceFrameTest, MultipleCommitsBeforeLatch) {
505 MultipleCommitsBeforeLatch();
506 }
507
508 } // namespace android
509