am a9c9a4ba: fix RefBase so it retains binary-compatibility with gingerbread (DO NOT MERGE) (4c83aefe) · Commits · e / os / android_frameworks_native-old

include/utils/RefBase.h

+13 −7

Original line number	Diff line number	Diff line
		@@ -117,16 +117,22 @@ public:

		typedef RefBase basetype;

		protected:
		RefBase();
		virtual ~RefBase();
		// used to override the RefBase destruction.
		class Destroyer {
		friend class RefBase;
		public:
		virtual ~Destroyer();
		private:
		virtual void destroy(RefBase const* base) = 0;
		};

		// called when the last reference goes away. this is responsible for
		// calling the destructor. The default implementation just does
		// "delete this;".
		// Make sure to never acquire a strong reference from this function. The
		// same restrictions than for destructors apply.
		virtual void destroy() const;
		void setDestroyer(Destroyer* destroyer);

		protected:
		RefBase();
		virtual ~RefBase();

		//! Flags for extendObjectLifetime()
		enum {

libs/utils/RefBase.cpp

+25 −9

Original line number	Diff line number	Diff line
		@@ -49,6 +49,11 @@ namespace android {

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

		RefBase::Destroyer::~Destroyer() {
		}

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

		class RefBase::weakref_impl : public RefBase::weakref_type
		{
		public:
		@@ -56,7 +61,7 @@ public:
		volatile int32_t mWeak;
		RefBase* const mBase;
		volatile int32_t mFlags;

		Destroyer* mDestroyer;

		#if !DEBUG_REFS

		@@ -65,6 +70,7 @@ public:
		, mWeak(0)
		, mBase(base)
		, mFlags(0)
		, mDestroyer(0)
		{
		}

		@@ -345,10 +351,6 @@ void RefBase::incStrong(const void* id) const
		const_cast<RefBase*>(this)->onFirstRef();
		}

		void RefBase::destroy() const {
		delete this;
		}

		void RefBase::decStrong(const void* id) const
		{
		weakref_impl* const refs = mRefs;
		@@ -361,7 +363,11 @@ void RefBase::decStrong(const void* id) const
		if (c == 1) {
		const_cast<RefBase*>(this)->onLastStrongRef(id);
		if ((refs->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {
		destroy();
		if (refs->mDestroyer) {
		refs->mDestroyer->destroy(this);
		} else {
		delete this;
		}
		}
		}
		refs->decWeak(id);
		@@ -394,7 +400,9 @@ int32_t RefBase::getStrongCount() const
		return mRefs->mStrong;
		}


		void RefBase::setDestroyer(RefBase::Destroyer* destroyer) {
		mRefs->mDestroyer = destroyer;
		}

		RefBase* RefBase::weakref_type::refBase() const
		{
		@@ -420,7 +428,11 @@ void RefBase::weakref_type::decWeak(const void* id)
		if ((impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {
		if (impl->mStrong == INITIAL_STRONG_VALUE) {
		if (impl->mBase) {
		impl->mBase->destroy();
		if (impl->mDestroyer) {
		impl->mDestroyer->destroy(impl->mBase);
		} else {
		delete impl->mBase;
		}
		}
		} else {
		// LOGV("Freeing refs %p of old RefBase %p\n", this, impl->mBase);
		@@ -430,7 +442,11 @@ void RefBase::weakref_type::decWeak(const void* id)
		impl->mBase->onLastWeakRef(id);
		if ((impl->mFlags&OBJECT_LIFETIME_FOREVER) != OBJECT_LIFETIME_FOREVER) {
		if (impl->mBase) {
		impl->mBase->destroy();
		if (impl->mDestroyer) {
		impl->mDestroyer->destroy(impl->mBase);
		} else {
		delete impl->mBase;
		}
		}
		}
		}

services/surfaceflinger/Layer.cpp

+3 −2

Original line number	Diff line number	Diff line
		@@ -61,6 +61,7 @@ Layer::Layer(SurfaceFlinger* flinger,
		mBufferManager(mTextureManager),
		mWidth(0), mHeight(0), mNeedsScaling(false), mFixedSize(false)
		{
		setDestroyer(this);
		}

		Layer::~Layer()
		@@ -77,8 +78,8 @@ Layer::~Layer()
		}
		}

		void Layer::destroy() const {
		mFlinger->destroyLayer(this);
		void Layer::destroy(RefBase const* base) {
		mFlinger->destroyLayer(static_cast<LayerBase const*>(base));
		}

		status_t Layer::setToken(const sp<UserClient>& userClient,

services/surfaceflinger/Layer.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -44,7 +44,7 @@ class UserClient;

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

		class Layer : public LayerBaseClient
		class Layer : public LayerBaseClient, private RefBase::Destroyer
		{
		public:
		Layer(SurfaceFlinger* flinger, DisplayID display,
		@@ -92,7 +92,7 @@ public:
		return mFreezeLock; }

		protected:
		virtual void destroy() const;
		virtual void destroy(RefBase const* base);
		virtual void dump(String8& result, char* scratch, size_t size) const;

		private: