Make the serialization of IPC::Messages inside other IPC::Messages independent

base/pickle.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_PICKLE_H__
 #define BASE_PICKLE_H__
 #pragma once
 
 #include <string>
 
@@ skipping 150 matching lines @@
   }
   bool ReadString(PickleIterator* iter, std::string* result) const {
     return iter->ReadString(result);
   }
   bool ReadWString(PickleIterator* iter, std::wstring* result) const {
     return iter->ReadWString(result);
   }
   bool ReadString16(PickleIterator* iter, string16* result) const {
     return iter->ReadString16(result);
   }
+  // A pointer to the data will be placed in *data, and the length will be
+  // placed in *length. This buffer will be into the message's buffer so will
+  // be scoped to the lifetime of the message (or until the message data is
+  // mutated).
   bool ReadData(PickleIterator* iter, const char** data, int* length) const {
     return iter->ReadData(data, length);
   }
+  // A pointer to the data will be placed in *data. The caller specifies the
+  // number of bytes to read, and ReadBytes will validate this length. The
+  // returned buffer will be into the message's buffer so will be scoped to the
+  // lifetime of the message (or until the message data is mutated).
   bool ReadBytes(PickleIterator* iter, const char** data, int length) const {
     return iter->ReadBytes(data, length);
   }
 
   // Safer version of ReadInt() checks for the result not being negative.
   // Use it for reading the object sizes.
   bool ReadLength(PickleIterator* iter, int* result) const {
     return iter->ReadLength(result);
   }
 
@@ skipping 23 matching lines @@
   }
   bool WriteInt64(int64 value) {
     return WriteBytes(&value, sizeof(value));
   }
   bool WriteUInt64(uint64 value) {
     return WriteBytes(&value, sizeof(value));
   }
   bool WriteString(const std::string& value);
   bool WriteWString(const std::wstring& value);
   bool WriteString16(const string16& value);
+  // "Data" is a blob with a length. When you read it out you will be given the
+  // length. See also WriteBytes.
   bool WriteData(const char* data, int length);
+  // "Bytes" is a blob with no length. The caller must specify the lenght both
+  // when reading and writing. It is normally used to serialize PoD types of a
+  // known size. See also WriteData.
   bool WriteBytes(const void* data, int data_len);
 
   // Same as WriteData, but allows the caller to write directly into the
   // Pickle. This saves a copy in cases where the data is not already
   // available in a buffer. The caller should take care to not write more
   // than the length it declares it will. Use ReadData to get the data.
   // Returns NULL on failure.
   //
   // The returned pointer will only be valid until the next write operation
   // on this Pickle.
@@ skipping 94 matching lines @@
   // Allocation size of payload (or -1 if allocation is const).
   size_t capacity_;
   size_t variable_buffer_offset_;  // IF non-zero, then offset to a buffer.
 
   FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
 };
 
 #endif  // BASE_PICKLE_H__