class Parcel { public:  Parcel();  ~Parcel();   const uint8_t* data() const;  size_t dataSize() const;  size_t dataAvail() const;  size_t dataPosition() const;  size_t dataCapacity() const;   status_t setDataSize(size_t size);  void setDataPosition(size_t pos) const;  status_t setDataCapacity(size_t size);   status_t setData(const uint8_t* buffer, size_t len);   status_t appendFrom(Parcel *parcel, size_t start, size_t len);   bool hasFileDescriptors() const;   status_t writeInterfaceToken(const String16& interface);  bool enforceInterface(const String16& interface) const;  bool checkInterface(IBinder*) const;   void freeData();   const size_t* objects() const;  size_t objectsCount() const;   status_t errorCheck() const;  void setError(status_t err);   status_t write(const void* data, size_t len);  void* writeInplace(size_t len);  status_t writeUnpadded(const void* data, size_t len);  status_t writeInt32(int32_t val);  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);  status_t writeString16(const char16_t* str, size_t len);  status_t writeStrongBinder(const sp<IBinder>& val);  status_t writeWeakBinder(const wp<IBinder>& val);  status_t write(const Flattenable& val);   // 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.  status_t writeFileDescriptor(int fd);   // Place a file descriptor into the parcel. A dup of the fd is made, which  // will be closed once the parcel is destroyed.  status_t writeDupFileDescriptor(int fd);   status_t writeObject(const flat_binder_object& val, bool nullMetaData);   void remove(size_t start, size_t amt);   status_t read(void* outData, size_t len) const;  const void* readInplace(size_t len) const;  int32_t readInt32() const;  status_t readInt32(int32_t *pArg) const;  int64_t readInt64() const;  status_t readInt64(int64_t *pArg) const;  float readFloat() const;  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;  String16 readString16() const;  const char16_t* readString16Inplace(size_t* outLen) const;  sp<IBinder> readStrongBinder() const;  wp<IBinder> readWeakBinder() const;  status_t read(Flattenable& val) 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  // in the parcel, which you do not own -- use dup() to get your own copy.  int readFileDescriptor() const;   const flat_binder_object* readObject(bool nullMetaData) const;   // Explicitly close all file descriptors in the parcel.  void closeFileDescriptors();   typedef void (*release_func)(Parcel* parcel,  const uint8_t* data, size_t dataSize,  const size_t* objects, size_t objectsSize,  void* cookie);   const uint8_t* ipcData() const;  size_t ipcDataSize() const;  const size_t* ipcObjects() const;  size_t ipcObjectsCount() const;  void ipcSetDataReference(const uint8_t* data, size_t dataSize,  const size_t* objects, size_t objectsCount,  release_func relFunc, void* relCookie);   void print(TextOutput& to, uint32_t flags = 0) const;  private:  Parcel(const Parcel& o);  Parcel& operator=(const Parcel& o);   status_t finishWrite(size_t len);  void releaseObjects();  void acquireObjects();  status_t growData(size_t len);  status_t restartWrite(size_t desired);  status_t continueWrite(size_t desired);  void freeDataNoInit();  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;  size_t mDataCapacity;  mutable size_t mDataPos;  size_t* mObjects;  size_t mObjectsSize;  size_t mObjectsCapacity;  mutable size_t mNextObjectHint;   mutable bool mFdsKnown;  mutable bool mHasFds;   release_func mOwner;  void* mOwnerCookie; }; 

Parcel::Parcel() {  initState(); } 

void Parcel::initState() {  mError = NO_ERROR;  mData = 0;  mDataSize = 0;  mDataCapacity = 0;  mDataPos = 0;  LOGV("initState Setting data size of %p to %d\n", this, mDataSize);  LOGV("initState Setting data pos of %p to %d\n", this, mDataPos);  mObjects = NULL;  mObjectsSize = 0;  mObjectsCapacity = 0;  mNextObjectHint = 0;  mHasFds = false;  mFdsKnown = true;  mOwner = NULL; } 

inline static status_t finish_flatten_binder(const sp<IBinder>& binder,const flat_binder_object& flat,Parcel* out) {  return out->writeObject(flat,false); } 

