Merge changes from topic "nullable-timestats" (deffcb44) · Commits · e / os / platform_frameworks_native

libs/renderengine/RenderEngine.cpp

+13 −0

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@
		#include <cutils/properties.h>
		#include <log/log.h>
		#include "gl/GLESRenderEngine.h"
		#include "renderengine/ExternalTexture.h"
		#include "threaded/RenderEngineThreaded.h"

		#include "skia/SkiaGLRenderEngine.h"
		@@ -70,10 +71,22 @@ ftl::Future<FenceResult> RenderEngine::drawLayers(const DisplaySettings& display
		base::unique_fd&& bufferFence) {
		const auto resultPromise = std::make_shared<std::promise<FenceResult>>();
		std::future<FenceResult> resultFuture = resultPromise->get_future();
		updateProtectedContext(layers, buffer);
		drawLayersInternal(std::move(resultPromise), display, layers, buffer, useFramebufferCache,
		std::move(bufferFence));
		return resultFuture;
		}

		void RenderEngine::updateProtectedContext(const std::vector<LayerSettings>& layers,
		const std::shared_ptr<ExternalTexture>& buffer) {
		const bool needsProtectedContext =
		(buffer && (buffer->getUsage() & GRALLOC_USAGE_PROTECTED)) \|\|
		std::any_of(layers.begin(), layers.end(), [](const LayerSettings& layer) {
		const std::shared_ptr<ExternalTexture>& buffer = layer.source.buffer.buffer;
		return buffer && (buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
		});
		useProtectedContext(needsProtectedContext);
		}

		} // namespace renderengine
		} // namespace android

libs/renderengine/gl/GLESRenderEngine.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -61,7 +61,7 @@ public:
		std::future<void> primeCache() override;
		void genTextures(size_t count, uint32_t* names) override;
		void deleteTextures(size_t count, uint32_t const* names) override;
		bool isProtected() const override { return mInProtectedContext; }
		bool isProtected() const { return mInProtectedContext; }
		bool supportsProtectedContent() const override;
		void useProtectedContext(bool useProtectedContext) override;
		void cleanupPostRender() override;

libs/renderengine/include/renderengine/RenderEngine.h

+7 −4

