fold LayerBaseClient into LayerBase (b79f61d4) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/Client.cpp

+6 −6

Original line number	Diff line number	Diff line
		@@ -43,7 +43,7 @@ Client::~Client()
		{
		const size_t count = mLayers.size();
		for (size_t i=0 ; i<count ; i++) {
		sp<LayerBaseClient> layer(mLayers.valueAt(i).promote());
		sp<LayerBase> layer(mLayers.valueAt(i).promote());
		if (layer != 0) {
		mFlinger->removeLayer(layer);
		}
		@@ -54,13 +54,13 @@ status_t Client::initCheck() const {
		return NO_ERROR;
		}

		void Client::attachLayer(const sp<IBinder>& handle, const sp<LayerBaseClient>& layer)
		void Client::attachLayer(const sp<IBinder>& handle, const sp<LayerBase>& layer)
		{
		Mutex::Autolock _l(mLock);
		mLayers.add(handle, layer);
		}

		void Client::detachLayer(const LayerBaseClient* layer)
		void Client::detachLayer(const LayerBase* layer)
		{
		Mutex::Autolock _l(mLock);
		// we do a linear search here, because this doesn't happen often
		@@ -72,11 +72,11 @@ void Client::detachLayer(const LayerBaseClient* layer)
		}
		}
		}
		sp<LayerBaseClient> Client::getLayerUser(const sp<IBinder>& handle) const
		sp<LayerBase> Client::getLayerUser(const sp<IBinder>& handle) const
		{
		Mutex::Autolock _l(mLock);
		sp<LayerBaseClient> lbc;
		wp<LayerBaseClient> layer(mLayers.valueFor(handle));
		sp<LayerBase> lbc;
		wp<LayerBase> layer(mLayers.valueFor(handle));
		if (layer != 0) {
		lbc = layer.promote();
		ALOGE_IF(lbc==0, "getLayerUser(name=%p) is dead", handle.get());

services/surfaceflinger/Client.h

+5 −5

Original line number	Diff line number	Diff line
		@@ -30,7 +30,7 @@ namespace android {

		// ---------------------------------------------------------------------------

		class LayerBaseClient;
		class LayerBase;
		class SurfaceFlinger;

		// ---------------------------------------------------------------------------
		@@ -44,11 +44,11 @@ public:
		status_t initCheck() const;

		// protected by SurfaceFlinger::mStateLock
		void attachLayer(const sp<IBinder>& handle, const sp<LayerBaseClient>& layer);
		void attachLayer(const sp<IBinder>& handle, const sp<LayerBase>& layer);

		void detachLayer(const LayerBaseClient* layer);
		void detachLayer(const LayerBase* layer);

		sp<LayerBaseClient> getLayerUser(const sp<IBinder>& handle) const;
		sp<LayerBase> getLayerUser(const sp<IBinder>& handle) const;

		private:
		// ISurfaceComposerClient interface
		@@ -66,7 +66,7 @@ private:
		sp<SurfaceFlinger> mFlinger;

		// protected by mLock
		DefaultKeyedVector< wp<IBinder>, wp<LayerBaseClient> > mLayers;
		DefaultKeyedVector< wp<IBinder>, wp<LayerBase> > mLayers;

		// thread-safe
		mutable Mutex mLock;

services/surfaceflinger/Layer.cpp

+9 −9

Original line number	Diff line number	Diff line
		@@ -50,7 +50,7 @@ namespace android {
		// ---------------------------------------------------------------------------

		Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client)
		: LayerBaseClient(flinger, client),
		: LayerBase(flinger, client),
		mTextureName(-1U),
		mQueuedFrames(0),
		mCurrentTransform(0),
		@@ -70,7 +70,7 @@ Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client)

		void Layer::onLayerDisplayed(const sp<const DisplayDevice>& hw,
		HWComposer::HWCLayerInterface* layer) {
		LayerBaseClient::onLayerDisplayed(hw, layer);
		LayerBase::onLayerDisplayed(hw, layer);
		if (layer) {
		mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFenceFd());
		}
		@@ -78,7 +78,7 @@ void Layer::onLayerDisplayed(const sp<const DisplayDevice>& hw,

		void Layer::onFirstRef()
		{
		LayerBaseClient::onFirstRef();
		LayerBase::onFirstRef();

		// Creates a custom BufferQueue for SurfaceFlingerConsumer to use
		sp<BufferQueue> bq = new SurfaceTextureLayer();
		@@ -224,7 +224,7 @@ void Layer::setGeometry(
		const sp<const DisplayDevice>& hw,
		HWComposer::HWCLayerInterface& layer)
		{
		LayerBaseClient::setGeometry(hw, layer);
		LayerBase::setGeometry(hw, layer);

		// enable this layer
		layer.setSkip(false);
		@@ -260,7 +260,7 @@ void Layer::setGeometry(

		void Layer::setPerFrameData(const sp<const DisplayDevice>& hw,
		HWComposer::HWCLayerInterface& layer) {
		LayerBaseClient::setPerFrameData(hw, layer);
		LayerBase::setPerFrameData(hw, layer);
		// NOTE: buffer can be NULL if the client never drew into this
		// layer yet, or if we ran out of memory
		layer.setBuffer(mActiveBuffer);
		@@ -528,7 +528,7 @@ void Layer::onPostComposition() {
		}

		bool Layer::isVisible() const {
		return LayerBaseClient::isVisible() && (mActiveBuffer != NULL);
		return LayerBase::isVisible() && (mActiveBuffer != NULL);
		}

		Region Layer::latchBuffer(bool& recomputeVisibleRegions)
		@@ -704,7 +704,7 @@ Region Layer::latchBuffer(bool& recomputeVisibleRegions)

		void Layer::dump(String8& result, char* buffer, size_t SIZE) const
		{
		LayerBaseClient::dump(result, buffer, SIZE);
		LayerBase::dump(result, buffer, SIZE);

		sp<const GraphicBuffer> buf0(mActiveBuffer);
		uint32_t w0=0, h0=0, s0=0, f0=0;
		@@ -730,13 +730,13 @@ void Layer::dump(String8& result, char* buffer, size_t SIZE) const

		void Layer::dumpStats(String8& result, char* buffer, size_t SIZE) const
		{
		LayerBaseClient::dumpStats(result, buffer, SIZE);
		LayerBase::dumpStats(result, buffer, SIZE);
		mFrameTracker.dump(result);
		}

		void Layer::clearStats()
		{
		LayerBaseClient::clearStats();
		LayerBase::clearStats();
		mFrameTracker.clear();
		}

services/surfaceflinger/Layer.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -55,7 +55,7 @@ class GLExtensions;
		* This also implements onFrameAvailable(), which notifies SurfaceFlinger
		* that new data has arrived.
		*/
		class Layer : public LayerBaseClient,
		class Layer : public LayerBase,
		public SurfaceFlingerConsumer::FrameAvailableListener
		{
		public:
		@@ -93,7 +93,7 @@ public:
		virtual void setName(const String8& name);
		virtual bool isVisible() const;

		// LayerBaseClient interface
		// LayerBase interface
		virtual wp<IBinder> getSurfaceTextureBinder() const;

		// only for debugging

services/surfaceflinger/LayerBase.cpp

+22 −47

Original line number	Diff line number	Diff line
		@@ -42,18 +42,24 @@ namespace android {

		int32_t LayerBase::sSequence = 1;

		LayerBase::LayerBase(SurfaceFlinger* flinger)
		LayerBase::LayerBase(SurfaceFlinger* flinger, const sp<Client>& client)
		: contentDirty(false),
		sequence(uint32_t(android_atomic_inc(&sSequence))),
		mFlinger(flinger), mFiltering(false),
		mNeedsFiltering(false),
		mTransactionFlags(0),
		mPremultipliedAlpha(true), mName("unnamed"), mDebug(false)
		mPremultipliedAlpha(true), mName("unnamed"), mDebug(false),
		mHasSurface(false),
		mClientRef(client)
		{
		}

		LayerBase::~LayerBase()
		{
		sp<Client> c(mClientRef.promote());
		if (c != 0) {
		c->detachLayer(this);
		}
		}

		void LayerBase::setName(const String8& name) {
		@@ -542,19 +548,22 @@ void LayerBase::dump(String8& result, char* buffer, size_t SIZE) const

		s.transparentRegion.dump(result, "transparentRegion");
		visibleRegion.dump(result, "visibleRegion");
		sp<Client> client(mClientRef.promote());

		snprintf(buffer, SIZE,
		" "
		"layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), "
		"isOpaque=%1d, needsDithering=%1d, invalidate=%1d, "
		"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
		"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n"
		" client=%p\n",
		s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h,
		s.active.crop.left, s.active.crop.top,
		s.active.crop.right, s.active.crop.bottom,
		isOpaque(), needsDithering(), contentDirty,
		s.alpha, s.flags,
		s.transform[0][0], s.transform[0][1],
		s.transform[1][0], s.transform[1][1]);
		s.transform[1][0], s.transform[1][1],
		client.get());
		result.append(buffer);
		}

		@@ -568,52 +577,32 @@ void LayerBase::dumpStats(String8& result, char* scratch, size_t SIZE) const {
		void LayerBase::clearStats() {
		}

		sp<LayerBaseClient> LayerBase::getLayerBaseClient() const {
		return 0;
		}

		sp<Layer> LayerBase::getLayer() const {
		return 0;
		}

		// ---------------------------------------------------------------------------

		LayerBaseClient::LayerBaseClient(SurfaceFlinger* flinger,
		const sp<Client>& client)
		: LayerBase(flinger),
		mHasSurface(false),
		mClientRef(client)
		{
		}

		LayerBaseClient::~LayerBaseClient()
		{
		sp<Client> c(mClientRef.promote());
		if (c != 0) {
		c->detachLayer(this);
		}
		}

		sp<ISurface> LayerBaseClient::createSurface()
		sp<ISurface> LayerBase::createSurface()
		{
		class BSurface : public BnSurface, public LayerCleaner {
		virtual sp<IGraphicBufferProducer> getSurfaceTexture() const { return 0; }
		public:
		BSurface(const sp<SurfaceFlinger>& flinger,
		const sp<LayerBaseClient>& layer)
		const sp<LayerBase>& layer)
		: LayerCleaner(flinger, layer) { }
		};
		sp<ISurface> sur(new BSurface(mFlinger, this));
		return sur;
		}

		sp<ISurface> LayerBaseClient::getSurface()
		sp<ISurface> LayerBase::getSurface()
		{
		sp<ISurface> s;
		Mutex::Autolock _l(mLock);

		LOG_ALWAYS_FATAL_IF(mHasSurface,
		"LayerBaseClient::getSurface() has already been called");
		"LayerBase::getSurface() has already been called");

		mHasSurface = true;
		s = createSurface();
		@@ -621,36 +610,22 @@ sp<ISurface> LayerBaseClient::getSurface()
		return s;
		}

		wp<IBinder> LayerBaseClient::getSurfaceBinder() const {
		wp<IBinder> LayerBase::getSurfaceBinder() const {
		return mClientSurfaceBinder;
		}

		wp<IBinder> LayerBaseClient::getSurfaceTextureBinder() const {
		wp<IBinder> LayerBase::getSurfaceTextureBinder() const {
		return 0;
		}

		void LayerBaseClient::dump(String8& result, char* buffer, size_t SIZE) const
		{
		LayerBase::dump(result, buffer, SIZE);
		sp<Client> client(mClientRef.promote());
		snprintf(buffer, SIZE, " client=%p\n", client.get());
		result.append(buffer);
		}


		void LayerBaseClient::shortDump(String8& result, char* scratch, size_t size) const
		{
		LayerBaseClient::dump(result, scratch, size);
		}

		// ---------------------------------------------------------------------------

		LayerBaseClient::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger,
		const sp<LayerBaseClient>& layer)
		LayerBase::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger,
		const sp<LayerBase>& layer)
		: mFlinger(flinger), mLayer(layer) {
		}

		LayerBaseClient::LayerCleaner::~LayerCleaner() {
		LayerBase::LayerCleaner::~LayerCleaner() {
		// destroy client resources
		mFlinger->onLayerDestroyed(mLayer);
		}