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