Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3e95285e authored by arthurhung's avatar arthurhung
Browse files

Introduce SurfaceFlinger Queued Transaction 

Implements the transaction queue to store the transaction updated from
'setTransactionState', and apply these queued transactions in main
thread. That would prevent holding the state lock between binder thread
and main thread.

- The setTransactionState won't call 'applyTransactionState' directly.
- The queue is protected by queue lock, apply/get states will still be
  protected by state lock.
- drain and apply transaction queue should be triggered in main thread.
- Sync transaction will wait after the condition broadcast, protected
  by stack lock.

Test: atest libsurfaceflinger_unittest SurfaceFlinger_test libgui_test
Bug: 166236811
Change-Id: Iab78a6d1e554d28eb4ffc5df860263ecb9091749
parent b2d6a712

services/surfaceflinger/SurfaceFlinger.cpp

+145 −146
Original line number Diff line number Diff line
@@ -1896,19 +1896,18 @@ void SurfaceFlinger::onMessageInvalidate(int64_t vsyncId, nsecs_t expectedVSyncT 


bool SurfaceFlinger::handleMessageTransaction() {

    ATRACE_CALL();

    uint32_t transactionFlags = peekTransactionFlags();



    bool flushedATransaction = flushTransactionQueues();

    if (getTransactionFlags(eTransactionFlushNeeded)) {

        flushPendingTransactionQueues();

        flushTransactionQueue();

    }



    uint32_t transactionFlags = peekTransactionFlags();

    bool runHandleTransaction =

            (transactionFlags && (transactionFlags != eTransactionFlushNeeded)) ||

            flushedATransaction ||

            mForceTraversal;

            (transactionFlags && (transactionFlags != eTransactionFlushNeeded)) || mForceTraversal;



    if (runHandleTransaction) {

        handleTransaction(eTransactionMask);

    } else {

        getTransactionFlags(eTransactionFlushNeeded);

    }



    if (transactionFlushNeeded()) {
@@ -2777,7 +2776,6 @@ void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags) 
        });

    }



    commitInputWindowCommands();

    commitTransaction();

}
@@ -2818,11 +2816,6 @@ void SurfaceFlinger::updateInputWindowInfo() { 
                                                                     : nullptr);

}



void SurfaceFlinger::commitInputWindowCommands() {

    mInputWindowCommands.merge(mPendingInputWindowCommands);

    mPendingInputWindowCommands.clear();

}