status_t Parcel::writeObject(const flat_binder_object& val, bool nullMetaData) {  const bool enoughData = (mDataPos+sizeof(val)) <= mDataCapacity;  const bool enoughObjects = mObjectsSize < mObjectsCapacity;  if (enoughData && enoughObjects) { restart_write:  //code_1  *reinterpret_cast<flat_binder_object*>(mData+mDataPos) = val;   // Need to write meta-data?  //code_2  if (nullMetaData || val.binder != NULL) {  mObjects[mObjectsSize] = mDataPos;  acquire_object(ProcessState::self(), val, this);  mObjectsSize++;  }   // remember if it's a file descriptor  //code_3  if (val.type == BINDER_TYPE_FD) {  mHasFds = mFdsKnown = true;  }  //code_4  return finishWrite(sizeof(flat_binder_object));  }   //code_5  if (!enoughData) {  const status_t err = growData(sizeof(val));  if (err != NO_ERROR) return err;  }  //code_6  if (!enoughObjects) {  size_t newSize = ((mObjectsSize+2)*3)/2;  size_t* objects = (size_t*)realloc(mObjects, newSize*sizeof(size_t));  if (objects == NULL) return NO_MEMORY;  mObjects = objects;  mObjectsCapacity = newSize;  }   goto restart_write; } 

status_t Parcel::growData(size_t len) {  size_t newSize=((mDataSize+len)*3)/2;  return (newSize<=mDataSize)  ? (status_t) NO_MEMORY  : continueWrite(newSize); } 

status_t Parcel::continueWrite(size_t desired) {  // If shrinking, first adjust for any objects that appear  // after the new data size.  size_t objectsSize = mObjectsSize;  //code_1  if (desired < mDataSize) {  if (desired == 0) {  objectsSize = 0;  } else {  while (objectsSize > 0) {  if (mObjects[objectsSize-1] < desired)  break;  objectsSize--;  }  }  }  //code_2  if (mOwner) {  // If the size is going to zero, just release the owner's data.  if (desired == 0) {  freeData();  return NO_ERROR;  }   // If there is a different owner, we need to take  // posession.  uint8_t* data = (uint8_t*)malloc(desired);  if (!data) {  mError = NO_MEMORY;  return NO_MEMORY;  }  size_t* objects = NULL;   if (objectsSize) {  objects = (size_t*)malloc(objectsSize*sizeof(size_t));  if (!objects) {  mError = NO_MEMORY;  return NO_MEMORY;  }   // Little hack to only acquire references on objects  // we will be keeping.  size_t oldObjectsSize = mObjectsSize;  mObjectsSize = objectsSize;  acquireObjects();  mObjectsSize = oldObjectsSize;  }   if (mData) {  memcpy(data, mData, mDataSize < desired ? mDataSize : desired);  }  if (objects && mObjects) {  memcpy(objects, mObjects, objectsSize*sizeof(size_t));  }  //LOGI("Freeing data ref of %p (pid=%d)\n", this, getpid());  mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);  mOwner = NULL;   mData = data;  mObjects = objects;  mDataSize = (mDataSize < desired) ? mDataSize : desired;  LOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);  mDataCapacity = desired;  mObjectsSize = mObjectsCapacity = objectsSize;  mNextObjectHint = 0;   } else if (mData) { //code_3  if (objectsSize < mObjectsSize) {  // Need to release refs on any objects we are dropping.  const sp<ProcessState> proc(ProcessState::self());  for (size_t i=objectsSize; i<mObjectsSize; i++) {  const flat_binder_object* flat  = reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);  if (flat->type == BINDER_TYPE_FD) {  // will need to rescan because we may have lopped off the only FDs  mFdsKnown = false;  }  release_object(proc, *flat, this);  }  size_t* objects =  (size_t*)realloc(mObjects, objectsSize*sizeof(size_t));  if (objects) {  mObjects = objects;  }  mObjectsSize = objectsSize;  mNextObjectHint = 0;  }   // We own the data, so we can just do a realloc().  if (desired > mDataCapacity) {  uint8_t* data = (uint8_t*)realloc(mData, desired);  if (data) {  mData = data;  mDataCapacity = desired;  } else if (desired > mDataCapacity) {  mError = NO_MEMORY;  return NO_MEMORY;  }  } else {  mDataSize = desired;  LOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);  if (mDataPos > desired) {  mDataPos = desired;  LOGV("continueWrite Setting data pos of %p to %d\n", this, mDataPos);  }  }   } else { //code_4  // This is the first data. Easy!  uint8_t* data = (uint8_t*)malloc(desired);  if (!data) {  mError = NO_MEMORY;  return NO_MEMORY;  }   if(!(mDataCapacity == 0 && mObjects == NULL  && mObjectsCapacity == 0)) {  LOGE("continueWrite: %d/%p/%d/%d", mDataCapacity, mObjects, mObjectsCapacity, desired);  }   mData = data;  mDataSize = mDataPos = 0;  LOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);  LOGV("continueWrite Setting data pos of %p to %d\n", this, mDataPos);  mDataCapacity = desired;  }   return NO_ERROR; } 

void acquire_object(const sp<ProcessState>& proc, const flat_binder_object& obj, const void* who) {  switch (obj.type) {  case BINDER_TYPE_BINDER:  if (obj.binder) {  LOG_REFS("Parcel %p acquiring reference on local %p", who, obj.cookie);  static_cast<IBinder*>(obj.cookie)->incStrong(who);  }  return;  case BINDER_TYPE_WEAK_BINDER:  if (obj.binder)  static_cast<RefBase::weakref_type*>(obj.binder)->incWeak(who);  return;  case BINDER_TYPE_HANDLE: {  const sp<IBinder> b = proc->getStrongProxyForHandle(obj.handle);  if (b != NULL) {  LOG_REFS("Parcel %p acquiring reference on remote %p", who, b.get());  b->incStrong(who);  }  return;  }  case BINDER_TYPE_WEAK_HANDLE: {  const wp<IBinder> b = proc->getWeakProxyForHandle(obj.handle);  if (b != NULL) b.get_refs()->incWeak(who);  return;  }  case BINDER_TYPE_FD: {  // intentionally blank -- nothing to do to acquire this, but we do  // recognize it as a legitimate object type.  return;  }  }   LOGD("Invalid object type 0x%08lx", obj.type); } 

status_t Parcel::finishWrite(size_t len) {  //printf("Finish write of %d\n", len);  mDataPos += len;  LOGV("finishWrite Setting data pos of %p to %d\n", this, mDataPos);  if (mDataPos > mDataSize) {  mDataSize = mDataPos;  LOGV("finishWrite Setting data size of %p to %d\n", this, mDataSize);  }  //printf("New pos=%d, size=%d\n", mDataPos, mDataSize);  return NO_ERROR; }