Merge "[SurfaceFlinger] Callback to renderengine when erasing BLAST buffers" into qt-r1-dev (9939d091) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/BufferLayer.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -48,7 +48,7 @@ namespace android {
		class BufferLayer : public Layer {
		public:
		explicit BufferLayer(const LayerCreationArgs& args);
		~BufferLayer() override;
		virtual ~BufferLayer() override;

		// -----------------------------------------------------------------------
		// Overriden from Layer

services/surfaceflinger/BufferStateLayer.cpp

+10 −4

Original line number	Diff line number	Diff line
		@@ -51,6 +51,16 @@ BufferStateLayer::BufferStateLayer(const LayerCreationArgs& args)
		mCurrentState.dataspace = ui::Dataspace::V0_SRGB;
		}

		BufferStateLayer::~BufferStateLayer() {
		if (mActiveBuffer != nullptr) {
		// Ensure that mActiveBuffer is uncached from RenderEngine here, as
		// RenderEngine may have been using the buffer as an external texture
		// after the client uncached the buffer.
		auto& engine(mFlinger->getRenderEngine());
		engine.unbindExternalTextureBuffer(mActiveBuffer->getId());
		}
		}

		// -----------------------------------------------------------------------
		// Interface implementation for Layer
		// -----------------------------------------------------------------------
		@@ -610,10 +620,6 @@ void BufferStateLayer::onFirstRef() {
		}
		}

		void BufferStateLayer::bufferErased(const client_cache_t& clientCacheId) {
		mFlinger->getRenderEngine().unbindExternalTextureBuffer(clientCacheId.id);
		}

		void BufferStateLayer::HwcSlotGenerator::bufferErased(const client_cache_t& clientCacheId) {
		std::lock_guard lock(mMutex);
		if (!clientCacheId.isValid()) {

services/surfaceflinger/BufferStateLayer.h

+2 −3

Original line number	Diff line number	Diff line
		@@ -35,6 +35,8 @@ class BufferStateLayer : public BufferLayer {
		public:
		explicit BufferStateLayer(const LayerCreationArgs&);

		~BufferStateLayer() override;

		// -----------------------------------------------------------------------
		// Interface implementation for Layer
		// -----------------------------------------------------------------------
		@@ -102,9 +104,6 @@ public:
		bool fenceHasSignaled() const override;
		bool framePresentTimeIsCurrent() const override;

		// Inherit from ClientCache::ErasedRecipient
		void bufferErased(const client_cache_t& clientCacheId) override;

		private:
		nsecs_t getDesiredPresentTime() override;
		std::shared_ptr<FenceTime> getCurrentFenceTime() const override;

services/surfaceflinger/ClientCache.cpp

+10 −8

Original line number	Diff line number	Diff line
		@@ -55,16 +55,16 @@ bool ClientCache::getBuffer(const client_cache_t& cacheId,
		return true;
		}

		void ClientCache::add(const client_cache_t& cacheId, const sp<GraphicBuffer>& buffer) {
		bool ClientCache::add(const client_cache_t& cacheId, const sp<GraphicBuffer>& buffer) {
		auto& [processToken, id] = cacheId;
		if (processToken == nullptr) {
		ALOGE("failed to cache buffer: invalid process token");
		return;
		return false;
		}

		if (!buffer) {
		ALOGE("failed to cache buffer: invalid buffer");
		return;
		return false;
		}

		std::lock_guard lock(mMutex);
		@@ -77,13 +77,13 @@ void ClientCache::add(const client_cache_t& cacheId, const sp<GraphicBuffer>& bu
		token = processToken.promote();
		if (!token) {
		ALOGE("failed to cache buffer: invalid token");
		return;
		return false;
		}

		status_t err = token->linkToDeath(mDeathRecipient);
		if (err != NO_ERROR) {
		ALOGE("failed to cache buffer: could not link to death");
		return;
		return false;
		}
		auto [itr, success] =
		mBuffers.emplace(processToken, std::unordered_map<uint64_t, ClientCacheBuffer>());
		@@ -95,10 +95,11 @@ void ClientCache::add(const client_cache_t& cacheId, const sp<GraphicBuffer>& bu

		if (processBuffers.size() > BUFFER_CACHE_MAX_SIZE) {
		ALOGE("failed to cache buffer: cache is full");
		return;
		return false;
		}

		processBuffers[id].buffer = buffer;
		return true;
		}

		void ClientCache::erase(const client_cache_t& cacheId) {
		@@ -139,16 +140,17 @@ sp<GraphicBuffer> ClientCache::get(const client_cache_t& cacheId) {
		return buf->buffer;
		}

		void ClientCache::registerErasedRecipient(const client_cache_t& cacheId,
		bool ClientCache::registerErasedRecipient(const client_cache_t& cacheId,
		const wp<ErasedRecipient>& recipient) {
		std::lock_guard lock(mMutex);

		ClientCacheBuffer* buf = nullptr;
		if (!getBuffer(cacheId, &buf)) {
		ALOGE("failed to register erased recipient, could not retrieve buffer");
		return;
		return false;
		}
		buf->recipients.insert(recipient);
		return true;
		}

		void ClientCache::unregisterErasedRecipient(const client_cache_t& cacheId,

services/surfaceflinger/ClientCache.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -36,7 +36,7 @@ class ClientCache : public Singleton<ClientCache> {
		public:
		ClientCache();

		void add(const client_cache_t& cacheId, const sp<GraphicBuffer>& buffer);
		bool add(const client_cache_t& cacheId, const sp<GraphicBuffer>& buffer);
		void erase(const client_cache_t& cacheId);

		sp<GraphicBuffer> get(const client_cache_t& cacheId);
		@@ -48,7 +48,7 @@ public:
		virtual void bufferErased(const client_cache_t& clientCacheId) = 0;
		};

		void registerErasedRecipient(const client_cache_t& cacheId,
		bool registerErasedRecipient(const client_cache_t& cacheId,
		const wp<ErasedRecipient>& recipient);
		void unregisterErasedRecipient(const client_cache_t& cacheId,
		const wp<ErasedRecipient>& recipient);