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

Commit 426b5c0c authored by chaviw's avatar chaviw
Browse files

Use ScreenCaptureResults in screenCapture helper functions 

It makes more sense to directly send the ScreenCaptureResults object to
the screenCapture helper functions so the render function can populate
the results. This makes it easier when adding new result values since
they likely want to be set for any screenshot path request.

Currently, the result object contains the buffer, whether secure layers
were captured, and the dataspace it was captured in.

Test: SurfaceFlinger_test
Bug: 162367424
Change-Id: I3b1f5264051bb2e885ce0d0df0cd18c8f55afdd1
parent b71b0625

services/surfaceflinger/RegionSamplingThread.cpp

+3 −2
Original line number Diff line number Diff line
@@ -442,9 +442,10 @@ void RegionSamplingThread::captureSample() { 
                                   PIXEL_FORMAT_RGBA_8888, 1, usage, "RegionSamplingThread");

    }



    bool ignored;

    ScreenCaptureResults captureResults;

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

                                 false /* identityTransform */, true /* regionSampling */, ignored);

                                 false /* identityTransform */, true /* regionSampling */,

                                 captureResults);



    std::vector<Descriptor> activeDescriptors;

    for (const auto& descriptor : descriptors) {

services/surfaceflinger/SurfaceFlinger.cpp

+40 −52
Original line number Diff line number Diff line
@@ -5482,11 +5482,8 @@ status_t SurfaceFlinger::captureDisplay(const DisplayCaptureArgs& args, 
    auto traverseLayers = [this, layerStack](const LayerVector::Visitor& visitor) {

        traverseLayersInLayerStack(layerStack, visitor);

    };



    captureResults.capturedDataspace = dataspace;

    return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, reqSize,

                               &captureResults.buffer, args.pixelFormat, args.useIdentityTransform,

                               captureResults.capturedSecureLayers);

                               args.pixelFormat, args.useIdentityTransform, captureResults);

}



status_t SurfaceFlinger::setSchedFifo(bool enabled) {
@@ -5534,6 +5531,7 @@ status_t SurfaceFlinger::captureDisplay(uint64_t displayOrLayerStack, 
    wp<DisplayDevice> displayWeak;

    ui::Size size;

    ui::Transform::RotationFlags captureOrientation;

    ui::Dataspace dataspace;

    {

        Mutex::Autolock lock(mStateLock);

        sp<DisplayDevice> display = getDisplayByIdOrLayerStack(displayOrLayerStack);
@@ -5565,7 +5563,7 @@ status_t SurfaceFlinger::captureDisplay(uint64_t displayOrLayerStack, 
            default:

                break;

        }

        captureResults.capturedDataspace =

        dataspace =

                pickDataspaceFromColorMode(display->getCompositionDisplay()->getState().colorMode);

    }
@@ -5580,9 +5578,8 @@ status_t SurfaceFlinger::captureDisplay(uint64_t displayOrLayerStack, 
    };



    return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, size,

                               &captureResults.buffer, ui::PixelFormat::RGBA_8888,

                               false /* useIdentityTransform */,

                               captureResults.capturedSecureLayers);

                               ui::PixelFormat::RGBA_8888, false /* useIdentityTransform */,

                               captureResults);

}



status_t SurfaceFlinger::captureLayers(const LayerCaptureArgs& args,
@@ -5686,37 +5683,34 @@ status_t SurfaceFlinger::captureLayers(const LayerCaptureArgs& args, 
        });

    };



    captureResults.capturedDataspace = dataspace;

    return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, reqSize,

                               &captureResults.buffer, args.pixelFormat, false,

                               captureResults.capturedSecureLayers);

                               args.pixelFormat, false, captureResults);

}



status_t SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture,

                                             TraverseLayersFunction traverseLayers,

                                             ui::Size bufferSize, sp<GraphicBuffer>* outBuffer,

                                             ui::PixelFormat reqPixelFormat,

                                             ui::Size bufferSize, ui::PixelFormat reqPixelFormat,

                                             bool useIdentityTransform,

                                             bool& outCapturedSecureLayers) {

                                             ScreenCaptureResults& captureResults) {

    ATRACE_CALL();



    // TODO(b/116112787) Make buffer usage a parameter.

    const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |

            GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;

    *outBuffer = getFactory().createGraphicBuffer(bufferSize.getWidth(), bufferSize.getHeight(),

    sp<GraphicBuffer> buffer =

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

                                             static_cast<android_pixel_format>(reqPixelFormat),

                                                  1, usage, "screenshot");

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



    return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, *outBuffer,

                               useIdentityTransform, false /* regionSampling */,

                               outCapturedSecureLayers);

    return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, buffer,

                               useIdentityTransform, false /* regionSampling */, captureResults);

}



status_t SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture,

                                             TraverseLayersFunction traverseLayers,

                                             const sp<GraphicBuffer>& buffer,

                                             bool useIdentityTransform, bool regionSampling,

                                             bool& outCapturedSecureLayers) {

                                             ScreenCaptureResults& captureResults) {

    const int uid = IPCThreadState::self()->getCallingUid();

    const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
@@ -5741,9 +5735,9 @@ status_t SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture, 


                    Mutex::Autolock lock(mStateLock);

                    renderArea->render([&] {

                        result = captureScreenImplLocked(*renderArea, traverseLayers, buffer.get(),

                        result = renderScreenImplLocked(*renderArea, traverseLayers, buffer.get(),

                                                        useIdentityTransform, forSystem, &fd,

                                                         regionSampling, outCapturedSecureLayers);

                                                        regionSampling, captureResults);

                    });



                    return {result, fd};
@@ -5758,13 +5752,30 @@ status_t SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture, 
    return result;

}



void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,

status_t SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,

                                                TraverseLayersFunction traverseLayers,

                                                const sp<GraphicBuffer>& buffer,

                                            bool useIdentityTransform, bool regionSampling,

                                            int* outSyncFd) {

                                                bool useIdentityTransform, bool forSystem,

                                                int* outSyncFd, bool regionSampling,

                                                ScreenCaptureResults& captureResults) {

    ATRACE_CALL();



    traverseLayers([&](Layer* layer) {

        captureResults.capturedSecureLayers =

                captureResults.capturedSecureLayers || (layer->isVisible() && layer->isSecure());

    });



    // We allow the system server to take screenshots of secure layers for

    // use in situations like the Screen-rotation animation and place

    // the impetus on WindowManager to not persist them.

    if (captureResults.capturedSecureLayers && !forSystem) {

        ALOGW("FB is protected: PERMISSION_DENIED");

        return PERMISSION_DENIED;

    }



    captureResults.buffer = buffer;

    captureResults.capturedDataspace = renderArea.getReqDataSpace();



    const auto reqWidth = renderArea.getReqWidth();

    const auto reqHeight = renderArea.getReqHeight();

    const auto sourceCrop = renderArea.getSourceCrop();
@@ -5856,30 +5867,7 @@ void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea, 
            layer->onLayerDisplayed(releaseFence);

        }

    }

}



status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,

                                                 TraverseLayersFunction traverseLayers,

                                                 const sp<GraphicBuffer>& buffer,

                                                 bool useIdentityTransform, bool forSystem,

                                                 int* outSyncFd, bool regionSampling,

                                                 bool& outCapturedSecureLayers) {

    ATRACE_CALL();



    traverseLayers([&](Layer* layer) {

        outCapturedSecureLayers =

                outCapturedSecureLayers || (layer->isVisible() && layer->isSecure());

    });



    // We allow the system server to take screenshots of secure layers for

    // use in situations like the Screen-rotation animation and place

    // the impetus on WindowManager to not persist them.

    if (outCapturedSecureLayers && !forSystem) {

        ALOGW("FB is protected: PERMISSION_DENIED");

        return PERMISSION_DENIED;

    }

    renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, regionSampling,

                           outSyncFd);

    return NO_ERROR;

}

