Merge "Use ScreenCaptureResults in screenCapture helper functions" (0ed43f57) · Commits · e / os / platform_frameworks_native

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,