Support for marshalling pointers / intptr_t in Parcel. (84a6d041) · Commits · e / os / platform_frameworks_native

include/binder/Parcel.h

+11 −0

Original line number	Diff line number	Diff line
		@@ -74,6 +74,7 @@ public:
		status_t writeInt64(int64_t val);
		status_t writeFloat(float val);
		status_t writeDouble(double val);
		status_t writeIntPtr(intptr_t val);
		status_t writeCString(const char* str);
		status_t writeString8(const String8& str);
		status_t writeString16(const String16& str);
		@@ -109,6 +110,8 @@ public:
		status_t readFloat(float *pArg) const;
		double readDouble() const;
		status_t readDouble(double *pArg) const;
		intptr_t readIntPtr() const;
		status_t readIntPtr(intptr_t *pArg) const;

		const char* readCString() const;
		String8 readString8() const;
		@@ -163,6 +166,14 @@ private:
		void initState();
		void scanForFds() const;

		template<class T>
		status_t readAligned(T *pArg) const;

		template<class T> T readAligned() const;

		template<class T>
		status_t writeAligned(T val);

		status_t mError;
		uint8_t* mData;
		size_t mDataSize;

include/utils/Debug.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,8 @@ template<> struct CompileTimeAssert<true> {};
		#define COMPILE_TIME_ASSERT(_exp) \
		template class CompileTimeAssert< (_exp) >;
		#endif
		#define COMPILE_TIME_ASSERT_FUNCTION_SCOPE(_exp) \
		CompileTimeAssert<( _exp )>();

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

libs/binder/Parcel.cpp

+63 −95

