blob: 7c431a077ba6b2350268e1de119174ec96ed1c33 [file] [log] [blame]
Valerie Haud251afb2019-03-29 14:19:02 -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
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017
Valerie Haud251afb2019-03-29 14:19:02 -070018#undef LOG_TAG
19#define LOG_TAG "CompositionTest"
20
21#include <compositionengine/Display.h>
22#include <compositionengine/mock/DisplaySurface.h>
23#include <gmock/gmock.h>
24#include <gtest/gtest.h>
25#include <gui/SurfaceComposerClient.h>
26#include <log/log.h>
27#include <utils/String8.h>
28
29#include "TestableScheduler.h"
30#include "TestableSurfaceFlinger.h"
Valerie Haud251afb2019-03-29 14:19:02 -070031#include "mock/MockEventThread.h"
32#include "mock/MockMessageQueue.h"
Ady Abraham8cb21882020-08-26 18:22:05 -070033#include "mock/MockVsyncController.h"
Valerie Haud251afb2019-03-29 14:19:02 -070034
35namespace android {
36
37using testing::_;
38using testing::Return;
39
40using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;
41
42class TransactionApplicationTest : public testing::Test {
43public:
44 TransactionApplicationTest() {
45 const ::testing::TestInfo* const test_info =
46 ::testing::UnitTest::GetInstance()->current_test_info();
47 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
48
49 mFlinger.mutableEventQueue().reset(mMessageQueue);
50 setupScheduler();
51 }
52
53 ~TransactionApplicationTest() {
54 const ::testing::TestInfo* const test_info =
55 ::testing::UnitTest::GetInstance()->current_test_info();
56 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
57 }
58
59 void setupScheduler() {
60 auto eventThread = std::make_unique<mock::EventThread>();
61 auto sfEventThread = std::make_unique<mock::EventThread>();
62
63 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
64 EXPECT_CALL(*eventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -070065 .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,
66 ResyncCallback())));
Valerie Haud251afb2019-03-29 14:19:02 -070067
68 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
69 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
Ady Abraham62f216c2020-10-13 19:07:23 -070070 .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,
71 ResyncCallback())));
Valerie Haud251afb2019-03-29 14:19:02 -070072
Ady Abraham8cb21882020-08-26 18:22:05 -070073 EXPECT_CALL(*mVSyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));
74 EXPECT_CALL(*mVSyncTracker, currentPeriod())
Marin Shalamanov045b7002021-01-07 16:56:24 +010075 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Valerie Haud251afb2019-03-29 14:19:02 -070076
Ady Abraham8cb21882020-08-26 18:22:05 -070077 mFlinger.setupScheduler(std::unique_ptr<mock::VsyncController>(mVsyncController),
78 std::unique_ptr<mock::VSyncTracker>(mVSyncTracker),
Valerie Haud251afb2019-03-29 14:19:02 -070079 std::move(eventThread), std::move(sfEventThread));
80 }
81
82 TestableScheduler* mScheduler;
83 TestableSurfaceFlinger mFlinger;
84
85 std::unique_ptr<mock::EventThread> mEventThread = std::make_unique<mock::EventThread>();
Valerie Haud251afb2019-03-29 14:19:02 -070086
87 mock::MessageQueue* mMessageQueue = new mock::MessageQueue();
Ady Abraham8cb21882020-08-26 18:22:05 -070088 mock::VsyncController* mVsyncController = new mock::VsyncController();
89 mock::VSyncTracker* mVSyncTracker = new mock::VSyncTracker();
Valerie Haud251afb2019-03-29 14:19:02 -070090
91 struct TransactionInfo {
92 Vector<ComposerState> states;
93 Vector<DisplayState> displays;
94 uint32_t flags = 0;
95 sp<IBinder> applyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance());
96 InputWindowCommands inputWindowCommands;
Ady Abrahamf0c56492020-12-17 18:04:15 -080097 int64_t desiredPresentTime = 0;
98 bool isAutoTimestamp = true;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -100099 FrameTimelineInfo frameTimelineInfo;
Valerie Haud251afb2019-03-29 14:19:02 -0700100 client_cache_t uncacheBuffer;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000101 uint64_t id = static_cast<uint64_t>(-1);
102 static_assert(0xffffffffffffffff == static_cast<uint64_t>(-1));
Valerie Haud251afb2019-03-29 14:19:02 -0700103 };
104
105 void checkEqual(TransactionInfo info, SurfaceFlinger::TransactionState state) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000106 EXPECT_EQ(0u, info.states.size());
107 EXPECT_EQ(0u, state.states.size());
Valerie Haud251afb2019-03-29 14:19:02 -0700108
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000109 EXPECT_EQ(0u, info.displays.size());
110 EXPECT_EQ(0u, state.displays.size());
Valerie Haud251afb2019-03-29 14:19:02 -0700111 EXPECT_EQ(info.flags, state.flags);
112 EXPECT_EQ(info.desiredPresentTime, state.desiredPresentTime);
113 }
114
115 void setupSingle(TransactionInfo& transaction, uint32_t flags, bool syncInputWindows,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800116 int64_t desiredPresentTime, bool isAutoTimestamp,
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000117 const FrameTimelineInfo& frameTimelineInfo) {
Valerie Haud251afb2019-03-29 14:19:02 -0700118 mTransactionNumber++;
119 transaction.flags |= flags; // ISurfaceComposer::eSynchronous;
120 transaction.inputWindowCommands.syncInputWindows = syncInputWindows;
121 transaction.desiredPresentTime = desiredPresentTime;
Ady Abrahamf0c56492020-12-17 18:04:15 -0800122 transaction.isAutoTimestamp = isAutoTimestamp;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000123 transaction.frameTimelineInfo = frameTimelineInfo;
Valerie Haud251afb2019-03-29 14:19:02 -0700124 }
125
126 void NotPlacedOnTransactionQueue(uint32_t flags, bool syncInputWindows) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000127 ASSERT_EQ(0u, mFlinger.getTransactionQueue().size());
Valerie Haud251afb2019-03-29 14:19:02 -0700128 // called in SurfaceFlinger::signalTransaction
129 EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
Valerie Haud251afb2019-03-29 14:19:02 -0700130 TransactionInfo transaction;
131 setupSingle(transaction, flags, syncInputWindows,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800132 /*desiredPresentTime*/ systemTime(), /*isAutoTimestamp*/ true,
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000133 FrameTimelineInfo{});
Valerie Haud251afb2019-03-29 14:19:02 -0700134 nsecs_t applicationTime = systemTime();
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000135 mFlinger.setTransactionState(transaction.frameTimelineInfo, transaction.states,
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700136 transaction.displays, transaction.flags,
Valerie Haud251afb2019-03-29 14:19:02 -0700137 transaction.applyToken, transaction.inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800138 transaction.desiredPresentTime, transaction.isAutoTimestamp,
139 transaction.uncacheBuffer, mHasListenerCallbacks, mCallbacks,
140 transaction.id);
Valerie Haud251afb2019-03-29 14:19:02 -0700141
Valerie Haud251afb2019-03-29 14:19:02 -0700142 // If transaction is synchronous or syncs input windows, SF
143 // applyTransactionState should time out (5s) wating for SF to commit
144 // the transaction or to receive a signal that syncInputWindows has
145 // completed. If this is animation, it should not time out waiting.
146 nsecs_t returnedTime = systemTime();
147 if (flags & ISurfaceComposer::eSynchronous || syncInputWindows) {
148 EXPECT_GE(returnedTime, applicationTime + s2ns(5));
149 } else {
150 EXPECT_LE(returnedTime, applicationTime + s2ns(5));
151 }
Arthur Hung58144272021-01-16 03:43:53 +0000152 // Each transaction should have been placed on the transaction queue
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +0000153 auto transactionQueue = mFlinger.getTransactionQueue();
Arthur Hung58144272021-01-16 03:43:53 +0000154 EXPECT_EQ(1u, transactionQueue.size());
Valerie Haud251afb2019-03-29 14:19:02 -0700155 }
156
157 void PlaceOnTransactionQueue(uint32_t flags, bool syncInputWindows) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000158 ASSERT_EQ(0u, mFlinger.getTransactionQueue().size());
Valerie Haud251afb2019-03-29 14:19:02 -0700159 // called in SurfaceFlinger::signalTransaction
160 EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
161
162 // first check will see desired present time has not passed,
163 // but afterwards it will look like the desired present time has passed
164 nsecs_t time = systemTime();
Valerie Haud251afb2019-03-29 14:19:02 -0700165 TransactionInfo transaction;
166 setupSingle(transaction, flags, syncInputWindows,
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000167 /*desiredPresentTime*/ time + s2ns(1), false, FrameTimelineInfo{});
Valerie Haud251afb2019-03-29 14:19:02 -0700168 nsecs_t applicationSentTime = systemTime();
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000169 mFlinger.setTransactionState(transaction.frameTimelineInfo, transaction.states,
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700170 transaction.displays, transaction.flags,
Valerie Haud251afb2019-03-29 14:19:02 -0700171 transaction.applyToken, transaction.inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800172 transaction.desiredPresentTime, transaction.isAutoTimestamp,
173 transaction.uncacheBuffer, mHasListenerCallbacks, mCallbacks,
174 transaction.id);
Valerie Haud251afb2019-03-29 14:19:02 -0700175
176 nsecs_t returnedTime = systemTime();
Ady Abrahame46243a2021-02-23 19:33:49 -0800177 if ((flags & ISurfaceComposer::eSynchronous) || syncInputWindows) {
178 EXPECT_GE(systemTime(), applicationSentTime + s2ns(5));
179 } else {
180 EXPECT_LE(returnedTime, applicationSentTime + s2ns(5));
181 }
Valerie Haud251afb2019-03-29 14:19:02 -0700182 // This transaction should have been placed on the transaction queue
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +0000183 auto transactionQueue = mFlinger.getTransactionQueue();
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000184 EXPECT_EQ(1u, transactionQueue.size());
Valerie Haud251afb2019-03-29 14:19:02 -0700185 }
186
187 void BlockedByPriorTransaction(uint32_t flags, bool syncInputWindows) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000188 ASSERT_EQ(0u, mFlinger.getTransactionQueue().size());
Valerie Haud251afb2019-03-29 14:19:02 -0700189 // called in SurfaceFlinger::signalTransaction
190 nsecs_t time = systemTime();
Ady Abrahame46243a2021-02-23 19:33:49 -0800191 if (!syncInputWindows) {
192 EXPECT_CALL(*mMessageQueue, invalidate()).Times(2);
193 } else {
194 EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
195 }
Valerie Haud251afb2019-03-29 14:19:02 -0700196 // transaction that should go on the pending thread
197 TransactionInfo transactionA;
198 setupSingle(transactionA, /*flags*/ 0, /*syncInputWindows*/ false,
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000199 /*desiredPresentTime*/ time + s2ns(1), false, FrameTimelineInfo{});
Valerie Haud251afb2019-03-29 14:19:02 -0700200
201 // transaction that would not have gone on the pending thread if not
202 // blocked
203 TransactionInfo transactionB;
204 setupSingle(transactionB, flags, syncInputWindows,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800205 /*desiredPresentTime*/ systemTime(), /*isAutoTimestamp*/ true,
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000206 FrameTimelineInfo{});
Valerie Haud251afb2019-03-29 14:19:02 -0700207
208 nsecs_t applicationSentTime = systemTime();
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000209 mFlinger.setTransactionState(transactionA.frameTimelineInfo, transactionA.states,
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700210 transactionA.displays, transactionA.flags,
Valerie Haud251afb2019-03-29 14:19:02 -0700211 transactionA.applyToken, transactionA.inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800212 transactionA.desiredPresentTime, transactionA.isAutoTimestamp,
213 transactionA.uncacheBuffer, mHasListenerCallbacks, mCallbacks,
214 transactionA.id);
Valerie Haud251afb2019-03-29 14:19:02 -0700215
216 // This thread should not have been blocked by the above transaction
217 // (5s is the timeout period that applyTransactionState waits for SF to
218 // commit the transaction)
219 EXPECT_LE(systemTime(), applicationSentTime + s2ns(5));
Arthur Hung58144272021-01-16 03:43:53 +0000220 // transaction that would goes to pending transaciton queue.
221 mFlinger.flushTransactionQueues();
Valerie Haud251afb2019-03-29 14:19:02 -0700222
223 applicationSentTime = systemTime();
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000224 mFlinger.setTransactionState(transactionB.frameTimelineInfo, transactionB.states,
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700225 transactionB.displays, transactionB.flags,
Valerie Haud251afb2019-03-29 14:19:02 -0700226 transactionB.applyToken, transactionB.inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800227 transactionB.desiredPresentTime, transactionB.isAutoTimestamp,
228 transactionB.uncacheBuffer, mHasListenerCallbacks, mCallbacks,
229 transactionB.id);
Valerie Haud251afb2019-03-29 14:19:02 -0700230
231 // this thread should have been blocked by the above transaction
232 // if this is an animation, this thread should be blocked for 5s
233 // in setTransactionState waiting for transactionA to flush. Otherwise,
234 // the transaction should be placed on the pending queue
Ady Abrahame46243a2021-02-23 19:33:49 -0800235 if (flags & (ISurfaceComposer::eAnimation | ISurfaceComposer::eSynchronous) ||
236 syncInputWindows) {
Valerie Haud251afb2019-03-29 14:19:02 -0700237 EXPECT_GE(systemTime(), applicationSentTime + s2ns(5));
238 } else {
239 EXPECT_LE(systemTime(), applicationSentTime + s2ns(5));
240 }
241
Arthur Hung58144272021-01-16 03:43:53 +0000242 // transaction that would goes to pending transaciton queue.
243 mFlinger.flushTransactionQueues();
244
Ady Abrahame46243a2021-02-23 19:33:49 -0800245 // check that the transaction was applied.
Arthur Hung58144272021-01-16 03:43:53 +0000246 auto transactionQueue = mFlinger.getPendingTransactionQueue();
Ady Abrahame46243a2021-02-23 19:33:49 -0800247 EXPECT_EQ(0u, transactionQueue.size());
Valerie Haud251afb2019-03-29 14:19:02 -0700248 }
249
250 bool mHasListenerCallbacks = false;
251 std::vector<ListenerCallbacks> mCallbacks;
252 int mTransactionNumber = 0;
253};
254
255TEST_F(TransactionApplicationTest, Flush_RemovesFromQueue) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000256 ASSERT_EQ(0u, mFlinger.getTransactionQueue().size());
Valerie Haud251afb2019-03-29 14:19:02 -0700257 // called in SurfaceFlinger::signalTransaction
258 EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
259
Valerie Haud251afb2019-03-29 14:19:02 -0700260 TransactionInfo transactionA; // transaction to go on pending queue
261 setupSingle(transactionA, /*flags*/ 0, /*syncInputWindows*/ false,
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000262 /*desiredPresentTime*/ s2ns(1), false, FrameTimelineInfo{});
263 mFlinger.setTransactionState(transactionA.frameTimelineInfo, transactionA.states,
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700264 transactionA.displays, transactionA.flags, transactionA.applyToken,
265 transactionA.inputWindowCommands, transactionA.desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800266 transactionA.isAutoTimestamp, transactionA.uncacheBuffer,
267 mHasListenerCallbacks, mCallbacks, transactionA.id);
Valerie Haud251afb2019-03-29 14:19:02 -0700268
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +0000269 auto& transactionQueue = mFlinger.getTransactionQueue();
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000270 ASSERT_EQ(1u, transactionQueue.size());
Valerie Haud251afb2019-03-29 14:19:02 -0700271
Arthur Hung58144272021-01-16 03:43:53 +0000272 auto& transactionState = transactionQueue.front();
Valerie Haud251afb2019-03-29 14:19:02 -0700273 checkEqual(transactionA, transactionState);
274
275 // because flushing uses the cached expected present time, we send an empty
276 // transaction here (sending a null applyToken to fake it as from a
277 // different process) to re-query and reset the cached expected present time
278 TransactionInfo empty;
279 empty.applyToken = sp<IBinder>();
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000280 mFlinger.setTransactionState(empty.frameTimelineInfo, empty.states, empty.displays, empty.flags,
281 empty.applyToken, empty.inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800282 empty.desiredPresentTime, empty.isAutoTimestamp,
283 empty.uncacheBuffer, mHasListenerCallbacks, mCallbacks, empty.id);
Valerie Haud251afb2019-03-29 14:19:02 -0700284
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +0000285 // flush transaction queue should flush as desiredPresentTime has
Valerie Haud251afb2019-03-29 14:19:02 -0700286 // passed
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +0000287 mFlinger.flushTransactionQueues();
Valerie Haud251afb2019-03-29 14:19:02 -0700288
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000289 EXPECT_EQ(0u, transactionQueue.size());
Valerie Haud251afb2019-03-29 14:19:02 -0700290}
291
292TEST_F(TransactionApplicationTest, NotPlacedOnTransactionQueue_Synchronous) {
293 NotPlacedOnTransactionQueue(ISurfaceComposer::eSynchronous, /*syncInputWindows*/ false);
294}
295
296TEST_F(TransactionApplicationTest, NotPlacedOnTransactionQueue_Animation) {
297 NotPlacedOnTransactionQueue(ISurfaceComposer::eAnimation, /*syncInputWindows*/ false);
298}
299
300TEST_F(TransactionApplicationTest, NotPlacedOnTransactionQueue_SyncInputWindows) {
301 NotPlacedOnTransactionQueue(/*flags*/ 0, /*syncInputWindows*/ true);
302}
303
304TEST_F(TransactionApplicationTest, PlaceOnTransactionQueue_Synchronous) {
305 PlaceOnTransactionQueue(ISurfaceComposer::eSynchronous, /*syncInputWindows*/ false);
306}
307
308TEST_F(TransactionApplicationTest, PlaceOnTransactionQueue_Animation) {
309 PlaceOnTransactionQueue(ISurfaceComposer::eAnimation, /*syncInputWindows*/ false);
310}
311
312TEST_F(TransactionApplicationTest, PlaceOnTransactionQueue_SyncInputWindows) {
313 PlaceOnTransactionQueue(/*flags*/ 0, /*syncInputWindows*/ true);
314}
315
316TEST_F(TransactionApplicationTest, BlockWithPriorTransaction_Synchronous) {
317 BlockedByPriorTransaction(ISurfaceComposer::eSynchronous, /*syncInputWindows*/ false);
318}
319
320TEST_F(TransactionApplicationTest, BlockWithPriorTransaction_Animation) {
321 BlockedByPriorTransaction(ISurfaceComposer::eSynchronous, /*syncInputWindows*/ false);
322}
323
324TEST_F(TransactionApplicationTest, BlockWithPriorTransaction_SyncInputWindows) {
325 BlockedByPriorTransaction(/*flags*/ 0, /*syncInputWindows*/ true);
326}
327
Valerie Hau09e60052019-12-15 14:51:15 -0800328TEST_F(TransactionApplicationTest, FromHandle) {
329 sp<IBinder> badHandle;
330 auto ret = mFlinger.fromHandle(badHandle);
Alec Mouri9a02eda2020-04-21 17:39:34 -0700331 EXPECT_EQ(nullptr, ret.promote().get());
Valerie Hau09e60052019-12-15 14:51:15 -0800332}
Valerie Haud251afb2019-03-29 14:19:02 -0700333} // namespace android