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

Commit 5f319778 authored by Vishnu Nair's avatar Vishnu Nair
Browse files

Reland Consolidate flags in Transaction 

Change-Id: Iba3ee1b4dd1765d70f9d26ef84ec8fb9156430e9
Flag: EXEMPT refactor
Bug: 385156191
Test: presubmit
parent 8d77b229

libs/gui/SurfaceComposerClient.cpp

+15 −33
Original line number Diff line number Diff line
@@ -829,9 +829,7 @@ SurfaceComposerClient::Transaction::Transaction() { 


SurfaceComposerClient::Transaction::Transaction(const Transaction& other)

      : mId(other.mId),

        mAnimation(other.mAnimation),

        mEarlyWakeupStart(other.mEarlyWakeupStart),

        mEarlyWakeupEnd(other.mEarlyWakeupEnd),

        mFlags(other.mFlags),

        mMayContainBuffer(other.mMayContainBuffer),

        mDesiredPresentTime(other.mDesiredPresentTime),

        mIsAutoTimestamp(other.mIsAutoTimestamp),
@@ -868,9 +866,7 @@ SurfaceComposerClient::Transaction::createFromParcel(const Parcel* parcel) { 


status_t SurfaceComposerClient::Transaction::readFromParcel(const Parcel* parcel) {

    const uint64_t transactionId = parcel->readUint64();

    const bool animation = parcel->readBool();

    const bool earlyWakeupStart = parcel->readBool();

    const bool earlyWakeupEnd = parcel->readBool();

    const uint32_t flags = parcel->readUint32();

    const int64_t desiredPresentTime = parcel->readInt64();

    const bool isAutoTimestamp = parcel->readBool();

    const bool logCallPoints = parcel->readBool();
@@ -965,9 +961,7 @@ status_t SurfaceComposerClient::Transaction::readFromParcel(const Parcel* parcel 


    // Parsing was successful. Update the object.

    mId = transactionId;

    mAnimation = animation;

    mEarlyWakeupStart = earlyWakeupStart;

    mEarlyWakeupEnd = earlyWakeupEnd;

    mFlags = flags;

    mDesiredPresentTime = desiredPresentTime;

    mIsAutoTimestamp = isAutoTimestamp;

    mFrameTimelineInfo = frameTimelineInfo;
@@ -996,9 +990,7 @@ status_t SurfaceComposerClient::Transaction::writeToParcel(Parcel* parcel) const 
    const_cast<SurfaceComposerClient::Transaction*>(this)->cacheBuffers();



    parcel->writeUint64(mId);

    parcel->writeBool(mAnimation);

    parcel->writeBool(mEarlyWakeupStart);

    parcel->writeBool(mEarlyWakeupEnd);

    parcel->writeUint32(mFlags);

    parcel->writeInt64(mDesiredPresentTime);

    parcel->writeBool(mIsAutoTimestamp);

    parcel->writeBool(mLogCallPoints);
@@ -1131,8 +1123,7 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::merge(Tr 
    mInputWindowCommands.merge(other.mInputWindowCommands);



    mMayContainBuffer |= other.mMayContainBuffer;

    mEarlyWakeupStart = mEarlyWakeupStart || other.mEarlyWakeupStart;

    mEarlyWakeupEnd = mEarlyWakeupEnd || other.mEarlyWakeupEnd;

    mFlags |= other.mFlags;

    mApplyToken = other.mApplyToken;



    mergeFrameTimelineInfo(mFrameTimelineInfo, other.mFrameTimelineInfo);
@@ -1154,15 +1145,13 @@ void SurfaceComposerClient::Transaction::clear() { 
    mInputWindowCommands.clear();

    mUncacheBuffers.clear();

    mMayContainBuffer = false;

    mAnimation = false;

    mEarlyWakeupStart = false;

    mEarlyWakeupEnd = false;

    mDesiredPresentTime = 0;

    mIsAutoTimestamp = true;

    mFrameTimelineInfo = {};

    mApplyToken = nullptr;

    mMergedTransactionIds.clear();

    mLogCallPoints = false;

    mFlags = 0;

}



uint64_t SurfaceComposerClient::Transaction::getId() {
@@ -1325,7 +1314,6 @@ status_t SurfaceComposerClient::Transaction::apply(bool synchronous, bool oneWay 


    Vector<ComposerState> composerStates;

    Vector<DisplayState> displayStates;

    uint32_t flags = 0;



    for (auto const& kv : mComposerStates) {

        composerStates.add(kv.second);
@@ -1333,32 +1321,26 @@ status_t SurfaceComposerClient::Transaction::apply(bool synchronous, bool oneWay 


    displayStates = std::move(mDisplayStates);



    if (mAnimation) {

        flags |= ISurfaceComposer::eAnimation;

    }

    if (oneWay) {

        if (synchronous) {

            ALOGE("Transaction attempted to set synchronous and one way at the same time"

                  " this is an invalid request. Synchronous will win for safety");

        } else {

            flags |= ISurfaceComposer::eOneWay;

            mFlags |= ISurfaceComposer::eOneWay;

        }

    }



    // If both mEarlyWakeupStart and mEarlyWakeupEnd are set

    // If both ISurfaceComposer::eEarlyWakeupStart and ISurfaceComposer::eEarlyWakeupEnd are set

    // it is equivalent for none

    if (mEarlyWakeupStart && !mEarlyWakeupEnd) {

        flags |= ISurfaceComposer::eEarlyWakeupStart;

    }

    if (mEarlyWakeupEnd && !mEarlyWakeupStart) {

        flags |= ISurfaceComposer::eEarlyWakeupEnd;

    uint32_t wakeupFlags = ISurfaceComposer::eEarlyWakeupStart | ISurfaceComposer::eEarlyWakeupEnd;

    if ((mFlags & wakeupFlags) == wakeupFlags) {

        mFlags &= ~(wakeupFlags);

    }



    sp<IBinder> applyToken = mApplyToken ? mApplyToken : getDefaultApplyToken();



    sp<ISurfaceComposer> sf(ComposerService::getComposerService());

    status_t binderStatus =

            sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, flags,

            sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, mFlags,

                                    applyToken, mInputWindowCommands, mDesiredPresentTime,

                                    mIsAutoTimestamp, mUncacheBuffers, hasListenerCallbacks,

                                    listenerCallbacks, mId, mMergedTransactionIds);
@@ -1461,15 +1443,15 @@ std::optional<gui::StalledTransactionInfo> SurfaceComposerClient::getStalledTran 
}



void SurfaceComposerClient::Transaction::setAnimationTransaction() {

    mAnimation = true;

    mFlags |= ISurfaceComposer::eAnimation;

}



void SurfaceComposerClient::Transaction::setEarlyWakeupStart() {

    mEarlyWakeupStart = true;

    mFlags |= ISurfaceComposer::eEarlyWakeupStart;

}



void SurfaceComposerClient::Transaction::setEarlyWakeupEnd() {

    mEarlyWakeupEnd = true;

    mFlags |= ISurfaceComposer::eEarlyWakeupEnd;

}



layer_state_t* SurfaceComposerClient::Transaction::getLayerState(const sp<SurfaceControl>& sc) {

libs/gui/include/gui/SurfaceComposerClient.h

+1 −4
Original line number Diff line number Diff line
@@ -467,10 +467,7 @@ public: 
        std::vector<uint64_t> mMergedTransactionIds;



        uint64_t mId;



        bool mAnimation = false;

        bool mEarlyWakeupStart = false;

        bool mEarlyWakeupEnd = false;

        uint32_t mFlags = 0;



        // Indicates that the Transaction may contain buffers that should be cached. The reason this

        // is only a guess is that buffers can be removed before cache is called. This is only a