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

Commit 787d302b authored by Melody Hsu's avatar Melody Hsu Committed by Android (Google) Code Review
Browse files

Revert "Refactor of screenshot code on main thread." 

This reverts commit b43b5837.

Reason for revert: Appstartup regression found in b/327488235

Change-Id: I8d975b81afd2cde1d543e8bc7e730a6e42393bec
parent b43b5837

services/surfaceflinger/RegionSamplingThread.cpp

+2 −2
Original line number Diff line number Diff line
@@ -377,7 +377,7 @@ void RegionSamplingThread::captureSample() { 
    constexpr bool kIsProtected = false;



    if (const auto fenceResult =

                mFlinger.captureScreenshot(std::move(renderAreaFuture), getLayerSnapshots, buffer,

                mFlinger.captureScreenCommon(std::move(renderAreaFuture), getLayerSnapshots, buffer,

                                             kRegionSampling, kGrayscale, kIsProtected, nullptr)

                        .get();

        fenceResult.ok()) {

services/surfaceflinger/SurfaceFlinger.cpp

+49 −55
Original line number Diff line number Diff line
@@ -8040,19 +8040,6 @@ void SurfaceFlinger::captureLayers(const LayerCaptureArgs& args, 
                        args.allowProtected, args.grayscale, captureListener);

}



bool SurfaceFlinger::layersHasProtectedLayer(

        const std::vector<std::pair<Layer*, sp<LayerFE>>>& layers) const {

    bool protectedLayerFound = false;

    for (auto& [_, layerFe] : layers) {

        protectedLayerFound |=

                (layerFe->mSnapshot->isVisible && layerFe->mSnapshot->hasProtectedContent);

        if (protectedLayerFound) {

            break;

        }

    }

    return protectedLayerFound;

}



void SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture,

                                         GetLayerSnapshotsFunction getLayerSnapshots,

                                         ui::Size bufferSize, ui::PixelFormat reqPixelFormat,
@@ -8068,9 +8055,6 @@ void SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture, 
        return;

    }



    // Snapshots must be taken from the main thread.

    auto layers = mScheduler->schedule([=]() { return getLayerSnapshots(); }).get();



    // Loop over all visible layers to see whether there's any protected layer. A protected layer is

    // typically a layer with DRM contents, or have the GRALLOC_USAGE_PROTECTED set on the buffer.

    // A protected layer has no implication on whether it's secure, which is explicitly set by
@@ -8078,7 +8062,18 @@ void SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture, 
    const bool supportsProtected = getRenderEngine().supportsProtectedContent();

    bool hasProtectedLayer = false;

    if (allowProtected && supportsProtected) {

        hasProtectedLayer = layersHasProtectedLayer(layers);

        hasProtectedLayer = mScheduler

                                    ->schedule([=]() {

                                        bool protectedLayerFound = false;

                                        auto layers = getLayerSnapshots();

                                        for (auto& [_, layerFe] : layers) {

                                            protectedLayerFound |=

                                                    (layerFe->mSnapshot->isVisible &&

                                                     layerFe->mSnapshot->hasProtectedContent);

                                        }

                                        return protectedLayerFound;

                                    })

                                    .get();

    }

    const bool isProtected = hasProtectedLayer && allowProtected && supportsProtected;

    const uint32_t usage = GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_RENDER |
@@ -8103,19 +8098,20 @@ void SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture, 
            renderengine::impl::ExternalTexture>(buffer, getRenderEngine(),

                                                 renderengine::impl::ExternalTexture::Usage::

                                                         WRITEABLE);

    auto futureFence =

            captureScreenshot(std::move(renderAreaFuture), getLayerSnapshots, texture,

                              false /* regionSampling */, grayscale, isProtected, captureListener);

    futureFence.get();

    auto fence = captureScreenCommon(std::move(renderAreaFuture), getLayerSnapshots, texture,

                                     false /* regionSampling */, grayscale, isProtected,

                                     captureListener);

    fence.get();

}



ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenshot(

ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenCommon(

        RenderAreaFuture renderAreaFuture, GetLayerSnapshotsFunction getLayerSnapshots,

        const std::shared_ptr<renderengine::ExternalTexture>& buffer, bool regionSampling,

        bool grayscale, bool isProtected, const sp<IScreenCaptureListener>& captureListener) {

    ATRACE_CALL();



    auto takeScreenshotFn = [=, this, renderAreaFuture = std::move(renderAreaFuture)]() REQUIRES(

    auto future = mScheduler->schedule(

            [=, this, renderAreaFuture = std::move(renderAreaFuture)]() FTL_FAKE_GUARD(

                    kMainThreadContext) mutable -> ftl::SharedFuture<FenceResult> {

                ScreenCaptureResults captureResults;

                std::shared_ptr<RenderArea> renderArea = renderAreaFuture.get();
@@ -8130,7 +8126,8 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenshot( 


                ftl::SharedFuture<FenceResult> renderFuture;

                renderArea->render([&]() FTL_FAKE_GUARD(kMainThreadContext) {

            renderFuture = renderScreenImpl(renderArea, getLayerSnapshots, buffer, regionSampling,

                    renderFuture =

                            renderScreenImpl(renderArea, getLayerSnapshots, buffer, regionSampling,

                                             grayscale, isProtected, captureResults);

                });
@@ -8146,10 +8143,7 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenshot( 
                            .share();

                }

                return renderFuture;

    };



    auto future =

            mScheduler->schedule(FTL_FAKE_GUARD(kMainThreadContext, std::move(takeScreenshotFn)));

            });



    // Flatten nested futures.

    auto chain = ftl::Future(std::move(future)).then([](ftl::SharedFuture<FenceResult> future) {

services/surfaceflinger/SurfaceFlinger.h

+1 −5
Original line number Diff line number Diff line
@@ -874,17 +874,13 @@ private: 
    // Boot animation, on/off animations and screen capture

    void startBootAnim();



    bool layersHasProtectedLayer(const std::vector<std::pair<Layer*, sp<LayerFE>>>& layers) const;



    void captureScreenCommon(RenderAreaFuture, GetLayerSnapshotsFunction, ui::Size bufferSize,

                             ui::PixelFormat, bool allowProtected, bool grayscale,

                             const sp<IScreenCaptureListener>&);



    ftl::SharedFuture<FenceResult> captureScreenshot(

    ftl::SharedFuture<FenceResult> captureScreenCommon(

            RenderAreaFuture, GetLayerSnapshotsFunction,

            const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,

            bool grayscale, bool isProtected, const sp<IScreenCaptureListener>&);



    ftl::SharedFuture<FenceResult> renderScreenImpl(

            std::shared_ptr<const RenderArea>, GetLayerSnapshotsFunction,

            const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,