/* * Copyright 2019 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #undef LOG_TAG #define LOG_TAG "TransactionApplicationTest" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "FrontEnd/TransactionHandler.h" #include "QueuedTransactionState.h" #include "TestableSurfaceFlinger.h" #include namespace android { using namespace com::android::graphics::surfaceflinger; using testing::_; using testing::Return; using frontend::TransactionHandler; constexpr nsecs_t TRANSACTION_TIMEOUT = s2ns(5); class TransactionApplicationTest : public testing::Test { public: TransactionApplicationTest() { const ::testing::TestInfo* const test_info = ::testing::UnitTest::GetInstance()->current_test_info(); ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name()); mFlinger.setupComposer(std::make_unique()); mFlinger.setupMockScheduler(); mFlinger.setupRenderEngine(std::unique_ptr(mRenderEngine)); mFlinger.flinger()->addTransactionReadyFilters(); } ~TransactionApplicationTest() { const ::testing::TestInfo* const test_info = ::testing::UnitTest::GetInstance()->current_test_info(); ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name()); } TestableSurfaceFlinger mFlinger; renderengine::mock::RenderEngine* mRenderEngine = new renderengine::mock::RenderEngine(); struct TransactionInfo { TransactionState transactionState; sp applyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); static_assert(0xffffffffffffffff == static_cast(-1)); std::vector earlyWakeupInfos; }; void checkEqual(const TransactionState& info, const QueuedTransactionState& state) { EXPECT_EQ(0u, info.mComposerStates.size()); EXPECT_EQ(0u, state.states.size()); EXPECT_EQ(0u, info.mDisplayStates.size()); EXPECT_EQ(0u, state.displays.size()); EXPECT_EQ(info.mFlags, state.flags); EXPECT_EQ(info.mDesiredPresentTime, state.desiredPresentTime); } TransactionState setupSingle(uint32_t flags, int64_t desiredPresentTime, bool isAutoTimestamp, const FrameTimelineInfo& frameTimelineInfo) { TransactionState state; state.mId = static_cast(-1); state.mFlags |= flags; state.mDesiredPresentTime = desiredPresentTime; state.mIsAutoTimestamp = isAutoTimestamp; state.mFrameTimelineInfo = frameTimelineInfo; state.mCallbacks.mHasListenerCallbacks = mHasListenerCallbacks; state.mCallbacks.mFlattenedListenerCallbacks = mCallbacks; return state; } void setupSingle(TransactionInfo& transaction, uint32_t flags, int64_t desiredPresentTime, bool isAutoTimestamp, const FrameTimelineInfo& frameTimelineInfo) { mTransactionNumber++; transaction.transactionState = setupSingle(flags, desiredPresentTime, isAutoTimestamp, frameTimelineInfo); } void NotPlacedOnTransactionQueue(uint32_t flags) { ASSERT_TRUE(mFlinger.getTransactionQueue().isEmpty()); EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(1); TransactionInfo transaction; setupSingle(transaction, flags, /*desiredPresentTime*/ systemTime(), /*isAutoTimestamp*/ true, FrameTimelineInfo{}); nsecs_t applicationTime = systemTime(); mFlinger.setTransactionState(std::move(transaction.transactionState), transaction.applyToken); // If transaction is synchronous, SF applyTransactionState should time out (5s) wating for // SF to commit the transaction. If this is animation, it should not time out waiting. nsecs_t returnedTime = systemTime(); EXPECT_LE(returnedTime, applicationTime + TRANSACTION_TIMEOUT); // Each transaction should have been placed on the transaction queue auto& transactionQueue = mFlinger.getTransactionQueue(); EXPECT_FALSE(transactionQueue.isEmpty()); } void PlaceOnTransactionQueue(uint32_t flags) { ASSERT_TRUE(mFlinger.getTransactionQueue().isEmpty()); EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(1); // first check will see desired present time has not passed, // but afterwards it will look like the desired present time has passed nsecs_t time = systemTime(); TransactionInfo transaction; setupSingle(transaction, flags, /*desiredPresentTime*/ time + s2ns(1), false, FrameTimelineInfo{}); nsecs_t applicationSentTime = systemTime(); mFlinger.setTransactionState(std::move(transaction.transactionState), transaction.applyToken); nsecs_t returnedTime = systemTime(); EXPECT_LE(returnedTime, applicationSentTime + TRANSACTION_TIMEOUT); // This transaction should have been placed on the transaction queue auto& transactionQueue = mFlinger.getTransactionQueue(); EXPECT_FALSE(transactionQueue.isEmpty()); } void BlockedByPriorTransaction(uint32_t flags) { ASSERT_TRUE(mFlinger.getTransactionQueue().isEmpty()); nsecs_t time = systemTime(); EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(2); // transaction that should go on the pending thread TransactionInfo transactionA; setupSingle(transactionA, /*flags*/ 0, /*desiredPresentTime*/ time + s2ns(1), false, FrameTimelineInfo{}); // transaction that would not have gone on the pending thread if not // blocked TransactionInfo transactionB; setupSingle(transactionB, flags, /*desiredPresentTime*/ systemTime(), /*isAutoTimestamp*/ true, FrameTimelineInfo{}); nsecs_t applicationSentTime = systemTime(); mFlinger.setTransactionState(std::move(transactionA.transactionState), transactionA.applyToken); // This thread should not have been blocked by the above transaction // (5s is the timeout period that applyTransactionState waits for SF to // commit the transaction) EXPECT_LE(systemTime(), applicationSentTime + TRANSACTION_TIMEOUT); // transaction that would goes to pending transaciton queue. mFlinger.flushTransactionQueues(); applicationSentTime = systemTime(); mFlinger.setTransactionState(std::move(transactionB.transactionState), transactionB.applyToken); // this thread should have been blocked by the above transaction // if this is an animation, this thread should be blocked for 5s // in setTransactionState waiting for transactionA to flush. Otherwise, // the transaction should be placed on the pending queue EXPECT_LE(systemTime(), applicationSentTime + TRANSACTION_TIMEOUT); // transaction that would goes to pending transaciton queue. mFlinger.flushTransactionQueues(); // check that the transaction was applied. const auto& transactionQueue = mFlinger.getPendingTransactionQueue(); EXPECT_EQ(0u, transactionQueue.size()); } void modulateVsync() { static_cast( mFlinger.mutableScheduler().vsyncModulator().onRefreshRateChangeInitiated()); } bool mHasListenerCallbacks = false; std::vector mCallbacks; int mTransactionNumber = 0; }; TEST_F(TransactionApplicationTest, WaitForTransactionBarrierSignal) { ASSERT_TRUE(mFlinger.getTransactionQueue().isEmpty()); EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(1); auto applyToken1 = sp::make(); auto applyToken2 = sp::make(); TransactionInfo waitTransaction; setupSingle(waitTransaction, /*flags*/ 0, /*desiredPresentTime*/ s2ns(1), false, FrameTimelineInfo{}); gui::TransactionBarrier waitBarrier; waitBarrier.barrierToken = String16("tok"); waitBarrier.kind = gui::TransactionBarrier::BarrierKind::KIND_WAIT; waitTransaction.transactionState.mBarriers.emplace_back(std::move(waitBarrier)); mFlinger.setTransactionState(std::move(waitTransaction.transactionState), applyToken1); mFlinger.flushTransactionQueues(); const auto& transactionQueue = mFlinger.getPendingTransactionQueue(); EXPECT_EQ(1u, transactionQueue.size()); TransactionInfo sigTransaction; setupSingle(sigTransaction, /*flags*/ 0, /*desiredPresentTime*/ s2ns(1), false, FrameTimelineInfo{}); gui::TransactionBarrier sigBarrier; sigBarrier.barrierToken = String16("tok"); sigBarrier.kind = gui::TransactionBarrier::BarrierKind::KIND_SIGNAL; sigTransaction.transactionState.mBarriers.emplace_back(std::move(sigBarrier)); mFlinger.setTransactionState(std::move(sigTransaction.transactionState), applyToken2); mFlinger.flushTransactionQueues(); EXPECT_TRUE(mFlinger.getPendingTransactionQueue().empty()); } TEST_F(TransactionApplicationTest, AddToPendingQueue) { ASSERT_TRUE(mFlinger.getTransactionQueue().isEmpty()); EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(1); TransactionInfo transactionA; // transaction to go on pending queue setupSingle(transactionA, /*flags*/ 0, /*desiredPresentTime*/ s2ns(1), false, FrameTimelineInfo{}); mFlinger.setTransactionState(std::move(transactionA.transactionState), transactionA.applyToken); auto& transactionQueue = mFlinger.getTransactionQueue(); ASSERT_FALSE(transactionQueue.isEmpty()); auto transactionState = transactionQueue.pop().value(); checkEqual(transactionA.transactionState, transactionState); } TEST_F(TransactionApplicationTest, Flush_RemovesFromQueue) { ASSERT_TRUE(mFlinger.getTransactionQueue().isEmpty()); EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(1); TransactionInfo transactionA; // transaction to go on pending queue setupSingle(transactionA, /*flags*/ 0, /*desiredPresentTime*/ s2ns(1), false, FrameTimelineInfo{}); mFlinger.setTransactionState(std::move(transactionA.transactionState), transactionA.applyToken); auto& transactionQueue = mFlinger.getTransactionQueue(); ASSERT_FALSE(transactionQueue.isEmpty()); // because flushing uses the cached expected present time, we send an empty // transaction here (sending a null applyToken to fake it as from a // different process) to re-query and reset the cached expected present time TransactionInfo empty; empty.applyToken = sp(); mFlinger.setTransactionState(std::move(empty.transactionState), empty.applyToken); // flush transaction queue should flush as desiredPresentTime has // passed mFlinger.flushTransactionQueues(); EXPECT_TRUE(mFlinger.getTransactionQueue().isEmpty()); } TEST_F(TransactionApplicationTest, NotPlacedOnTransactionQueue_SyncInputWindows) { NotPlacedOnTransactionQueue(/*flags*/ 0); } TEST_F(TransactionApplicationTest, PlaceOnTransactionQueue_SyncInputWindows) { PlaceOnTransactionQueue(/*flags*/ 0); } TEST_F(TransactionApplicationTest, FromHandle) { sp badHandle; auto ret = mFlinger.fromHandle(badHandle); EXPECT_EQ(nullptr, ret.get()); } class FakeExternalTexture : public renderengine::ExternalTexture { const sp mEmptyBuffer = nullptr; uint32_t mWidth; uint32_t mHeight; uint64_t mId; PixelFormat mPixelFormat; uint64_t mUsage; public: FakeExternalTexture(BufferData& bufferData) : mWidth(bufferData.getWidth()), mHeight(bufferData.getHeight()), mId(bufferData.getId()), mPixelFormat(bufferData.getPixelFormat()), mUsage(bufferData.getUsage()) {} const sp& getBuffer() const { return mEmptyBuffer; } bool hasSameBuffer(const renderengine::ExternalTexture& other) const override { return getId() == other.getId(); } uint32_t getWidth() const override { return mWidth; } uint32_t getHeight() const override { return mHeight; } uint64_t getId() const override { return mId; } PixelFormat getPixelFormat() const override { return mPixelFormat; } uint64_t getUsage() const override { return mUsage; } void remapBuffer() override {} ~FakeExternalTexture() = default; }; TEST_F(TransactionApplicationTest, ApplyTokensUseDifferentQueues) { auto applyToken1 = sp::make(); auto applyToken2 = sp::make(); // Transaction 1 has a buffer with an unfired fence. It should not be ready to be applied. QueuedTransactionState transaction1; transaction1.applyToken = applyToken1; transaction1.id = 42069; transaction1.states.emplace_back(); transaction1.states[0].state.what |= layer_state_t::eBufferChanged; transaction1.states[0].state.bufferData = std::make_shared(/* bufferId */ 1, /* width */ 1, /* height */ 1, /* pixelFormat */ 0, /* outUsage */ 0); mFlinger.addLayer(1); bool out; mFlinger.updateLayerSnapshots(VsyncId{1}, 0, 0, /* transactionsFlushed */ true, out); transaction1.states[0].externalTexture = std::make_shared(*transaction1.states[0].state.bufferData); transaction1.states[0].state.surface = mFlinger.getLegacyLayer(1)->getHandle(); auto fence = sp::make(); EXPECT_CALL(*fence, getStatus()).WillRepeatedly(Return(Fence::Status::Unsignaled)); transaction1.states[0].state.bufferData->acquireFence = std::move(fence); transaction1.states[0].state.bufferData->flags = BufferData::BufferDataChange::fenceChanged; transaction1.states[0].layerId = 1; transaction1.isAutoTimestamp = true; // Transaction 2 should be ready to be applied. QueuedTransactionState transaction2; transaction2.applyToken = applyToken2; transaction2.id = 2; transaction2.isAutoTimestamp = true; mFlinger.setTransactionStateInternal(transaction1); mFlinger.setTransactionStateInternal(transaction2); mFlinger.flushTransactionQueues(); const auto& transactionQueues = mFlinger.getPendingTransactionQueue(); // Transaction 1 is still in its queue. EXPECT_EQ(transactionQueues.at(applyToken1).size(), 1u); // Transaction 2 has been dequeued. EXPECT_FALSE(transactionQueues.contains(applyToken2)); } class LatchUnsignaledTest : public TransactionApplicationTest { public: void TearDown() override { // Clear all transaction queues to release all transactions we sent // in the tests. Otherwise, gmock complains about memory leaks. while (!mFlinger.getTransactionQueue().isEmpty()) { mFlinger.getTransactionQueue().pop(); } mFlinger.getPendingTransactionQueue().clear(); mFlinger.commitTransactionsLocked(eTransactionMask); mFlinger.destroyAllLayerHandles(); } static sp fence(Fence::Status status) { const auto fence = sp::make(); EXPECT_CALL(*fence, getStatus()).WillRepeatedly(Return(status)); return fence; } ComposerState createComposerState(int layerId, sp fence, uint64_t what) { ComposerState state; state.state.bufferData = std::make_shared(/* bufferId */ 123L, /* width */ 1, /* height */ 2, /* pixelFormat */ 0, /* outUsage */ 0); state.state.bufferData->acquireFence = std::move(fence); state.state.layerId = layerId; state.state.bufferData->flags = BufferData::BufferDataChange::fenceChanged; state.state.what = what; if (what & layer_state_t::eCropChanged) { state.state.crop = FloatRect(1, 2, 3, 4); } if (what & layer_state_t::eFlagsChanged) { state.state.flags = layer_state_t::eEnableBackpressure; state.state.mask = layer_state_t::eEnableBackpressure; } return state; } TransactionInfo createTransactionInfo(const sp& applyToken, const std::vector& states) { TransactionInfo transaction; const uint32_t kFlags = 0; const nsecs_t kDesiredPresentTime = systemTime(); const bool kIsAutoTimestamp = true; const auto kFrameTimelineInfo = FrameTimelineInfo{}; setupSingle(transaction, kFlags, kDesiredPresentTime, kIsAutoTimestamp, kFrameTimelineInfo); transaction.applyToken = applyToken; for (const auto& state : states) { transaction.transactionState.mComposerStates.push_back(state); } return transaction; } void setTransactionStates(const std::vector& transactions, size_t expectedTransactionsPending) { EXPECT_TRUE(mFlinger.getTransactionQueue().isEmpty()); EXPECT_EQ(0u, mFlinger.getPendingTransactionQueue().size()); std::unordered_set createdLayers; for (auto transaction : transactions) { for (auto& state : transaction.transactionState.mComposerStates) { auto layerId = static_cast(state.state.layerId); if (createdLayers.find(layerId) == createdLayers.end()) { mFlinger.addLayer(layerId); createdLayers.insert(layerId); } } } bool unused; bool mustComposite = mFlinger.updateLayerSnapshots(VsyncId{1}, /*frameTimeNs=*/0, /*expectedPresentTimeNs=*/0, /*transactionsFlushed=*/true, unused); for (auto transaction : transactions) { std::vector resolvedStates; resolvedStates.reserve(transaction.transactionState.mComposerStates.size()); for (auto& state : transaction.transactionState.mComposerStates) { ResolvedComposerState resolvedState; resolvedState.state = std::move(state.state); resolvedState.externalTexture = std::make_shared(*resolvedState.state.bufferData); resolvedState.layerId = static_cast(state.state.layerId); resolvedState.state.surface = mFlinger.getLegacyLayer(resolvedState.layerId)->getHandle(); resolvedStates.emplace_back(resolvedState); } QueuedTransactionState transactionState(transaction.transactionState.mFrameTimelineInfo, resolvedStates, transaction.transactionState.mDisplayStates, transaction.transactionState.mFlags, transaction.applyToken, transaction.transactionState.mInputWindowCommands, transaction.transactionState.mDesiredPresentTime, transaction.transactionState.mIsAutoTimestamp, {}, systemTime(), mHasListenerCallbacks, mCallbacks, getpid(), static_cast(getuid()), transaction.transactionState.getId(), transaction.transactionState.mMergedTransactionIds, transaction.transactionState.mEarlyWakeupInfos, transaction.transactionState.mBarriers); mFlinger.setTransactionStateInternal(transactionState); } mFlinger.flushTransactionQueues(); EXPECT_TRUE(mFlinger.getTransactionQueue().isEmpty()); EXPECT_EQ(expectedTransactionsPending, mFlinger.getPendingTransactionCount()); } }; class LatchUnsignaledAutoSingleLayerTest : public LatchUnsignaledTest { public: void SetUp() override { LatchUnsignaledTest::SetUp(); SurfaceFlinger::enableLatchUnsignaledConfig = LatchUnsignaledConfig::AutoSingleLayer; } }; TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_RemovesSingleSignaledFromTheQueue) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 10; const auto kExpectedTransactionsPending = 0u; const auto signaledTransaction = createTransactionInfo(kApplyToken, {createComposerState(kLayerId, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged)}); setTransactionStates({signaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_RemovesSingleUnSignaledFromTheQueue) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 1; const auto kExpectedTransactionsPending = 0u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_KeepsUnSignaledInTheQueue_NonBufferCropChange) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 1; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eCropChanged | layer_state_t:: eBufferChanged), }); setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_RemovesUnSignaledInTheQueue_AutoRefreshChanged) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 1; const auto kExpectedTransactionsPending = 0u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eAutoRefreshChanged | layer_state_t:: eBufferChanged), }); setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_KeepsUnSignaledInTheQueue_NonBufferChangeClubed) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 1; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eCropChanged | layer_state_t:: eBufferChanged), }); setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_KeepsInTheQueueSameApplyTokenMultiState) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 1; const auto kExpectedTransactionsPending = 1u; const auto mixedTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), createComposerState(kLayerId, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); setTransactionStates({mixedTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_KeepsInTheQueue_MultipleStateTransaction) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 1u; const auto mixedTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId1, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), createComposerState(kLayerId2, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); setTransactionStates({mixedTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_RemovesSignaledFromTheQueue) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 0u; const auto signaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId1, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); const auto signaledTransaction2 = createTransactionInfo(kApplyToken, { createComposerState(kLayerId2, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); setTransactionStates({signaledTransaction, signaledTransaction2}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, UnsignaledNotAppliedWhenThereAreSignaled_UnsignaledFirst) { const sp kApplyToken1 = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const sp kApplyToken2 = sp::make(); const sp kApplyToken3 = sp::make(); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken1, { createComposerState(kLayerId1, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); const auto signaledTransaction = createTransactionInfo(kApplyToken2, { createComposerState(kLayerId2, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); const auto signaledTransaction2 = createTransactionInfo(kApplyToken3, { createComposerState(kLayerId2, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction, signaledTransaction, signaledTransaction2}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_KeepsTransactionInTheQueueSameApplyToken) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId1, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); const auto signaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId2, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction, signaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, Flush_KeepsTransactionInTheQueue) { const sp kApplyToken1 = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const sp kApplyToken2 = sp::make(); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken1, { createComposerState(kLayerId1, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); const auto unsignaledTransaction2 = createTransactionInfo(kApplyToken2, { createComposerState(kLayerId2, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction, unsignaledTransaction2}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, DontLatchUnsignaledWhenEarlyOffset) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 1; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); modulateVsync(); setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledAutoSingleLayerTest, UnsignaledNotAppliedWhenThereAreSignaled_SignaledFirst) { const sp kApplyToken1 = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const sp kApplyToken2 = sp::make(); const sp kApplyToken3 = sp::make(); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 1u; const auto signaledTransaction = createTransactionInfo(kApplyToken1, { createComposerState(kLayerId1, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); const auto signaledTransaction2 = createTransactionInfo(kApplyToken2, { createComposerState(kLayerId1, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); const auto unsignaledTransaction = createTransactionInfo(kApplyToken3, { createComposerState(kLayerId2, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); setTransactionStates({signaledTransaction, signaledTransaction2, unsignaledTransaction}, kExpectedTransactionsPending); } class LatchUnsignaledDisabledTest : public LatchUnsignaledTest { public: void SetUp() override { LatchUnsignaledTest::SetUp(); SurfaceFlinger::enableLatchUnsignaledConfig = LatchUnsignaledConfig::Disabled; } }; TEST_F(LatchUnsignaledDisabledTest, Flush_RemovesSignaledFromTheQueue) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 10; const auto kExpectedTransactionsPending = 0u; const auto signaledTransaction = createTransactionInfo(kApplyToken, {createComposerState(kLayerId, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged)}); setTransactionStates({signaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledDisabledTest, Flush_KeepsInTheQueue) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 1; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledDisabledTest, Flush_KeepsInTheQueueSameLayerId) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId = 1; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), createComposerState(kLayerId, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledDisabledTest, Flush_KeepsInTheQueueDifferentLayerId) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId1, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), createComposerState(kLayerId2, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledDisabledTest, Flush_RemovesSignaledFromTheQueue_MultipleLayers) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 0u; const auto signaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId1, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); const auto signaledTransaction2 = createTransactionInfo(kApplyToken, { createComposerState(kLayerId2, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); setTransactionStates({signaledTransaction, signaledTransaction2}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledDisabledTest, Flush_KeepInTheQueueDifferentApplyToken) { const sp kApplyToken1 = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const sp kApplyToken2 = sp::make(); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 1u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken1, { createComposerState(kLayerId1, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); const auto signaledTransaction = createTransactionInfo(kApplyToken2, { createComposerState(kLayerId2, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction, signaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledDisabledTest, Flush_KeepInTheQueueSameApplyToken) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 1u; const auto signaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId1, fence(Fence::Status::Signaled), layer_state_t::eBufferChanged), }); const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId2, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); setTransactionStates({signaledTransaction, unsignaledTransaction}, kExpectedTransactionsPending); } TEST_F(LatchUnsignaledDisabledTest, Flush_KeepInTheUnsignaledTheQueue) { const sp kApplyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance()); const auto kLayerId1 = 1; const auto kLayerId2 = 2; const auto kExpectedTransactionsPending = 2u; const auto unsignaledTransaction = createTransactionInfo(kApplyToken, { createComposerState(kLayerId1, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); const auto unsignaledTransaction2 = createTransactionInfo(kApplyToken, { createComposerState(kLayerId2, fence(Fence::Status::Unsignaled), layer_state_t::eBufferChanged), }); setTransactionStates({unsignaledTransaction, unsignaledTransaction2}, kExpectedTransactionsPending); } TEST(TransactionHandlerTest, QueueTransaction) { TransactionHandler handler; QueuedTransactionState transaction; transaction.applyToken = sp::make(); transaction.id = 42; handler.queueTransaction(std::move(transaction)); handler.collectTransactions(); std::vector transactionsReadyToBeApplied = handler.flushTransactions(); EXPECT_EQ(transactionsReadyToBeApplied.size(), 1u); EXPECT_EQ(transactionsReadyToBeApplied.front().id, 42u); } QueuedTransactionState createBarrierTransaction(uint64_t id, gui::TransactionBarrier::BarrierKind kind) { QueuedTransactionState transaction; transaction.applyToken = sp::make(); transaction.id = id; transaction.postTime = systemTime(); gui::TransactionBarrier b; b.barrierToken = String16("tok"); b.kind = kind; transaction.transactionBarriers.emplace_back(std::move(b)); return transaction; } TEST(TransactionHandlerTest, WaitBarrierExpiration) { TransactionHandler handler; handler.addTransactionReadyFilter(std::bind(&TransactionHandler::isBarrierSignalledOrExpired, &handler, std::placeholders::_1)); QueuedTransactionState transaction = createBarrierTransaction(42, gui::TransactionBarrier::BarrierKind::KIND_WAIT); handler.queueTransaction(std::move(transaction)); handler.collectTransactions(); std::vector transactionsReadyToBeApplied = handler.flushTransactions(); // Barrier not signalled or expired. EXPECT_TRUE(transactionsReadyToBeApplied.empty()); handler.setTransactionBarrierTtl(std::chrono::milliseconds(0)); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // Barrier expired. EXPECT_EQ(transactionsReadyToBeApplied.size(), 1u); EXPECT_EQ(transactionsReadyToBeApplied.front().id, 42u); } TEST(TransactionHandlerTest, WaitBarrierSignalled) { TransactionHandler handler; handler.addTransactionReadyFilter(std::bind(&TransactionHandler::isBarrierSignalledOrExpired, &handler, std::placeholders::_1)); QueuedTransactionState waitTransaction = createBarrierTransaction(42, gui::TransactionBarrier::BarrierKind::KIND_WAIT); handler.queueTransaction(std::move(waitTransaction)); handler.collectTransactions(); std::vector transactionsReadyToBeApplied = handler.flushTransactions(); // Barrier not signalled or expired. EXPECT_TRUE(transactionsReadyToBeApplied.empty()); QueuedTransactionState sigTransaction = createBarrierTransaction(43, gui::TransactionBarrier::BarrierKind::KIND_SIGNAL); handler.queueTransaction(std::move(sigTransaction)); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // Signal and wait transactions applied. EXPECT_EQ(transactionsReadyToBeApplied.size(), 2u); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // No more transactions left. EXPECT_TRUE(transactionsReadyToBeApplied.empty()); } TEST(TransactionHandlerTest, WaitEnqueuedAfterBarrierSignalled) { TransactionHandler handler; handler.addTransactionReadyFilter(std::bind(&TransactionHandler::isBarrierSignalledOrExpired, &handler, std::placeholders::_1)); QueuedTransactionState sigTransaction = createBarrierTransaction(43, gui::TransactionBarrier::BarrierKind::KIND_SIGNAL); handler.queueTransaction(std::move(sigTransaction)); handler.collectTransactions(); std::vector transactionsReadyToBeApplied = handler.flushTransactions(); // Signal transaction ready to be applied. EXPECT_EQ(transactionsReadyToBeApplied.size(), 1u); EXPECT_EQ(transactionsReadyToBeApplied.front().id, 43u); QueuedTransactionState waitTransaction = createBarrierTransaction(42, gui::TransactionBarrier::BarrierKind::KIND_WAIT); handler.queueTransaction(std::move(waitTransaction)); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // Wait transactions applied. EXPECT_EQ(transactionsReadyToBeApplied.size(), 1u); EXPECT_EQ(transactionsReadyToBeApplied.front().id, 42u); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // No more transactions left. EXPECT_TRUE(transactionsReadyToBeApplied.empty()); } TEST(TransactionHandlerTest, SignalAndWaitEnqueuedTogether) { TransactionHandler handler; handler.addTransactionReadyFilter(std::bind(&TransactionHandler::isBarrierSignalledOrExpired, &handler, std::placeholders::_1)); QueuedTransactionState sigTransaction = createBarrierTransaction(43, gui::TransactionBarrier::BarrierKind::KIND_SIGNAL); handler.queueTransaction(std::move(sigTransaction)); QueuedTransactionState waitTransaction = createBarrierTransaction(42, gui::TransactionBarrier::BarrierKind::KIND_WAIT); handler.queueTransaction(std::move(waitTransaction)); handler.collectTransactions(); auto transactionsReadyToBeApplied = handler.flushTransactions(); // Both transactions applied. EXPECT_EQ(transactionsReadyToBeApplied.size(), 2u); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // No more transactions left. EXPECT_TRUE(transactionsReadyToBeApplied.empty()); } TEST(TransactionHandlerTest, WaitAndSignalEnqueuedTogether) { TransactionHandler handler; handler.addTransactionReadyFilter(std::bind(&TransactionHandler::isBarrierSignalledOrExpired, &handler, std::placeholders::_1)); QueuedTransactionState waitTransaction = createBarrierTransaction(42, gui::TransactionBarrier::BarrierKind::KIND_WAIT); handler.queueTransaction(std::move(waitTransaction)); QueuedTransactionState sigTransaction = createBarrierTransaction(43, gui::TransactionBarrier::BarrierKind::KIND_SIGNAL); handler.queueTransaction(std::move(sigTransaction)); handler.collectTransactions(); auto transactionsReadyToBeApplied = handler.flushTransactions(); // Both transactions applied. EXPECT_EQ(transactionsReadyToBeApplied.size(), 2u); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // No more transactions left. EXPECT_TRUE(transactionsReadyToBeApplied.empty()); } TEST(TransactionHandlerTest, SignalBarrierExpiration) { TransactionHandler handler; handler.setTransactionBarrierTtl(std::chrono::milliseconds(0)); QueuedTransactionState sigTransaction = createBarrierTransaction(42, gui::TransactionBarrier::BarrierKind::KIND_SIGNAL); handler.addTransactionReadyFilter(std::bind(&TransactionHandler::isBarrierSignalledOrExpired, &handler, std::placeholders::_1)); handler.queueTransaction(std::move(sigTransaction)); handler.collectTransactions(); std::vector transactionsReadyToBeApplied = handler.flushTransactions(); // Signal transaction ready to be applied. EXPECT_EQ(transactionsReadyToBeApplied.size(), 1u); EXPECT_EQ(transactionsReadyToBeApplied.front().id, 42u); // Expire the signal. handler.flushTransactions(); handler.setTransactionBarrierTtl(std::chrono::seconds(5)); QueuedTransactionState waitTransaction = createBarrierTransaction(43, gui::TransactionBarrier::BarrierKind::KIND_WAIT); handler.queueTransaction(std::move(waitTransaction)); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // Signal expired, wait transaction still queued. EXPECT_TRUE(transactionsReadyToBeApplied.empty()); handler.setTransactionBarrierTtl(std::chrono::seconds(0)); handler.collectTransactions(); transactionsReadyToBeApplied = handler.flushTransactions(); // Wait transaction expired and can be applied. EXPECT_EQ(transactionsReadyToBeApplied.size(), 1u); EXPECT_EQ(transactionsReadyToBeApplied.front().id, 43u); } TEST(TransactionHandlerTest, TransactionsKeepTrackOfDirectMerges) { SurfaceComposerClient::Transaction transaction1, transaction2, transaction3, transaction4; uint64_t transaction2Id = transaction2.getId(); uint64_t transaction3Id = transaction3.getId(); EXPECT_NE(transaction2Id, transaction3Id); transaction1.merge(std::move(transaction2)); transaction1.merge(std::move(transaction3)); EXPECT_EQ(transaction1.getMergedTransactionIds().size(), 2u); EXPECT_EQ(transaction1.getMergedTransactionIds()[0], transaction3Id); EXPECT_EQ(transaction1.getMergedTransactionIds()[1], transaction2Id); } TEST(TransactionHandlerTest, TransactionsKeepTrackOfIndirectMerges) { SurfaceComposerClient::Transaction transaction1, transaction2, transaction3, transaction4; uint64_t transaction2Id = transaction2.getId(); uint64_t transaction3Id = transaction3.getId(); uint64_t transaction4Id = transaction4.getId(); EXPECT_NE(transaction2Id, transaction3Id); EXPECT_NE(transaction2Id, transaction4Id); EXPECT_NE(transaction3Id, transaction4Id); transaction4.merge(std::move(transaction2)); transaction4.merge(std::move(transaction3)); EXPECT_EQ(transaction4.getMergedTransactionIds().size(), 2u); EXPECT_EQ(transaction4.getMergedTransactionIds()[0], transaction3Id); EXPECT_EQ(transaction4.getMergedTransactionIds()[1], transaction2Id); transaction1.merge(std::move(transaction4)); EXPECT_EQ(transaction1.getMergedTransactionIds().size(), 3u); EXPECT_EQ(transaction1.getMergedTransactionIds()[0], transaction4Id); EXPECT_EQ(transaction1.getMergedTransactionIds()[1], transaction3Id); EXPECT_EQ(transaction1.getMergedTransactionIds()[2], transaction2Id); } TEST(TransactionHandlerTest, TransactionMergesAreCleared) { SurfaceComposerClient::Transaction transaction1, transaction2, transaction3; transaction1.merge(std::move(transaction2)); transaction1.merge(std::move(transaction3)); EXPECT_EQ(transaction1.getMergedTransactionIds().size(), 2u); transaction1.clear(); EXPECT_EQ(transaction1.getMergedTransactionIds().empty(), true); } TEST(TransactionHandlerTest, TransactionMergesAreCapped) { SurfaceComposerClient::Transaction transaction; std::vector mergedTransactionIds; for (uint i = 0; i < 20u; i++) { SurfaceComposerClient::Transaction transactionToMerge; mergedTransactionIds.push_back(transactionToMerge.getId()); transaction.merge(std::move(transactionToMerge)); } // Keeps latest 10 merges in order of merge recency EXPECT_EQ(transaction.getMergedTransactionIds().size(), 10u); for (uint i = 0; i < 10u; i++) { EXPECT_EQ(transaction.getMergedTransactionIds()[i], mergedTransactionIds[mergedTransactionIds.size() - 1 - i]); } } TEST(TransactionHandlerTest, KeepsMergesFromMoreRecentMerge) { SurfaceComposerClient::Transaction transaction1, transaction2, transaction3; std::vector mergedTransactionIds1, mergedTransactionIds2, mergedTransactionIds3; uint64_t transaction2Id = transaction2.getId(); uint64_t transaction3Id = transaction3.getId(); for (uint i = 0; i < 20u; i++) { SurfaceComposerClient::Transaction transactionToMerge; mergedTransactionIds1.push_back(transactionToMerge.getId()); transaction1.merge(std::move(transactionToMerge)); } for (uint i = 0; i < 5u; i++) { SurfaceComposerClient::Transaction transactionToMerge; mergedTransactionIds2.push_back(transactionToMerge.getId()); transaction2.merge(std::move(transactionToMerge)); } transaction1.merge(std::move(transaction2)); EXPECT_EQ(transaction1.getMergedTransactionIds().size(), 10u); EXPECT_EQ(transaction1.getMergedTransactionIds()[0], transaction2Id); for (uint i = 0; i < 5u; i++) { EXPECT_EQ(transaction1.getMergedTransactionIds()[i + 1u], mergedTransactionIds2[mergedTransactionIds2.size() - 1 - i]); } for (uint i = 0; i < 4u; i++) { EXPECT_EQ(transaction1.getMergedTransactionIds()[i + 6u], mergedTransactionIds1[mergedTransactionIds1.size() - 1 - i]); } for (uint i = 0; i < 20u; i++) { SurfaceComposerClient::Transaction transactionToMerge; mergedTransactionIds3.push_back(transactionToMerge.getId()); transaction3.merge(std::move(transactionToMerge)); } transaction1.merge(std::move(transaction3)); EXPECT_EQ(transaction1.getMergedTransactionIds().size(), 10u); EXPECT_EQ(transaction1.getMergedTransactionIds()[0], transaction3Id); for (uint i = 0; i < 9u; i++) { EXPECT_EQ(transaction1.getMergedTransactionIds()[i + 1], mergedTransactionIds3[mergedTransactionIds3.size() - 1 - i]); } } TEST(TransactionHandlerTest, CanAddTransactionWithFullMergedIds) { SurfaceComposerClient::Transaction transaction1, transaction2; for (uint i = 0; i < 20u; i++) { SurfaceComposerClient::Transaction transactionToMerge; transaction1.merge(std::move(transactionToMerge)); } EXPECT_EQ(transaction1.getMergedTransactionIds().size(), 10u); auto transaction1Id = transaction1.getId(); transaction2.merge(std::move(transaction1)); EXPECT_EQ(transaction2.getMergedTransactionIds().size(), 10u); auto mergedTransactionIds = transaction2.getMergedTransactionIds(); EXPECT_TRUE(std::count(mergedTransactionIds.begin(), mergedTransactionIds.end(), transaction1Id) > 0); } } // namespace android