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

Commit 16c4c32c authored by Melody Hsu's avatar Melody Hsu
Browse files

Remove flag single_hop_screenshots 

Flag has been rolled out for several months and is safe to
remove along with any legacy methods and dead code.

Bug: b/351894825
Test: atest SurfaceFlinger_test
Flag: EXEMPT flag removal
Change-Id: Id6fdfc534a0bff6ff9dfb8727c08ff821bc4965a
parent 0b80c743

services/surfaceflinger/RegionSamplingThread.cpp

+7 −15
Original line number Diff line number Diff line
@@ -353,21 +353,13 @@ void RegionSamplingThread::captureSample() { 
                              sampledBounds.getSize(), ui::Dataspace::V0_SRGB, displayWeak,

                              RenderArea::Options::CAPTURE_SECURE_LAYERS);



    FenceResult fenceResult;

    if (FlagManager::getInstance().single_hop_screenshot()) {

    std::vector<std::pair<Layer*, sp<LayerFE>>> layers;

    auto displayState =

            mFlinger.getSnapshotsFromMainThread(renderAreaBuilder, getLayerSnapshotsFn, layers);

        fenceResult = mFlinger.captureScreenshot(renderAreaBuilder, buffer, kRegionSampling,

                                                 kGrayscale, kIsProtected, kAttachGainmap, nullptr,

                                                 displayState, layers)

    FenceResult fenceResult =

            mFlinger.captureScreenshot(renderAreaBuilder, buffer, kRegionSampling, kGrayscale,

                                       kIsProtected, kAttachGainmap, nullptr, displayState, layers)

                    .get();

    } else {

        fenceResult = mFlinger.captureScreenshotLegacy(renderAreaBuilder, getLayerSnapshotsFn,

                                                       buffer, kRegionSampling, kGrayscale,

                                                       kIsProtected, kAttachGainmap, nullptr)

                              .get();

    }

    if (fenceResult.ok()) {

        fenceResult.value()->waitForever(LOG_TAG);

    }

services/surfaceflinger/SurfaceFlinger.cpp

+41 −143
Original line number Diff line number Diff line
@@ -7212,10 +7212,8 @@ void SurfaceFlinger::captureScreenCommon(RenderAreaBuilderVariant renderAreaBuil 
        return;

    }



    if (FlagManager::getInstance().single_hop_screenshot()) {

    std::vector<std::pair<Layer*, sp<LayerFE>>> layers;

        auto displayState =

                getSnapshotsFromMainThread(renderAreaBuilder, getLayerSnapshotsFn, layers);

    auto displayState = getSnapshotsFromMainThread(renderAreaBuilder, getLayerSnapshotsFn, layers);



    const bool supportsProtected = getRenderEngine().supportsProtectedContent();

    bool hasProtectedLayer = false;
@@ -7245,46 +7243,10 @@ void SurfaceFlinger::captureScreenCommon(RenderAreaBuilderVariant renderAreaBuil 
            renderengine::impl::ExternalTexture>(buffer, getRenderEngine(),

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

                                                         WRITEABLE);

        auto futureFence = captureScreenshot(renderAreaBuilder, texture, false /* regionSampling */,

                                             grayscale, isProtected, attachGainmap, captureListener,

                                             displayState, layers);

    auto futureFence =

            captureScreenshot(renderAreaBuilder, texture, false /* regionSampling */, grayscale,

                              isProtected, attachGainmap, captureListener, displayState, layers);

    futureFence.get();



    } else {

        const bool supportsProtected = getRenderEngine().supportsProtectedContent();

        bool hasProtectedLayer = false;

        if (allowProtected && supportsProtected) {

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

            hasProtectedLayer = layersHasProtectedLayer(layers);

        }

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

        const uint32_t usage = GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_RENDER |

                GRALLOC_USAGE_HW_TEXTURE |

                (isProtected ? GRALLOC_USAGE_PROTECTED

                             : GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);

        sp<GraphicBuffer> buffer =

                getFactory().createGraphicBuffer(bufferSize.getWidth(), bufferSize.getHeight(),

                                                 static_cast<android_pixel_format>(reqPixelFormat),

                                                 1 /* layerCount */, usage, "screenshot");



        const status_t bufferStatus = buffer->initCheck();

        if (bufferStatus != OK) {

            // Animations may end up being really janky, but don't crash here.

            // Otherwise an irreponsible process may cause an SF crash by allocating

            // too much.

            ALOGE("%s: Buffer failed to allocate: %d", __func__, bufferStatus);

            invokeScreenCaptureError(bufferStatus, captureListener);

            return;

        }

        const std::shared_ptr<renderengine::ExternalTexture> texture = std::make_shared<

                renderengine::impl::ExternalTexture>(buffer, getRenderEngine(),

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

                                                             WRITEABLE);

        auto futureFence = captureScreenshotLegacy(renderAreaBuilder, getLayerSnapshotsFn, texture,

                                                   false /* regionSampling */, grayscale,

                                                   isProtected, attachGainmap, captureListener);

        futureFence.get();

    }

}