void SurfaceFlinger::updateCursorAsync() {

    compositionengine::CompositionRefreshArgs refreshArgs;

    for (const auto& [_, display] : ON_MAIN_THREAD(mDisplays)) {
@@ -3175,50 +3168,52 @@ void SurfaceFlinger::setTraversalNeeded() { 
    mForceTraversal = true;

}



bool SurfaceFlinger::flushTransactionQueues() {

void SurfaceFlinger::flushPendingTransactionQueues() {

    // to prevent onHandleDestroyed from being called while the lock is held,

    // we must keep a copy of the transactions (specifically the composer

    // states) around outside the scope of the lock

    std::vector<const TransactionState> transactions;

    bool flushedATransaction = false;

    {

        Mutex::Autolock _l(mStateLock);

        Mutex::Autolock _l(mQueueLock);



        auto it = mTransactionQueues.begin();

        while (it != mTransactionQueues.end()) {

        auto it = mPendingTransactionQueues.begin();

        while (it != mPendingTransactionQueues.end()) {

            auto& [applyToken, transactionQueue] = *it;



            while (!transactionQueue.empty()) {

                const auto& transaction = transactionQueue.front();

                if (!transactionIsReadyToBeApplied(transaction.desiredPresentTime,

                                                   transaction.states)) {

                    setTransactionFlags(eTransactionFlushNeeded);

                    break;

                }

                transactions.push_back(transaction);

                applyTransactionState(transaction.states, transaction.displays, transaction.flags,

                                      mPendingInputWindowCommands, transaction.desiredPresentTime,

                                      transaction.buffer, transaction.postTime,

                                      transaction.privileged, transaction.hasListenerCallbacks,

                                      transaction.listenerCallbacks, transaction.originPID,

                                      transaction.originUID, /*isMainThread*/ true);

                transactionQueue.pop();

                flushedATransaction = true;

            }



            if (transactionQueue.empty()) {

                it = mTransactionQueues.erase(it);

                it = mPendingTransactionQueues.erase(it);

                mTransactionCV.broadcast();

            } else {

                it = std::next(it, 1);

            }

        }

    }

    return flushedATransaction;



    {

        Mutex::Autolock _l(mStateLock);

        for (const auto& transaction : transactions) {

            applyTransactionState(transaction.states, transaction.displays, transaction.flags,

                                  mInputWindowCommands, transaction.desiredPresentTime,

                                  transaction.buffer, transaction.postTime, transaction.privileged,

                                  transaction.hasListenerCallbacks, transaction.listenerCallbacks,

                                  transaction.originPID, transaction.originUID);

        }

    }

}



bool SurfaceFlinger::transactionFlushNeeded() {

    return !mTransactionQueues.empty();

    Mutex::Autolock _l(mQueueLock);

    return !mPendingTransactionQueues.empty();

}
@@ -3253,17 +3248,16 @@ status_t SurfaceFlinger::setTransactionState( 
    ATRACE_CALL();



    const int64_t postTime = systemTime();



    bool privileged = callingThreadHasUnscopedSurfaceFlingerAccess();



    Mutex::Autolock _l(mStateLock);

    {

        Mutex::Autolock _l(mQueueLock);



        // If its TransactionQueue already has a pending TransactionState or if it is pending

    auto itr = mTransactionQueues.find(applyToken);

        auto itr = mPendingTransactionQueues.find(applyToken);

        // if this is an animation frame, wait until prior animation frame has

        // been applied by SF

        if (flags & eAnimation) {

        while (itr != mTransactionQueues.end()) {

            while (itr != mPendingTransactionQueues.end()) {

                status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));

                if (CC_UNLIKELY(err != NO_ERROR)) {

                    ALOGW_IF(err == TIMED_OUT,
@@ -3271,11 +3265,21 @@ status_t SurfaceFlinger::setTransactionState( 
                             "waiting for animation frame to apply");

                    break;

                }

            itr = mTransactionQueues.find(applyToken);

                itr = mPendingTransactionQueues.find(applyToken);

            }

        }



    const bool pendingTransactions = itr != mTransactionQueues.end();

        // TODO(b/159125966): Remove eEarlyWakeup completly as no client should use this flag

        if (flags & eEarlyWakeup) {

            ALOGW("eEarlyWakeup is deprecated. Use eExplicitEarlyWakeup[Start|End]");

        }



        if (!privileged && (flags & (eExplicitEarlyWakeupStart | eExplicitEarlyWakeupEnd))) {

            ALOGE("Only WindowManager is allowed to use eExplicitEarlyWakeup[Start|End] flags");

            flags &= ~(eExplicitEarlyWakeupStart | eExplicitEarlyWakeupEnd);

        }



        const bool pendingTransactions = itr != mPendingTransactionQueues.end();

        // Expected present time is computed and cached on invalidate, so it may be stale.

        if (!pendingTransactions) {

            mExpectedPresentTime = calculateExpectedPresentTime(systemTime());
@@ -3286,43 +3290,92 @@ status_t SurfaceFlinger::setTransactionState( 
        const int originUID = ipc->getCallingUid();



        if (pendingTransactions || !transactionIsReadyToBeApplied(desiredPresentTime, states)) {

        mTransactionQueues[applyToken].emplace(states, displays, flags, desiredPresentTime,

            mPendingTransactionQueues[applyToken].emplace(states, displays, flags,

                                                          inputWindowCommands, desiredPresentTime,

                                                          uncacheBuffer, postTime, privileged,

                                               hasListenerCallbacks, listenerCallbacks, originPID,

                                               originUID);

                                                          hasListenerCallbacks, listenerCallbacks,

                                                          originPID, originUID);

            setTransactionFlags(eTransactionFlushNeeded);

            return NO_ERROR;

        }



    applyTransactionState(states, displays, flags, inputWindowCommands, desiredPresentTime,

                          uncacheBuffer, postTime, privileged, hasListenerCallbacks,

                          listenerCallbacks, originPID, originUID, /*isMainThread*/ false);

        mTransactionQueue.emplace_back(states, displays, flags, inputWindowCommands,

                                       desiredPresentTime, uncacheBuffer, postTime, privileged,

                                       hasListenerCallbacks, listenerCallbacks, originPID,

                                       originUID);

    }



    {

        Mutex::Autolock _l(mStateLock);



        const auto schedule = [](uint32_t flags) {

            if (flags & eEarlyWakeup) return TransactionSchedule::Early;

            if (flags & eExplicitEarlyWakeupEnd) return TransactionSchedule::EarlyEnd;

            if (flags & eExplicitEarlyWakeupStart) return TransactionSchedule::EarlyStart;

            return TransactionSchedule::Late;

        }(flags);



        // if this is a synchronous transaction, wait for it to take effect

        // before returning.

        const bool synchronous = flags & eSynchronous;

        const bool syncInput = inputWindowCommands.syncInputWindows;

        if (!synchronous && !syncInput) {

            setTransactionFlags(eTransactionFlushNeeded, schedule);

            return NO_ERROR;

        }



void SurfaceFlinger::applyTransactionState(

        const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,

        const InputWindowCommands& inputWindowCommands, const int64_t desiredPresentTime,

        const client_cache_t& uncacheBuffer, const int64_t postTime, bool privileged,

        bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,

        int originPID, int originUID, bool isMainThread) {

    uint32_t transactionFlags = 0;

        if (synchronous) {

            mTransactionPending = true;

        }

        if (syncInput) {

            mPendingSyncInputWindows = true;

        }

        setTransactionFlags(eTransactionFlushNeeded, schedule);



    if (flags & eAnimation) {

        // For window updates that are part of an animation we must wait for

        // previous animation "frames" to be handled.

        while (!isMainThread && mAnimTransactionPending) {

        // applyTransactionState can be called by either the main SF thread or by

        // another process through setTransactionState.  While a given process may wish

        // to wait on synchronous transactions, the main SF thread should never

        // be blocked.  Therefore, we only wait if isMainThread is false.

        while (mTransactionPending || mPendingSyncInputWindows) {

            status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));

            if (CC_UNLIKELY(err != NO_ERROR)) {

                // just in case something goes wrong in SF, return to the

                // caller after a few seconds.

                ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "

                        "waiting for previous animation frame");

                mAnimTransactionPending = false;

                // called after a few seconds.

                ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");

                mTransactionPending = false;

                mPendingSyncInputWindows = false;

                break;

            }

        }

    }

    return NO_ERROR;

}



void SurfaceFlinger::flushTransactionQueue() {

    std::vector<TransactionState> transactionQueue;

    {

        Mutex::Autolock _l(mQueueLock);

        if (!mTransactionQueue.empty()) {

            transactionQueue.swap(mTransactionQueue);

        }

    }



    Mutex::Autolock _l(mStateLock);

    for (const auto& t : transactionQueue) {

        applyTransactionState(t.states, t.displays, t.flags, t.inputWindowCommands,

                              t.desiredPresentTime, t.buffer, t.postTime, t.privileged,

                              t.hasListenerCallbacks, t.listenerCallbacks, t.originPID,

                              t.originUID);

    }

}



void SurfaceFlinger::applyTransactionState(

        const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,

        const InputWindowCommands& inputWindowCommands, const int64_t desiredPresentTime,

        const client_cache_t& uncacheBuffer, const int64_t postTime, bool privileged,

        bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,

        int32_t originPID, int32_t originUID) {

    uint32_t transactionFlags = 0;



    for (const DisplayState& display : displays) {

        transactionFlags |= setDisplayStateLocked(display);
@@ -3379,80 +3432,25 @@ void SurfaceFlinger::applyTransactionState( 
        transactionFlags = eTransactionNeeded;

    }



    // If we are on the main thread, we are about to preform a traversal. Clear the traversal bit

    // so we don't have to wake up again next frame to preform an uneeded traversal.

    if (isMainThread && (transactionFlags & eTraversalNeeded)) {

    if (transactionFlags && mInterceptor->isEnabled()) {

        mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags, originPID,

                                      originUID);

    }



    // We are on the main thread, we are about to preform a traversal. Clear the traversal bit

    // so we don't have to wake up again next frame to preform an unnecessary traversal.

    if (transactionFlags & eTraversalNeeded) {

        transactionFlags = transactionFlags & (~eTraversalNeeded);

        mForceTraversal = true;

    }



    const auto schedule = [](uint32_t flags) {

        if (flags & eEarlyWakeup) return TransactionSchedule::Early;

        if (flags & eExplicitEarlyWakeupEnd) return TransactionSchedule::EarlyEnd;

        if (flags & eExplicitEarlyWakeupStart) return TransactionSchedule::EarlyStart;

        return TransactionSchedule::Late;

    }(flags);



    if (transactionFlags) {

        if (mInterceptor->isEnabled()) {

            mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags,

                                          originPID, originUID);

        }



        // TODO(b/159125966): Remove eEarlyWakeup completly as no client should use this flag

        if (flags & eEarlyWakeup) {

            ALOGW("eEarlyWakeup is deprecated. Use eExplicitEarlyWakeup[Start|End]");

        }



        if (!privileged && (flags & (eExplicitEarlyWakeupStart | eExplicitEarlyWakeupEnd))) {

            ALOGE("Only WindowManager is allowed to use eExplicitEarlyWakeup[Start|End] flags");

            flags &= ~(eExplicitEarlyWakeupStart | eExplicitEarlyWakeupEnd);

        }



        // this triggers the transaction

        setTransactionFlags(transactionFlags, schedule);

        setTransactionFlags(transactionFlags);



        if (flags & eAnimation) {

            mAnimTransactionPending = true;

        }



        // if this is a synchronous transaction, wait for it to take effect

        // before returning.

        const bool synchronous = flags & eSynchronous;

        const bool syncInput = inputWindowCommands.syncInputWindows;

        if (!synchronous && !syncInput) {

            return;

        }



        if (synchronous) {

            mTransactionPending = true;

        }

        if (syncInput) {

            mPendingSyncInputWindows = true;

        }





        // applyTransactionState can be called by either the main SF thread or by

        // another process through setTransactionState.  While a given process may wish

        // to wait on synchronous transactions, the main SF thread should never

        // be blocked.  Therefore, we only wait if isMainThread is false.

        while (!isMainThread && (mTransactionPending || mPendingSyncInputWindows)) {

            status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));

            if (CC_UNLIKELY(err != NO_ERROR)) {

                // just in case something goes wrong in SF, return to the

                // called after a few seconds.

                ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");

                mTransactionPending = false;

                mPendingSyncInputWindows = false;

                break;

            }

        }

    } else {

        // Update VsyncModulator state machine even if transaction is not needed.

        if (schedule == TransactionSchedule::EarlyStart ||

            schedule == TransactionSchedule::EarlyEnd) {

            modulateVsync(&VsyncModulator::setTransactionSchedule, schedule);

        }

    }

}
@@ -3831,7 +3829,7 @@ uint32_t SurfaceFlinger::setClientStateLocked( 
}



uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {

    bool hasChanges = mPendingInputWindowCommands.merge(inputWindowCommands);

    bool hasChanges = mInputWindowCommands.merge(inputWindowCommands);

    return hasChanges ? eTraversalNeeded : 0;

}
@@ -4109,8 +4107,9 @@ void SurfaceFlinger::onInitializeDisplays() { 
    d.width = 0;

    d.height = 0;

    displays.add(d);

    setTransactionState(state, displays, 0, nullptr, mPendingInputWindowCommands, -1, {}, false,

                        {});

    // This called on the main thread, apply it directly.

    applyTransactionState(state, displays, 0, mInputWindowCommands, -1, {}, systemTime(), true,

                          false, {}, getpid(), getuid());



    setPowerModeInternal(display, hal::PowerMode::ON);

    const nsecs_t vsyncPeriod = mRefreshRateConfigs->getCurrentRefreshRate().getVsyncPeriod();
@@ -5274,7 +5273,7 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r 


void SurfaceFlinger::repaintEverything() {

    mRepaintEverything = true;

    signalTransaction();

    setTransactionFlags(eTransactionNeeded);

}



void SurfaceFlinger::repaintEverythingForHWC() {

services/surfaceflinger/SurfaceFlinger.h

+13 −9
Original line number Diff line number Diff line
@@ -433,13 +433,15 @@ private: 
    struct TransactionState {

        TransactionState(const Vector<ComposerState>& composerStates,

                         const Vector<DisplayState>& displayStates, uint32_t transactionFlags,

                         int64_t desiredPresentTime, const client_cache_t& uncacheBuffer,

                         int64_t postTime, bool privileged, bool hasListenerCallbacks,

                         const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,

                         const client_cache_t& uncacheBuffer, int64_t postTime, bool privileged,

                         bool hasListenerCallbacks,

                         std::vector<ListenerCallbacks> listenerCallbacks, int originPID,

                         int originUID)

              : states(composerStates),

                displays(displayStates),

                flags(transactionFlags),

                inputWindowCommands(inputWindowCommands),

                desiredPresentTime(desiredPresentTime),

                buffer(uncacheBuffer),

                postTime(postTime),
@@ -452,6 +454,7 @@ private: 
        Vector<ComposerState> states;

        Vector<DisplayState> displays;

        uint32_t flags;

        InputWindowCommands inputWindowCommands;

        const int64_t desiredPresentTime;

        client_cache_t buffer;

        const int64_t postTime;
@@ -704,6 +707,7 @@ private: 
    /*

     * Transactions

     */

    void flushTransactionQueue();

    void applyTransactionState(const Vector<ComposerState>& state,

                               const Vector<DisplayState>& displays, uint32_t flags,

                               const InputWindowCommands& inputWindowCommands,
@@ -711,10 +715,9 @@ private: 
                               const client_cache_t& uncacheBuffer, const int64_t postTime,

                               bool privileged, bool hasListenerCallbacks,

                               const std::vector<ListenerCallbacks>& listenerCallbacks,

                               int originPID, int originUID, bool isMainThread = false)

            REQUIRES(mStateLock);

    // Returns true if at least one transaction was flushed

    bool flushTransactionQueues();

                               int32_t originPID, int32_t originUID) REQUIRES(mStateLock);

    // flush pending transaction that was presented after desiredPresentTime.

    void flushPendingTransactionQueues();

    // Returns true if there is at least one transaction that needs to be flushed

    bool transactionFlushNeeded();

    uint32_t getTransactionFlags(uint32_t flags);
@@ -1158,8 +1161,10 @@ private: 
    uint32_t mTexturePoolSize = 0;

    std::vector<uint32_t> mTexturePool;



    std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash> mTransactionQueues;



    mutable Mutex mQueueLock;

    std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash>

            mPendingTransactionQueues GUARDED_BY(mQueueLock);

    std::vector<TransactionState> mTransactionQueue GUARDED_BY(mQueueLock);

    /*

     * Feature prototyping

     */
@@ -1236,7 +1241,6 @@ private: 
    const float mEmulatedDisplayDensity;



    sp<os::IInputFlinger> mInputFlinger;

    InputWindowCommands mPendingInputWindowCommands GUARDED_BY(mStateLock);

    // Should only be accessed by the main thread.

    InputWindowCommands mInputWindowCommands;

services/surfaceflinger/tests/TransactionTestHarnesses.h

+3 −0
Original line number Diff line number Diff line
@@ -68,6 +68,9 @@ public: 
                                       Rect(displayState.layerStackSpaceRect), Rect(resolution));

                t.apply();

                SurfaceComposerClient::Transaction().apply(true);

                // wait for 3 vsyncs to ensure the buffer is latched.

                usleep(static_cast<int32_t>(1e6 / displayConfig.refreshRate) * 3);



                BufferItem item;

                itemConsumer->acquireBuffer(&item, 0, true);

                auto sc = std::make_unique<ScreenCapture>(item.mGraphicBuffer);

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+2 −2
Original line number Diff line number Diff line
@@ -346,7 +346,7 @@ public: 
        return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);

    }



    auto& getTransactionQueue() { return mFlinger->mTransactionQueues; }

    auto& getPendingTransactionQueue() { return mFlinger->mPendingTransactionQueues; }



    auto setTransactionState(const Vector<ComposerState>& states,

                             const Vector<DisplayState>& displays, uint32_t flags,
@@ -360,7 +360,7 @@ public: 
                                             hasListenerCallbacks, listenerCallbacks);

    }



    auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(); };

    auto flushPendingTransactionQueues() { return mFlinger->flushPendingTransactionQueues(); };



    auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {

        return mFlinger->onTransact(code, data, reply, flags);

services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp

+10 −10
Original line number Diff line number Diff line
@@ -122,7 +122,7 @@ public: 
    }



    void NotPlacedOnTransactionQueue(uint32_t flags, bool syncInputWindows) {

        ASSERT_EQ(0, mFlinger.getTransactionQueue().size());

        ASSERT_EQ(0, mFlinger.getPendingTransactionQueue().size());

        // called in SurfaceFlinger::signalTransaction

        EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);

        EXPECT_CALL(*mVSyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillOnce(Return(systemTime()));
@@ -146,12 +146,12 @@ public: 
        } else {

            EXPECT_LE(returnedTime, applicationTime + s2ns(5));

        }

        auto transactionQueue = mFlinger.getTransactionQueue();

        auto transactionQueue = mFlinger.getPendingTransactionQueue();

        EXPECT_EQ(0, transactionQueue.size());

    }



    void PlaceOnTransactionQueue(uint32_t flags, bool syncInputWindows) {

        ASSERT_EQ(0, mFlinger.getTransactionQueue().size());

        ASSERT_EQ(0, mFlinger.getPendingTransactionQueue().size());

        // called in SurfaceFlinger::signalTransaction

        EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
@@ -172,12 +172,12 @@ public: 
        nsecs_t returnedTime = systemTime();

        EXPECT_LE(returnedTime, applicationSentTime + s2ns(5));

        // This transaction should have been placed on the transaction queue

        auto transactionQueue = mFlinger.getTransactionQueue();

        auto transactionQueue = mFlinger.getPendingTransactionQueue();

        EXPECT_EQ(1, transactionQueue.size());

    }



    void BlockedByPriorTransaction(uint32_t flags, bool syncInputWindows) {

        ASSERT_EQ(0, mFlinger.getTransactionQueue().size());

        ASSERT_EQ(0, mFlinger.getPendingTransactionQueue().size());

        // called in SurfaceFlinger::signalTransaction

        nsecs_t time = systemTime();

        EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
@@ -222,7 +222,7 @@ public: 
        }



        // check that there is one binder on the pending queue.

        auto transactionQueue = mFlinger.getTransactionQueue();

        auto transactionQueue = mFlinger.getPendingTransactionQueue();

        EXPECT_EQ(1, transactionQueue.size());



        auto& [applyToken, transactionStates] = *(transactionQueue.begin());
