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

Commit 8c24eb66 authored by Vishnu Nair's avatar Vishnu Nair
Browse files

Remove legacy snapshot updates 

Flag: EXEMPT (removing old flags)
Bug: 330785038
Test: presubmit
Change-Id: I1363277c29a09aaba8d06ec0bf1edf912c2c8037
parent 6aac09ec

services/surfaceflinger/SurfaceFlinger.cpp

+0 −635

File changed.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/SurfaceFlinger.h

+0 −32
Original line number Diff line number Diff line
@@ -313,7 +313,6 @@ public: 
    // Disables expensive rendering for all displays

    // This is scheduled on the main thread

    void disableExpensiveRendering();

    FloatRect getMaxDisplayBounds();



    // If set, composition engine tries to predict the composition strategy provided by HWC

    // based on the previous frame. If the strategy can be predicted, gpu composition will
@@ -764,16 +763,11 @@ private: 
                                            const scheduler::RefreshRateSelector&)

            REQUIRES(mStateLock, kMainThreadContext);



    void commitTransactionsLegacy() EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);

    void commitTransactions() REQUIRES(kMainThreadContext, mStateLock);

    void commitTransactionsLocked(uint32_t transactionFlags)

            REQUIRES(mStateLock, kMainThreadContext);

    void doCommitTransactions() REQUIRES(mStateLock);



    // Returns whether a new buffer has been latched.

    bool latchBuffers();



    void updateLayerGeometry();

    void updateLayerMetadataSnapshot();

    std::vector<std::pair<Layer*, LayerFE*>> moveSnapshotsToCompositionArgs(

            compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly)
@@ -782,13 +776,9 @@ private: 
                                          const std::vector<std::pair<Layer*, LayerFE*>>& layers)

            REQUIRES(kMainThreadContext);

    // Return true if we must composite this frame

    bool updateLayerSnapshotsLegacy(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,

                                    bool& out) REQUIRES(kMainThreadContext);

    // Return true if we must composite this frame

    bool updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,

                              bool& out) REQUIRES(kMainThreadContext);

    void updateLayerHistory(nsecs_t now) REQUIRES(kMainThreadContext);

    frontend::Update flushLifecycleUpdates() REQUIRES(kMainThreadContext);



    void updateInputFlinger(VsyncId vsyncId, TimePoint frameTime) REQUIRES(kMainThreadContext);

    void persistDisplayBrightness(bool needsComposite) REQUIRES(kMainThreadContext);
@@ -834,9 +824,6 @@ private: 
            const TransactionHandler::TransactionFlushState& flushState)

            REQUIRES(kMainThreadContext);



    uint32_t setClientStateLocked(const FrameTimelineInfo&, ResolvedComposerState&,

                                  int64_t desiredPresentTime, bool isAutoTimestamp,

                                  int64_t postTime, uint64_t transactionId) REQUIRES(mStateLock);

    uint32_t updateLayerCallbacksAndStats(const FrameTimelineInfo&, ResolvedComposerState&,

                                          int64_t desiredPresentTime, bool isAutoTimestamp,

                                          int64_t postTime, uint64_t transactionId)
@@ -886,9 +873,6 @@ private: 
                            const sp<Layer>& layer, const wp<Layer>& parentLayer,

                            uint32_t* outTransformHint);



    // Traverse through all the layers and compute and cache its bounds.

    void computeLayerBounds();



    // Creates a promise for a future release fence for a layer. This allows for

    // the layer to keep track of when its buffer can be released.

    void attachReleaseFenceFutureToLayer(Layer* layer, LayerFE* layerFE, ui::LayerStack layerStack);
@@ -1311,8 +1295,6 @@ private: 
    std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithBuffersRemoved;

    std::unordered_set<uint32_t> mLayersIdsWithQueuedFrames;



    // Tracks layers that need to update a display's dirty region.

    std::vector<sp<Layer>> mLayersPendingRefresh;

    // Sorted list of layers that were composed during previous frame. This is used to

    // avoid an expensive traversal of the layer hierarchy when there are no

    // visible region changes. Because this is a list of strong pointers, this will
@@ -1457,22 +1439,8 @@ private: 
    // A temporay pool that store the created layers and will be added to current state in main

    // thread.

    std::vector<LayerCreatedState> mCreatedLayers GUARDED_BY(mCreatedLayersLock);

    bool commitCreatedLayers(VsyncId, std::vector<LayerCreatedState>& createdLayers);

    void handleLayerCreatedLocked(const LayerCreatedState&, VsyncId) REQUIRES(mStateLock);



    mutable std::mutex mMirrorDisplayLock;

    struct MirrorDisplayState {

        MirrorDisplayState(ui::LayerStack layerStack, sp<IBinder>& rootHandle,

                           const sp<Client>& client)

              : layerStack(layerStack), rootHandle(rootHandle), client(client) {}



        ui::LayerStack layerStack;

        sp<IBinder> rootHandle;

        const sp<Client> client;

    };

    std::vector<MirrorDisplayState> mMirrorDisplays GUARDED_BY(mMirrorDisplayLock);

    bool commitMirrorDisplays(VsyncId);



    std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;



    // Must only be accessed on the main thread.