std::optional<SurfaceFlinger::OutputCompositionState>
@@ -7350,7 +7312,7 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenshot( 


    ftl::SharedFuture<FenceResult> renderFuture =

            renderScreenImpl(renderArea.get(), buffer, regionSampling, grayscale, isProtected,

                             attachGainmap, captureResults, displayState, layers);

                             captureResults, displayState, layers);



    if (captureResults.capturedHdrLayers && attachGainmap &&

        FlagManager::getInstance().true_hdr_screenshots()) {
@@ -7385,8 +7347,7 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenshot( 
            ScreenCaptureResults unusedResults;

            ftl::SharedFuture<FenceResult> hdrRenderFuture =

                    renderScreenImpl(renderArea.get(), hdrTexture, regionSampling, grayscale,

                                     isProtected, attachGainmap, unusedResults, displayState,

                                     layers);

                                     isProtected, unusedResults, displayState, layers);



            renderFuture =

                    ftl::Future(std::move(renderFuture))
@@ -7432,67 +7393,10 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenshot( 
    return renderFuture;

}



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

        RenderAreaBuilderVariant renderAreaBuilder, GetLayerSnapshotsFunction getLayerSnapshotsFn,

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

        bool grayscale, bool isProtected, bool attachGainmap,

        const sp<IScreenCaptureListener>& captureListener) {

    SFTRACE_CALL();



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

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

        auto layers = getLayerSnapshotsFn();

        auto displayState = getDisplayStateFromRenderAreaBuilder(renderAreaBuilder);



        ScreenCaptureResults captureResults;

        std::unique_ptr<const RenderArea> renderArea =

                std::visit([](auto&& arg) -> std::unique_ptr<RenderArea> { return arg.build(); },

                           renderAreaBuilder);



        if (!renderArea) {

            ALOGW("Skipping screen capture because of invalid render area.");

            if (captureListener) {

                captureResults.fenceResult = base::unexpected(NO_MEMORY);

                captureListener->onScreenCaptureCompleted(captureResults);

            }

            return ftl::yield<FenceResult>(base::unexpected(NO_ERROR)).share();

        }



        ftl::SharedFuture<FenceResult> renderFuture =

                renderScreenImpl(renderArea.get(), buffer, regionSampling, grayscale, isProtected,

                                 attachGainmap, captureResults, displayState, layers);



        if (captureListener) {

            // Defer blocking on renderFuture back to the Binder thread.

            return ftl::Future(std::move(renderFuture))

                    .then([captureListener, captureResults = std::move(captureResults)](

                                  FenceResult fenceResult) mutable -> FenceResult {

                        captureResults.fenceResult = std::move(fenceResult);

                        captureListener->onScreenCaptureCompleted(captureResults);

                        return base::unexpected(NO_ERROR);

                    })

                    .share();

        }

        return renderFuture;

    };



    // TODO(b/294936197): Run takeScreenshotsFn() in a binder thread to reduce the number

    // of calls on the main thread.

    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) {

        return future;

    });



    return chain.share();

}



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

        const RenderArea* renderArea, const std::shared_ptr<renderengine::ExternalTexture>& buffer,

        bool regionSampling, bool grayscale, bool isProtected, bool attachGainmap,

        ScreenCaptureResults& captureResults, std::optional<OutputCompositionState>& displayState,

        bool regionSampling, bool grayscale, bool isProtected, ScreenCaptureResults& captureResults,

        std::optional<OutputCompositionState>& displayState,

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

    SFTRACE_CALL();
