Merge change 21576 into eclair (10843106) · Commits · e / os / platform_frameworks_native

include/binder/Parcel.h

+11 −0

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

	const char* readCString() const;		const char* readCString() const;
	String8 readString8() const;		String8 readString8() const;
	@@ -163,6 +166,14 @@ private:
	void initState();		void initState();
	void scanForFds() const;		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;		status_t mError;
	uint8_t* mData;		uint8_t* mData;
	size_t mDataSize;		size_t mDataSize;

include/utils/Debug.h

+2 −0

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

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

libs/binder/Parcel.cpp

+63 −95

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

	status_t Parcel::writeInt32(int32_t val)		status_t Parcel::writeInt32(int32_t val)
	{		{
	if ((mDataPos+sizeof(val)) <= mDataCapacity) {		return writeAligned(val);
	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;
	}		}

	status_t Parcel::writeInt64(int64_t val)		status_t Parcel::writeInt64(int64_t val)
	{		{
	if ((mDataPos+sizeof(val)) <= mDataCapacity) {		return writeAligned(val);
	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;
	}		}

	status_t Parcel::writeFloat(float val)		status_t Parcel::writeFloat(float val)
	{		{
	if ((mDataPos+sizeof(val)) <= mDataCapacity) {		return writeAligned(val);
	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;
	}		}

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

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

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

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

			if ((mDataPos+sizeof(T)) <= mDataSize) {
	const void* data = mData+mDataPos;		const void* data = mData+mDataPos;
	mDataPos += sizeof(int32_t);		mDataPos += sizeof(T);
	pArg = reinterpret_cast<const int32_t*>(data);		pArg = reinterpret_cast<const T*>(data);
	return NO_ERROR;		return NO_ERROR;
	} else {		} else {
	return NOT_ENOUGH_DATA;		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) {		return readAligned(pArg);
	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 0;
			int32_t Parcel::readInt32() const
			{
			return readAligned<int32_t>();
	}		}


	status_t Parcel::readInt64(int64_t *pArg) const		status_t Parcel::readInt64(int64_t *pArg) const
	{		{
	if ((mDataPos+sizeof(int64_t)) <= mDataSize) {		return readAligned(pArg);
	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;
	}
	}		}


	int64_t Parcel::readInt64() const		int64_t Parcel::readInt64() const
	{		{
	if ((mDataPos+sizeof(int64_t)) <= mDataSize) {		return readAligned<int64_t>();
	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;
	}		}

	status_t Parcel::readFloat(float *pArg) const		status_t Parcel::readFloat(float *pArg) const
	{		{
	if ((mDataPos+sizeof(float)) <= mDataSize) {		return readAligned(pArg);
	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;
	}
	}		}


	float Parcel::readFloat() const		float Parcel::readFloat() const
	{		{
	if ((mDataPos+sizeof(float)) <= mDataSize) {		return readAligned<float>();
	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;
	}		}

	status_t Parcel::readDouble(double *pArg) const		status_t Parcel::readDouble(double *pArg) const
	{		{
	if ((mDataPos+sizeof(double)) <= mDataSize) {		return readAligned(pArg);
	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;
	}
	}		}


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

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