services/surfaceflinger/SurfaceFlinger.h

+9 −11
Original line number Diff line number Diff line
@@ -719,22 +719,20 @@ private: 
    using TraverseLayersFunction = std::function<void(const LayerVector::Visitor&)>;

    using RenderAreaFuture = std::future<std::unique_ptr<RenderArea>>;



    void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,

    status_t renderScreenImplLocked(const RenderArea& renderArea,

                                    TraverseLayersFunction traverseLayers,

                                    const sp<GraphicBuffer>& buffer, bool useIdentityTransform,

                                bool regionSampling, int* outSyncFd);

                                    bool forSystem, int* outSyncFd, bool regionSampling,

                                    ScreenCaptureResults& captureResults);

    status_t captureScreenCommon(RenderAreaFuture, TraverseLayersFunction, ui::Size bufferSize,

                                 sp<GraphicBuffer>* outBuffer, ui::PixelFormat,

                                 bool useIdentityTransform, bool& outCapturedSecureLayers);

                                 ui::PixelFormat, bool useIdentityTransform,

                                 ScreenCaptureResults& captureResults);

    status_t captureScreenCommon(RenderAreaFuture, TraverseLayersFunction, const sp<GraphicBuffer>&,

                                 bool useIdentityTransform, bool regionSampling,

                                 bool& outCapturedSecureLayers);

                                 ScreenCaptureResults& captureResults);

    sp<DisplayDevice> getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) REQUIRES(mStateLock);

    sp<DisplayDevice> getDisplayByLayerStack(uint64_t layerStack) REQUIRES(mStateLock);

    status_t captureScreenImplLocked(const RenderArea& renderArea,

                                     TraverseLayersFunction traverseLayers,

                                     const sp<GraphicBuffer>& buffer, bool useIdentityTransform,

                                     bool forSystem, int* outSyncFd, bool regionSampling,

                                     bool& outCapturedSecureLayers);



    void traverseLayersInLayerStack(ui::LayerStack, const LayerVector::Visitor&);



    sp<StartPropertySetThread> mStartPropertySetThread;

services/surfaceflinger/tests/unittests/CompositionTest.cpp

+2 −3
Original line number Diff line number Diff line
@@ -254,9 +254,8 @@ void CompositionTest::captureScreenComposition() { 


    int fd = -1;

    status_t result =

            mFlinger.captureScreenImplLocked(*renderArea, traverseLayers,

                                             mCaptureScreenBuffer.get(), useIdentityTransform,

                                             forSystem, &fd, regionSampling);

            mFlinger.renderScreenImplLocked(*renderArea, traverseLayers, mCaptureScreenBuffer.get(),

                                            useIdentityTransform, forSystem, &fd, regionSampling);

    if (fd >= 0) {

        close(fd);

    }

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+8 −8
Original line number Diff line number Diff line
@@ -339,14 +339,14 @@ public: 


    auto onMessageReceived(int32_t what) { return mFlinger->onMessageReceived(what, systemTime()); }



    auto captureScreenImplLocked(const RenderArea& renderArea,

    auto renderScreenImplLocked(const RenderArea& renderArea,

                                SurfaceFlinger::TraverseLayersFunction traverseLayers,

                                const sp<GraphicBuffer>& buffer, bool useIdentityTransform,

                                bool forSystem, int* outSyncFd, bool regionSampling) {

        bool ignored;

        return mFlinger->captureScreenImplLocked(renderArea, traverseLayers, buffer,

        ScreenCaptureResults captureResults;

        return mFlinger->renderScreenImplLocked(renderArea, traverseLayers, buffer,

                                                useIdentityTransform, forSystem, outSyncFd,

                                                 regionSampling, ignored);

                                                regionSampling, captureResults);

    }



    auto traverseLayersInLayerStack(ui::LayerStack layerStack,