@@ -7638,15 +7542,9 @@ ftl::SharedFuture<FenceResult> SurfaceFlinger::renderScreenImpl( 
    //

    // TODO(b/196334700) Once we use RenderEngineThreaded everywhere we can always defer the call

    // to CompositionEngine::present.

    ftl::SharedFuture<FenceResult> presentFuture;

    if (FlagManager::getInstance().single_hop_screenshot()) {

        presentFuture = mRenderEngine->isThreaded()

    ftl::SharedFuture<FenceResult> presentFuture = mRenderEngine->isThreaded()

            ? ftl::yield(present()).share()

            : mScheduler->schedule(std::move(present)).share();

    } else {

        presentFuture = mRenderEngine->isThreaded() ? ftl::defer(std::move(present)).share()

                                                    : ftl::yield(present()).share();

    }



    return presentFuture;

}

services/surfaceflinger/SurfaceFlinger.h

+2 −8
Original line number Diff line number Diff line
@@ -875,16 +875,10 @@ private: 
            std::optional<OutputCompositionState>& displayState,

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



    ftl::SharedFuture<FenceResult> captureScreenshotLegacy(

            RenderAreaBuilderVariant, GetLayerSnapshotsFunction,

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

            bool grayscale, bool isProtected, bool attachGainmap,

            const sp<IScreenCaptureListener>&);



    ftl::SharedFuture<FenceResult> renderScreenImpl(

            const RenderArea*, const std::shared_ptr<renderengine::ExternalTexture>&,

            bool regionSampling, bool grayscale, bool isProtected, bool attachGainmap,

            ScreenCaptureResults&, std::optional<OutputCompositionState>& displayState,

            bool regionSampling, bool grayscale, bool isProtected, ScreenCaptureResults&,

            std::optional<OutputCompositionState>& displayState,

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



    void readPersistentProperties();

services/surfaceflinger/common/FlagManager.cpp

+0 −2
Original line number Diff line number Diff line
@@ -153,7 +153,6 @@ void FlagManager::dump(std::string& result) const { 
    DUMP_READ_ONLY_FLAG(override_trusted_overlay);

    DUMP_READ_ONLY_FLAG(flush_buffer_slots_to_uncache);

    DUMP_READ_ONLY_FLAG(force_compile_graphite_renderengine);

    DUMP_READ_ONLY_FLAG(single_hop_screenshot);

    DUMP_READ_ONLY_FLAG(trace_frame_rate_override);

    DUMP_READ_ONLY_FLAG(true_hdr_screenshots);

    DUMP_READ_ONLY_FLAG(display_config_error_hal);
@@ -259,7 +258,6 @@ FLAG_MANAGER_READ_ONLY_FLAG(local_tonemap_screenshots, "debug.sf.local_tonemap_s 
FLAG_MANAGER_READ_ONLY_FLAG(override_trusted_overlay, "");

FLAG_MANAGER_READ_ONLY_FLAG(flush_buffer_slots_to_uncache, "");

FLAG_MANAGER_READ_ONLY_FLAG(force_compile_graphite_renderengine, "");

FLAG_MANAGER_READ_ONLY_FLAG(single_hop_screenshot, "");

FLAG_MANAGER_READ_ONLY_FLAG(true_hdr_screenshots, "debug.sf.true_hdr_screenshots");

FLAG_MANAGER_READ_ONLY_FLAG(display_config_error_hal, "");

services/surfaceflinger/common/include/common/FlagManager.h

+0 −1
Original line number Diff line number Diff line
@@ -91,7 +91,6 @@ public: 
    bool override_trusted_overlay() const;

    bool flush_buffer_slots_to_uncache() const;

    bool force_compile_graphite_renderengine() const;

    bool single_hop_screenshot() const;

    bool trace_frame_rate_override() const;

    bool true_hdr_screenshots() const;

    bool display_config_error_hal() const;