Explicitly destroy Layer in DeferredLayerUpdater on destroyHardwareResources() (3e9999bd) · Commits · e / os / android_frameworks_base

libs/hwui/BakedOpDispatcher.cpp

+9 −4

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@

		#include "BakedOpRenderer.h"
		#include "Caches.h"
		#include "DeferredLayerUpdater.h"
		#include "Glop.h"
		#include "GlopBuilder.h"
		#include "Patch.h"
		@@ -762,15 +763,19 @@ void BakedOpDispatcher::onTextOnPathOp(BakedOpRenderer& renderer, const TextOnPa
		}

		void BakedOpDispatcher::onTextureLayerOp(BakedOpRenderer& renderer, const TextureLayerOp& op, const BakedOpState& state) {
		const bool tryToSnap = !op.layer->getForceFilter();
		float alpha = (op.layer->getAlpha() / 255.0f) * state.alpha;
		GlLayer* layer = static_cast<GlLayer*>(op.layerHandle->backingLayer());
		if (!layer) {
		return;
		}
		const bool tryToSnap = layer->getForceFilter();
		float alpha = (layer->getAlpha() / 255.0f) * state.alpha;
		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshTexturedUvQuad(nullptr, Rect(0, 1, 1, 0)) // TODO: simplify with VBO
		.setFillTextureLayer(*(op.layer), alpha)
		.setFillTextureLayer(*(layer), alpha)
		.setTransform(state.computedState.transform, TransformFlags::None)
		.setModelViewMapUnitToRectOptionalSnap(tryToSnap, Rect(op.layer->getWidth(), op.layer->getHeight()))
		.setModelViewMapUnitToRectOptionalSnap(tryToSnap, Rect(layer->getWidth(), layer->getHeight()))
		.build();
		renderer.renderGlop(state, glop);
		}

libs/hwui/DeferredLayerUpdater.cpp

