Integrate from //sandbox/mathias/donut/...@145728 (6b35f970) · Commits · e / os / android_system_core

include/utils/Parcel.h

+10 −8

Original line number	Diff line number	Diff line
		@@ -80,8 +80,11 @@ public:
		status_t writeStrongBinder(const sp<IBinder>& val);
		status_t writeWeakBinder(const wp<IBinder>& val);

		// doesn't take ownership of the native_handle
		status_t writeNativeHandle(const native_handle& handle);
		// Place a native_handle into the parcel (the native_handle's file-
		// descriptors are dup'ed, so it is safe to delete the native_handle
		// when this function returns).
		// Doesn't take ownership of the native_handle.
		status_t writeNativeHandle(const native_handle* handle);

		// Place a file descriptor into the parcel. The given fd must remain
		// valid for the lifetime of the parcel.
		@@ -114,12 +117,11 @@ public:
		wp<IBinder> readWeakBinder() const;


		// if alloc is NULL, native_handle is allocated with malloc(), otherwise
		// alloc is used. If the function fails, the effects of alloc() must be
		// reverted by the caller.
		native_handle* readNativeHandle(
		native_handle* (alloc)(void cookie, int numFds, int ints),
		void* cookie) const;
		// Retrieve native_handle from the parcel. This returns a copy of the
		// parcel's native_handle (the caller takes ownership). The caller
		// must free the native_handle with native_handle_close() and
		// native_handle_delete().
		native_handle* readNativeHandle() const;


		// Retrieve a file descriptor from the parcel. This returns the raw fd

include/utils/Singleton.h

0 → 100644

+59 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_UTILS_SINGLETON_H
		#define ANDROID_UTILS_SINGLETON_H

		#include <stdint.h>
		#include <sys/types.h>
		#include <utils/threads.h>

		namespace android {
		// ---------------------------------------------------------------------------

		template <typename TYPE>
		class Singleton
		{
		public:
		static TYPE& getInstance() {
		Mutex::Autolock _l(sLock);
		TYPE* instance = sInstance;
		if (instance == 0) {
		instance = new TYPE();
		sInstance = instance;
		}
		return *instance;
		}

		protected:
		~Singleton() { };
		Singleton() { };

		private:
		Singleton(const Singleton&);
		Singleton& operator = (const Singleton&);
		static Mutex sLock;
		static TYPE* sInstance;
		};

		template<class TYPE> Mutex Singleton<TYPE>::sLock;
		template<class TYPE> TYPE* Singleton<TYPE>::sInstance(0);

		// ---------------------------------------------------------------------------
		}; // namespace android

		#endif // ANDROID_UTILS_SINGLETON_H

libs/utils/Parcel.cpp

+11 −29

Original line number	Diff line number	Diff line
		@@ -650,28 +650,26 @@ status_t Parcel::writeWeakBinder(const wp<IBinder>& val)
		return flatten_binder(ProcessState::self(), val, this);
		}

		status_t Parcel::writeNativeHandle(const native_handle& handle)
		status_t Parcel::writeNativeHandle(const native_handle* handle)
		{
		if (handle.version != sizeof(native_handle))
		if (handle->version != sizeof(native_handle))
		return BAD_TYPE;

		status_t err;
		err = writeInt32(handle.numFds);
		err = writeInt32(handle->numFds);
		if (err != NO_ERROR) return err;

		err = writeInt32(handle.numInts);
		err = writeInt32(handle->numInts);
		if (err != NO_ERROR) return err;

		for (int i=0 ; err==NO_ERROR && i<handle.numFds ; i++)
		err = writeDupFileDescriptor(handle.data[i]);
		for (int i=0 ; err==NO_ERROR && i<handle->numFds ; i++)
		err = writeDupFileDescriptor(handle->data[i]);

		if (err != NO_ERROR) {
		LOGD("write native handle, write dup fd failed");
		return err;
		}

		err = write(handle.data + handle.numFds, sizeof(int)*handle.numInts);

		err = write(handle->data + handle->numFds, sizeof(int)*handle->numInts);
		return err;
		}

		@@ -928,7 +926,7 @@ wp<IBinder> Parcel::readWeakBinder() const
		}


		native_handle* Parcel::readNativeHandle(native_handle* (alloc)(void, int, int), void* cookie) const
		native_handle* Parcel::readNativeHandle() const
		{
		int numFds, numInts;
		status_t err;
		@@ -937,31 +935,15 @@ native_handle* Parcel::readNativeHandle(native_handle* (alloc)(void, int, int)
		err = readInt32(&numInts);
		if (err != NO_ERROR) return 0;

		native_handle* h;
		if (alloc == 0) {
		size_t size = sizeof(native_handle) + sizeof(int)*(numFds + numInts);
		h = (native_handle*)malloc(size);
		h->version = sizeof(native_handle);
		h->numFds = numFds;
		h->numInts = numInts;
		} else {
		h = alloc(cookie, numFds, numInts);
		if (h->version != sizeof(native_handle)) {
		return 0;
		}
		}

		native_handle* h = native_handle_create(numFds, numInts);
		for (int i=0 ; err==NO_ERROR && i<numFds ; i++) {
		h->data[i] = dup(readFileDescriptor());
		if (h->data[i] < 0) err = BAD_VALUE;
		}

		err = read(h->data + numFds, sizeof(int)*numInts);

		if (err != NO_ERROR) {
		if (alloc == 0) {
		free(h);
		}
		native_handle_close(h);
		native_handle_delete(h);
		h = 0;
		}
		return h;