Original line number	Diff line number	Diff line
		@@ -126,12 +126,8 @@ public:
		// ----- BEGIN NEW INTERFACE -----

		// queries that are required to be thread safe
		virtual bool isProtected() const = 0;
		virtual bool supportsProtectedContent() const = 0;

		// Attempt to switch RenderEngine into and out of protectedContext mode
		virtual void useProtectedContext(bool useProtectedContext) = 0;

		// Notify RenderEngine of changes to the dimensions of the active display
		// so that it can configure its internal caches accordingly.
		virtual void onActiveDisplaySizeChanged(ui::Size size) = 0;
		@@ -238,6 +234,13 @@ protected:
		friend class RenderEngineTest_cleanupPostRender_cleansUpOnce_Test;
		const RenderEngineType mRenderEngineType;

		// Update protectedContext mode depending on whether or not any layer has a protected buffer.
		void updateProtectedContext(const std::vector<LayerSettings>&,
		const std::shared_ptr<ExternalTexture>&);

		// Attempt to switch RenderEngine into and out of protectedContext mode
		virtual void useProtectedContext(bool useProtectedContext) = 0;

		virtual void drawLayersInternal(
		const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
		const DisplaySettings& display, const std::vector<LayerSettings>& layers,

libs/renderengine/skia/SkiaRenderEngine.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -68,7 +68,6 @@ public:
		std::future<void> primeCache() override final;
		void cleanupPostRender() override final;
		void cleanFramebufferCache() override final{ }
		bool isProtected() const override final{ return mInProtectedContext; }
		bool supportsBackgroundBlur() override final {
		return mBlurFilter != nullptr;
		}
		@@ -102,6 +101,8 @@ protected:
		size_t getMaxViewportDims() const override final;
		GrDirectContext* getActiveGrContext();

		bool isProtected() const { return mInProtectedContext; }

		// Implements PersistentCache as a way to monitor what SkSL shaders Skia has
		// cached.
		class SkSLCacheMonitor : public GrContextOptions::PersistentCache {

libs/renderengine/tests/RenderEngineThreadedTest.cpp

+64 −34

Original line number	Diff line number	Diff line
		@@ -17,8 +17,10 @@
		#include <cutils/properties.h>
		#include <gmock/gmock.h>
		#include <gtest/gtest.h>
		#include <hardware/gralloc.h>
		#include <renderengine/impl/ExternalTexture.h>
		#include <renderengine/mock/RenderEngine.h>
		#include <ui/PixelFormat.h>
		#include "../threaded/RenderEngineThreaded.h"

		namespace android {
		@@ -95,18 +97,6 @@ TEST_F(RenderEngineThreadedTest, getMaxViewportDims_returns0) {
		ASSERT_EQ(dims, result);
		}

		TEST_F(RenderEngineThreadedTest, isProtected_returnsFalse) {
		EXPECT_CALL(*mRenderEngine, isProtected()).WillOnce(Return(false));
		status_t result = mThreadedRE->isProtected();
		ASSERT_EQ(false, result);
		}

		TEST_F(RenderEngineThreadedTest, isProtected_returnsTrue) {
		EXPECT_CALL(*mRenderEngine, isProtected()).WillOnce(Return(true));
		size_t result = mThreadedRE->isProtected();
		ASSERT_EQ(true, result);
		}

		TEST_F(RenderEngineThreadedTest, supportsProtectedContent_returnsFalse) {
		EXPECT_CALL(*mRenderEngine, supportsProtectedContent()).WillOnce(Return(false));
		status_t result = mThreadedRE->supportsProtectedContent();
		@@ -119,28 +109,6 @@ TEST_F(RenderEngineThreadedTest, supportsProtectedContent_returnsTrue) {
		ASSERT_EQ(true, result);
		}

		TEST_F(RenderEngineThreadedTest, useProtectedContext) {
		EXPECT_CALL(*mRenderEngine, useProtectedContext(true));
		auto& ipExpect = EXPECT_CALL(*mRenderEngine, isProtected()).WillOnce(Return(false));
		EXPECT_CALL(*mRenderEngine, supportsProtectedContent()).WillOnce(Return(true));
		EXPECT_CALL(*mRenderEngine, isProtected()).After(ipExpect).WillOnce(Return(true));

		mThreadedRE->useProtectedContext(true);
		ASSERT_EQ(true, mThreadedRE->isProtected());

		// call ANY synchronous function to ensure that useProtectedContext has completed.
		mThreadedRE->getContextPriority();
		ASSERT_EQ(true, mThreadedRE->isProtected());
		}

		TEST_F(RenderEngineThreadedTest, useProtectedContext_quickReject) {
		EXPECT_CALL(*mRenderEngine, useProtectedContext(false)).Times(0);
		EXPECT_CALL(*mRenderEngine, isProtected()).WillOnce(Return(false));
		mThreadedRE->useProtectedContext(false);
		// call ANY synchronous function to ensure that useProtectedContext has completed.
		mThreadedRE->getContextPriority();
		}

		TEST_F(RenderEngineThreadedTest, PostRenderCleanup_skipped) {
		EXPECT_CALL(*mRenderEngine, canSkipPostRenderCleanup()).WillOnce(Return(true));
		EXPECT_CALL(*mRenderEngine, cleanupPostRender()).Times(0);
		@@ -182,6 +150,68 @@ TEST_F(RenderEngineThreadedTest, drawLayers) {

		base::unique_fd bufferFence;

		EXPECT_CALL(*mRenderEngine, useProtectedContext(false));
		EXPECT_CALL(*mRenderEngine, drawLayersInternal)
		.WillOnce([&](const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
		const renderengine::DisplaySettings&,
		const std::vector<renderengine::LayerSettings>&,
		const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
		base::unique_fd&&) { resultPromise->set_value(Fence::NO_FENCE); });

		ftl::Future<FenceResult> future =
		mThreadedRE->drawLayers(settings, layers, buffer, false, std::move(bufferFence));
		ASSERT_TRUE(future.valid());
		auto result = future.get();
		ASSERT_TRUE(result.ok());
		}

		TEST_F(RenderEngineThreadedTest, drawLayers_protectedLayer) {
		renderengine::DisplaySettings settings;
		auto layerBuffer = sp<GraphicBuffer>::make();
		layerBuffer->usage \|= GRALLOC_USAGE_PROTECTED;
		renderengine::LayerSettings layer;
		layer.source.buffer.buffer = std::make_shared<
		renderengine::impl::ExternalTexture>(std::move(layerBuffer), *mRenderEngine,
		renderengine::impl::ExternalTexture::Usage::
		READABLE);
		std::vector<renderengine::LayerSettings> layers = {std::move(layer)};
		std::shared_ptr<renderengine::ExternalTexture> buffer = std::make_shared<
		renderengine::impl::
		ExternalTexture>(sp<GraphicBuffer>::make(), *mRenderEngine,
		renderengine::impl::ExternalTexture::Usage::READABLE \|
		renderengine::impl::ExternalTexture::Usage::WRITEABLE);

		base::unique_fd bufferFence;

		EXPECT_CALL(*mRenderEngine, useProtectedContext(true));
		EXPECT_CALL(*mRenderEngine, drawLayersInternal)
		.WillOnce([&](const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
		const renderengine::DisplaySettings&,
		const std::vector<renderengine::LayerSettings>&,
		const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
		base::unique_fd&&) { resultPromise->set_value(Fence::NO_FENCE); });

		ftl::Future<FenceResult> future =
		mThreadedRE->drawLayers(settings, layers, buffer, false, std::move(bufferFence));
		ASSERT_TRUE(future.valid());
		auto result = future.get();
		ASSERT_TRUE(result.ok());
		}

		TEST_F(RenderEngineThreadedTest, drawLayers_protectedOutputBuffer) {
		renderengine::DisplaySettings settings;
		std::vector<renderengine::LayerSettings> layers;
		auto graphicBuffer = sp<GraphicBuffer>::make();
		graphicBuffer->usage \|= GRALLOC_USAGE_PROTECTED;
		std::shared_ptr<renderengine::ExternalTexture> buffer = std::make_shared<
		renderengine::impl::
		ExternalTexture>(std::move(graphicBuffer), *mRenderEngine,
		renderengine::impl::ExternalTexture::Usage::READABLE \|
		renderengine::impl::ExternalTexture::Usage::WRITEABLE);

		base::unique_fd bufferFence;

		EXPECT_CALL(*mRenderEngine, useProtectedContext(true));
		EXPECT_CALL(*mRenderEngine, drawLayersInternal)
		.WillOnce([&](const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
		const renderengine::DisplaySettings&,