1 /*
2 * Copyright (C) 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 TransactionFrameTracerTest : public testing::Test {
42 public:
TransactionFrameTracerTest()43 TransactionFrameTracerTest() {
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
~TransactionFrameTracerTest()51 ~TransactionFrameTracerTest() {
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
BLASTTransactionSendsFrameTracerEvents()100 void BLASTTransactionSendsFrameTracerEvents() {
101 sp<BufferStateLayer> layer = createBufferStateLayer();
102
103 sp<Fence> fence(new Fence());
104 const auto buffer = std::make_shared<
105 renderengine::ExternalTexture>(new GraphicBuffer(1, 1, HAL_PIXEL_FORMAT_RGBA_8888,
106 1, 0),
107 mRenderEngine, false);
108 int32_t layerId = layer->getSequence();
109 uint64_t bufferId = buffer->getBuffer()->getId();
110 uint64_t frameNumber = 5;
111 nsecs_t dequeueTime = 10;
112 nsecs_t postTime = 20;
113 EXPECT_CALL(*mFlinger.getFrameTracer(), traceNewLayer(layerId, "buffer-state-layer"));
114 EXPECT_CALL(*mFlinger.getFrameTracer(),
115 traceTimestamp(layerId, bufferId, frameNumber, dequeueTime,
116 FrameTracer::FrameEvent::DEQUEUE, /*duration*/ 0));
117 EXPECT_CALL(*mFlinger.getFrameTracer(),
118 traceTimestamp(layerId, bufferId, frameNumber, postTime,
119 FrameTracer::FrameEvent::QUEUE, /*duration*/ 0));
120 layer->setBuffer(buffer, fence, postTime, /*desiredPresentTime*/ 30, false, mClientCache,
121 frameNumber, dequeueTime, FrameTimelineInfo{},
122 nullptr /* releaseBufferCallback */, nullptr /* releaseBufferEndpoint*/);
123
124 commitTransaction(layer.get());
125 bool computeVisisbleRegions;
126 nsecs_t latchTime = 25;
127 EXPECT_CALL(*mFlinger.getFrameTracer(),
128 traceFence(layerId, bufferId, frameNumber, _,
129 FrameTracer::FrameEvent::ACQUIRE_FENCE, /*startTime*/ 0));
130 EXPECT_CALL(*mFlinger.getFrameTracer(),
131 traceTimestamp(layerId, bufferId, frameNumber, latchTime,
132 FrameTracer::FrameEvent::LATCH, /*duration*/ 0));
133 layer->updateTexImage(computeVisisbleRegions, latchTime, /*expectedPresentTime*/ 0);
134
135 auto glDoneFence = fenceFactory.createFenceTimeForTest(fence);
136 auto presentFence = fenceFactory.createFenceTimeForTest(fence);
137 CompositorTiming compositorTiming;
138 EXPECT_CALL(*mFlinger.getFrameTracer(),
139 traceFence(layerId, bufferId, frameNumber, presentFence,
140 FrameTracer::FrameEvent::PRESENT_FENCE, /*startTime*/ 0));
141 layer->onPostComposition(nullptr, glDoneFence, presentFence, compositorTiming);
142 }
143 };
144
TEST_F(TransactionFrameTracerTest,BLASTTransactionSendsFrameTracerEvents)145 TEST_F(TransactionFrameTracerTest, BLASTTransactionSendsFrameTracerEvents) {
146 BLASTTransactionSendsFrameTracerEvents();
147 }
148
149 } // namespace android
150