[mojo] Use base::Pickle for Message storage.

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_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 240 matching lines @@
   }
 
   size_t capacity_after_header() const {
     return capacity_after_header_;
   }
 
   // Resize the capacity, note that the input value should not include the size
   // of the header.
   void Resize(size_t new_capacity);
 
+  // Claims |num_bytes| bytes of payload. This is similar to Reserve in that it

[yzshen1, 2015/12/15 19:07:02]

style nit: Reserve -> Reserve() and |ClaimBytes| -> ClaimBytes().
I think that is more commonly used and consistent with line 210.

(And I think I saw some other places in this CL, too.)

+  // may grow the capacity, but it also advances the write offset of the pickle
+  // by |num_bytes|. Claimed memory is NOT initialized, though any alignment
+  // padding is zeroed.
+  //
+  // Unless you're SURE you're going to write to all the allocated bytes, you
+  // should use |ClaimBytes| instead.
+  void* ClaimUninitializedBytes(size_t num_bytes);
+
+  // Claims |num_bytes| bytes of payload, zeroing its contents.
+  void* ClaimBytes(size_t num_bytes);
+
   // Find the end of the pickled data that starts at range_start.  Returns NULL
   // if the entire Pickle is not found in the given data range.
   static const char* FindNext(size_t header_size,
                               const char* range_start,
                               const char* range_end);
 
   // Parse pickle header and return total size of the pickle. Data range
   // doesn't need to contain entire pickle.
   // Returns true if pickle header was found and parsed. Callers must check
   // returned |pickle_size| for sanity (against maximum message size, etc).
@@ skipping 21 matching lines @@
   size_t write_offset_;
 
   // Just like WriteBytes, but with a compile-time size, for performance.
   template<size_t length> void BASE_EXPORT WriteBytesStatic(const void* data);
 
   // Writes a POD by copying its bytes.
   template <typename T> bool WritePOD(const T& data) {
     WriteBytesStatic<sizeof(data)>(&data);
     return true;
   }
+
+  inline void* ClaimUninitializedBytesInternal(size_t num_bytes);
   inline void WriteBytesCommon(const void* data, size_t length);
 
   FRIEND_TEST_ALL_PREFIXES(PickleTest, DeepCopyResize);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNextOverflow);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextOverflow);
 };
 
 }  // namespace base
 
 #endif  // BASE_PICKLE_H_