@@ -241,7 +241,7 @@ public: 
};



TEST_F(TransactionApplicationTest, Flush_RemovesFromQueue) {

    ASSERT_EQ(0, mFlinger.getTransactionQueue().size());

    ASSERT_EQ(0, mFlinger.getPendingTransactionQueue().size());

    // called in SurfaceFlinger::signalTransaction

    EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
@@ -257,7 +257,7 @@ TEST_F(TransactionApplicationTest, Flush_RemovesFromQueue) { 
                                 transactionA.desiredPresentTime, transactionA.uncacheBuffer,

                                 mHasListenerCallbacks, mCallbacks);



    auto& transactionQueue = mFlinger.getTransactionQueue();

    auto& transactionQueue = mFlinger.getPendingTransactionQueue();

    ASSERT_EQ(1, transactionQueue.size());



    auto& [applyToken, transactionStates] = *(transactionQueue.begin());
@@ -275,9 +275,9 @@ TEST_F(TransactionApplicationTest, Flush_RemovesFromQueue) { 
                                 empty.inputWindowCommands, empty.desiredPresentTime,

                                 empty.uncacheBuffer, mHasListenerCallbacks, mCallbacks);



    // flush transaction queue should flush as desiredPresentTime has

    // flush pending transaction queue should flush as desiredPresentTime has

    // passed

    mFlinger.flushTransactionQueues();

    mFlinger.flushPendingTransactionQueues();



    EXPECT_EQ(0, transactionQueue.size());

}