Original line number	Diff line number	Diff line
		@@ -562,54 +562,27 @@ restart_write:

		status_t Parcel::writeInt32(int32_t val)
		{
		if ((mDataPos+sizeof(val)) <= mDataCapacity) {
		restart_write:
		reinterpret_cast<int32_t>(mData+mDataPos) = val;
		return finishWrite(sizeof(val));
		}

		status_t err = growData(sizeof(val));
		if (err == NO_ERROR) goto restart_write;
		return err;
		return writeAligned(val);
		}

		status_t Parcel::writeInt64(int64_t val)
		{
		if ((mDataPos+sizeof(val)) <= mDataCapacity) {
		restart_write:
		reinterpret_cast<int64_t>(mData+mDataPos) = val;
		return finishWrite(sizeof(val));
		}

		status_t err = growData(sizeof(val));
		if (err == NO_ERROR) goto restart_write;
		return err;
		return writeAligned(val);
		}

		status_t Parcel::writeFloat(float val)
		{
		if ((mDataPos+sizeof(val)) <= mDataCapacity) {
		restart_write:
		reinterpret_cast<float>(mData+mDataPos) = val;
		return finishWrite(sizeof(val));
		}

		status_t err = growData(sizeof(val));
		if (err == NO_ERROR) goto restart_write;
		return err;
		return writeAligned(val);
		}

		status_t Parcel::writeDouble(double val)
		{
		if ((mDataPos+sizeof(val)) <= mDataCapacity) {
		restart_write:
		reinterpret_cast<double>(mData+mDataPos) = val;
		return finishWrite(sizeof(val));
		return writeAligned(val);
		}

		status_t err = growData(sizeof(val));
		if (err == NO_ERROR) goto restart_write;
		return err;
		status_t Parcel::writeIntPtr(intptr_t val)
		{
		return writeAligned(val);
		}

		status_t Parcel::writeCString(const char* str)
		@@ -768,103 +741,98 @@ const void* Parcel::readInplace(size_t len) const
		return NULL;
		}

		status_t Parcel::readInt32(int32_t *pArg) const
		{
		if ((mDataPos+sizeof(int32_t)) <= mDataSize) {
		template<class T>
		status_t Parcel::readAligned(T *pArg) const {
		COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));

		if ((mDataPos+sizeof(T)) <= mDataSize) {
		const void* data = mData+mDataPos;
		mDataPos += sizeof(int32_t);
		pArg = reinterpret_cast<const int32_t*>(data);
		mDataPos += sizeof(T);
		pArg = reinterpret_cast<const T*>(data);
		return NO_ERROR;
		} else {
		return NOT_ENOUGH_DATA;
		}
		}

		int32_t Parcel::readInt32() const
		template<class T>
		T Parcel::readAligned() const {
		T result;
		if (readAligned(&result) != NO_ERROR) {
		result = 0;
		}

		return result;
		}

		template<class T>
		status_t Parcel::writeAligned(T val) {
		COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));

		if ((mDataPos+sizeof(val)) <= mDataCapacity) {
		restart_write:
		reinterpret_cast<T>(mData+mDataPos) = val;
		return finishWrite(sizeof(val));
		}

		status_t err = growData(sizeof(val));
		if (err == NO_ERROR) goto restart_write;
		return err;
		}

		status_t Parcel::readInt32(int32_t *pArg) const
		{
		if ((mDataPos+sizeof(int32_t)) <= mDataSize) {
		const void* data = mData+mDataPos;
		mDataPos += sizeof(int32_t);
		LOGV("readInt32 Setting data pos of %p to %d\n", this, mDataPos);
		return reinterpret_cast<const int32_t>(data);
		return readAligned(pArg);
		}
		return 0;

		int32_t Parcel::readInt32() const
		{
		return readAligned<int32_t>();
		}


		status_t Parcel::readInt64(int64_t *pArg) const
		{
		if ((mDataPos+sizeof(int64_t)) <= mDataSize) {
		const void* data = mData+mDataPos;
		mDataPos += sizeof(int64_t);
		pArg = reinterpret_cast<const int64_t*>(data);
		LOGV("readInt64 Setting data pos of %p to %d\n", this, mDataPos);
		return NO_ERROR;
		} else {
		return NOT_ENOUGH_DATA;
		}
		return readAligned(pArg);
		}


		int64_t Parcel::readInt64() const
		{
		if ((mDataPos+sizeof(int64_t)) <= mDataSize) {
		const void* data = mData+mDataPos;
		mDataPos += sizeof(int64_t);
		LOGV("readInt64 Setting data pos of %p to %d\n", this, mDataPos);
		return reinterpret_cast<const int64_t>(data);
		}
		return 0;
		return readAligned<int64_t>();
		}

		status_t Parcel::readFloat(float *pArg) const
		{
		if ((mDataPos+sizeof(float)) <= mDataSize) {
		const void* data = mData+mDataPos;
		mDataPos += sizeof(float);
		LOGV("readFloat Setting data pos of %p to %d\n", this, mDataPos);
		pArg = reinterpret_cast<const float*>(data);
		return NO_ERROR;
		} else {
		return NOT_ENOUGH_DATA;
		}
		return readAligned(pArg);
		}


		float Parcel::readFloat() const
		{
		if ((mDataPos+sizeof(float)) <= mDataSize) {
		const void* data = mData+mDataPos;
		mDataPos += sizeof(float);
		LOGV("readFloat Setting data pos of %p to %d\n", this, mDataPos);
		return reinterpret_cast<const float>(data);
		}
		return 0;
		return readAligned<float>();
		}

		status_t Parcel::readDouble(double *pArg) const
		{
		if ((mDataPos+sizeof(double)) <= mDataSize) {
		const void* data = mData+mDataPos;
		mDataPos += sizeof(double);
		LOGV("readDouble Setting data pos of %p to %d\n", this, mDataPos);
		pArg = reinterpret_cast<const double*>(data);
		return NO_ERROR;
		} else {
		return NOT_ENOUGH_DATA;
		}
		return readAligned(pArg);
		}


		double Parcel::readDouble() const
		{
		if ((mDataPos+sizeof(double)) <= mDataSize) {
		const void* data = mData+mDataPos;
		mDataPos += sizeof(double);
		LOGV("readDouble Setting data pos of %p to %d\n", this, mDataPos);
		return reinterpret_cast<const double>(data);
		return readAligned<double>();
		}

		status_t Parcel::readIntPtr(intptr_t *pArg) const
		{
		return readAligned(pArg);
		}
		return 0;


		intptr_t Parcel::readIntPtr() const
		{
		return readAligned<intptr_t>();
		}