Merge "Remove a dependency of Region (libui) on Parcel (libbinder)." (4734bd4e) · Commits · e / os / android_frameworks_native-old

include/ui/Region.h

+0 −6

Original line number	Diff line number	Diff line
		@@ -21,7 +21,6 @@
		#include <sys/types.h>

		#include <utils/Vector.h>
		#include <binder/Parcel.h>

		#include <ui/Rect.h>

		@@ -39,7 +38,6 @@ public:
		Region();
		Region(const Region& rhs);
		explicit Region(const Rect& rhs);
		explicit Region(const Parcel& parcel);
		explicit Region(const void* buffer);
		~Region();

		@@ -118,10 +116,6 @@ public:
		// be sorted in Y and X and must not make the region invalid.
		void addRectUnchecked(int l, int t, int r, int b);

		// flatten/unflatten a region to/from a Parcel
		status_t write(Parcel& parcel) const;
		status_t read(const Parcel& parcel);

		// flatten/unflatten a region to/from a raw buffer
		ssize_t write(void* buffer, size_t size) const;
		static ssize_t writeEmpty(void* buffer, size_t size);

libs/surfaceflinger_client/LayerState.cpp

+24 −4

Original line number	Diff line number	Diff line
		@@ -22,17 +22,37 @@ namespace android {

		status_t layer_state_t::write(Parcel& output) const
		{
		status_t err;

		size_t len = transparentRegion.write(NULL, 0);
		err = output.writeInt32(len);
		if (err < NO_ERROR) return err;

		void* buf = output.writeInplace(len);
		if (buf == NULL) return NO_MEMORY;

		err = transparentRegion.write(buf, len);
		if (err < NO_ERROR) return err;

		// NOTE: regions are at the end of the structure
		size_t size = sizeof(layer_state_t);
		transparentRegion.write(output);
		size -= sizeof(transparentRegion);
		output.write(this, size);
		return NO_ERROR;
		err = output.write(this, size);
		return err;
		}

		status_t layer_state_t::read(const Parcel& input)
		{
		status_t err;
		size_t len = input.readInt32();
		void const* buf = input.readInplace(len);
		if (buf == NULL) return NO_MEMORY;

		err = transparentRegion.read(buf);
		if (err < NO_ERROR) return err;

		// NOTE: regions are at the end of the structure
		size_t size = sizeof(layer_state_t);
		transparentRegion.read(input);
		size -= sizeof(transparentRegion);
		input.read(this, size);
		return NO_ERROR;

libs/ui/Region.cpp

+9 −44

Original line number	Diff line number	Diff line
		@@ -63,16 +63,10 @@ Region::Region(const Rect& rhs)
		{
		}

		Region::Region(const Parcel& parcel)
		{
		status_t err = read(parcel);
		LOGE_IF(err<0, "error %s reading Region from parcel", strerror(err));
		}

		Region::Region(const void* buffer)
		{
		status_t err = read(buffer);
		LOGE_IF(err<0, "error %s reading Region from parcel", strerror(err));
		LOGE_IF(err<0, "error %s reading Region from buffer", strerror(err));
		}

		Region::~Region()
		@@ -532,37 +526,6 @@ void Region::translate(Region& dst, const Region& reg, int dx, int dy)

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

		status_t Region::write(Parcel& parcel) const
		{
		#if VALIDATE_REGIONS
		validate(*this, "write(Parcel)");
		#endif
		status_t err;
		const size_t count = mStorage.size();
		const size_t sizeNeeded = sizeof(int32_t) + (1+count)*sizeof(Rect);
		void* buffer = parcel.writeInplace(sizeNeeded);
		if (!buffer) return NO_MEMORY;
		ssize_t written = Region::write(buffer, sizeNeeded);
		if (written < 0) return status_t(written);
		return NO_ERROR;
		}

		status_t Region::read(const Parcel& parcel)
		{
		void const* buffer = parcel.readInplace(sizeof(int32_t));
		if (!buffer) return NO_MEMORY;
		const size_t count = static_cast<int32_t const >(buffer);
		void const* dummy = parcel.readInplace((1+count)*sizeof(Rect));
		if (!dummy) return NO_MEMORY;
		const size_t sizeNeeded = sizeof(int32_t) + (1+count)*sizeof(Rect);
		const ssize_t read = Region::read(buffer);
		if (read < 0) return status_t(read);
		#if VALIDATE_REGIONS
		validate(*this, "read(Parcel)");
		#endif
		return NO_ERROR;
		}

		ssize_t Region::write(void* buffer, size_t size) const
		{
		#if VALIDATE_REGIONS
		@@ -570,6 +533,7 @@ ssize_t Region::write(void* buffer, size_t size) const
		#endif
		const size_t count = mStorage.size();
		const size_t sizeNeeded = sizeof(int32_t) + (1+count)*sizeof(Rect);
		if (buffer != NULL) {
		if (sizeNeeded > size) return NO_MEMORY;
		int32_t* const p = static_cast<int32_t*>(buffer);
		*p = count;
		@@ -577,6 +541,7 @@ ssize_t Region::write(void* buffer, size_t size) const
		if (count) {
		memcpy(p+5, mStorage.array(), count*sizeof(Rect));
		}
		}
		return ssize_t(sizeNeeded);
		}