+23 −11

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@

		#include "GlLayer.h"
		#include "VkLayer.h"
		#include "renderstate/RenderState.h"
		#include "renderthread/EglManager.h"
		#include "renderthread/RenderTask.h"
		#include "utils/PaintUtils.h"
		@@ -24,26 +25,33 @@
		namespace android {
		namespace uirenderer {

		DeferredLayerUpdater::DeferredLayerUpdater(Layer* layer)
		: mSurfaceTexture(nullptr)
		DeferredLayerUpdater::DeferredLayerUpdater(RenderState& renderState, CreateLayerFn createLayerFn,
		Layer::Api layerApi)
		: mRenderState(renderState)
		, mBlend(false)
		, mSurfaceTexture(nullptr)
		, mTransform(nullptr)
		, mNeedsGLContextAttach(false)
		, mUpdateTexImage(false)
		, mLayer(layer) {
		mWidth = mLayer->getWidth();
		mHeight = mLayer->getHeight();
		mBlend = mLayer->isBlend();
		mColorFilter = SkSafeRef(mLayer->getColorFilter());
		mAlpha = mLayer->getAlpha();
		mMode = mLayer->getMode();
		, mLayer(nullptr)
		, mLayerApi(layerApi)
		, mCreateLayerFn(createLayerFn) {
		renderState.registerDeferredLayerUpdater(this);
		}

		DeferredLayerUpdater::~DeferredLayerUpdater() {
		SkSafeUnref(mColorFilter);
		setTransform(nullptr);
		mRenderState.unregisterDeferredLayerUpdater(this);
		destroyLayer();
		}

		void DeferredLayerUpdater::destroyLayer() {
		if (mLayer) {
		mLayer->postDecStrong();
		mLayer = nullptr;
		}
		}

		void DeferredLayerUpdater::setPaint(const SkPaint* paint) {
		mAlpha = PaintUtils::getAlphaDirect(paint);
		@@ -53,6 +61,10 @@ void DeferredLayerUpdater::setPaint(const SkPaint* paint) {
		}

		void DeferredLayerUpdater::apply() {
		if (!mLayer) {
		mLayer = mCreateLayerFn(mRenderState, mWidth, mHeight, mColorFilter, mAlpha, mMode, mBlend);
		}

		mLayer->setColorFilter(mColorFilter);
		mLayer->setAlpha(mAlpha, mMode);

libs/hwui/DeferredLayerUpdater.h

+24 −7

Original line number	Diff line number	Diff line
		@@ -32,13 +32,20 @@
		namespace android {
		namespace uirenderer {

		class RenderState;

		// Container to hold the properties a layer should be set to at the start
		// of a render pass
		class DeferredLayerUpdater : public VirtualLightRefBase {
		public:
		// Note that DeferredLayerUpdater assumes it is taking ownership of the layer
		// and will not call incrementRef on it as a result.
		ANDROID_API explicit DeferredLayerUpdater(Layer* layer);
		typedef std::function<Layer*(RenderState& renderState, uint32_t layerWidth,
		uint32_t layerHeight, SkColorFilter* colorFilter, int alpha,
		SkBlendMode mode, bool blend)> CreateLayerFn;
		ANDROID_API explicit DeferredLayerUpdater(RenderState& renderState,
		CreateLayerFn createLayerFn, Layer::Api layerApi);

		ANDROID_API ~DeferredLayerUpdater();

		ANDROID_API bool setSize(int width, int height) {
		@@ -97,20 +104,30 @@ public:

		void updateLayer(bool forceFilter, GLenum renderTarget, const float* textureTransform);

		void destroyLayer();

		Layer::Api getBackingLayerApi() {
		return mLayerApi;
		}

		private:
		RenderState& mRenderState;

		// Generic properties
		int mWidth;
		int mHeight;
		bool mBlend;
		SkColorFilter* mColorFilter;
		int mAlpha;
		SkBlendMode mMode;
		int mWidth = 0;
		int mHeight = 0;
		bool mBlend = false;
		SkColorFilter* mColorFilter = nullptr;
		int mAlpha = 255;
		SkBlendMode mMode = SkBlendMode::kSrcOver;
		sp<GLConsumer> mSurfaceTexture;
		SkMatrix* mTransform;
		bool mNeedsGLContextAttach;
		bool mUpdateTexImage;

		Layer* mLayer;
		Layer::Api mLayerApi;
		CreateLayerFn mCreateLayerFn;

		void doUpdateTexImage();
		void doUpdateVkTexImage();

libs/hwui/FrameBuilder.cpp

+5 −3

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@

		#include "FrameBuilder.h"

		#include "DeferredLayerUpdater.h"
		#include "LayerUpdateQueue.h"
		#include "RenderNode.h"
		#include "VectorDrawable.h"
		@@ -784,14 +785,15 @@ void FrameBuilder::deferTextOnPathOp(const TextOnPathOp& op) {
		}

		void FrameBuilder::deferTextureLayerOp(const TextureLayerOp& op) {
		if (CC_UNLIKELY(!op.layer->isRenderable())) return;
		GlLayer* layer = static_cast<GlLayer*>(op.layerHandle->backingLayer());
		if (CC_UNLIKELY(!layer \|\| !layer->isRenderable())) return;

		const TextureLayerOp* textureLayerOp = &op;
		// Now safe to access transform (which was potentially unready at record time)
		if (!op.layer->getTransform().isIdentity()) {
		if (!layer->getTransform().isIdentity()) {
		// non-identity transform present, so 'inject it' into op by copying + replacing matrix
		Matrix4 combinedMatrix(op.localMatrix);
		combinedMatrix.multiply(op.layer->getTransform());
		combinedMatrix.multiply(layer->getTransform());
		textureLayerOp = mAllocator.create<TextureLayerOp>(op, combinedMatrix);
		}
		BakedOpState* bakedState = tryBakeOpState(*textureLayerOp);

libs/hwui/GlLayer.cpp

+4 −2

Original line number	Diff line number	Diff line
		@@ -32,12 +32,14 @@
		namespace android {
		namespace uirenderer {

		GlLayer::GlLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight)
		: Layer(renderState, Api::OpenGL)
		GlLayer::GlLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
		SkColorFilter* colorFilter, int alpha, SkBlendMode mode, bool blend)
		: Layer(renderState, Api::OpenGL, colorFilter, alpha, mode)
		, caches(Caches::getInstance())
		, texture(caches) {
		texture.mWidth = layerWidth;
		texture.mHeight = layerHeight;
		texture.blend = blend;
		}

		GlLayer::~GlLayer() {