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

base/pickle_unittest.cc

 // 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.
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/strings/string16.h"
@@ skipping 506 matching lines @@
   while (pickle.capacity_after_header() != pickle.payload_size())
     pickle.WriteBool(true);
 
   // Make a deep copy.
   Pickle pickle2(pickle);
 
   // Check that there isn't any extraneous capacity.
   EXPECT_EQ(pickle.capacity_after_header(), pickle2.capacity_after_header());
 }
 
+namespace {
+
+// Publicly exposes the ClaimBytes interface for testing.
+class TestingPickle : public base::Pickle {
+ public:
+  TestingPickle() {}
+
+  void* ClaimBytes(size_t num_bytes) {
+    return base::Pickle::ClaimBytes(num_bytes);
+  }
+};
+
+}  // namespace
+
+// Checks that claimed bytes are zero-initialized.
+TEST(PickleTest, ClaimBytesInitialization) {
+  static const int kChunkSize = 64;
+  TestingPickle pickle;
+  void* bytes = pickle.ClaimBytes(kChunkSize);
+  for (size_t i = 0; i < kChunkSize; ++i) {
+    EXPECT_EQ(0, reinterpret_cast<char*>(bytes)[i]);

[yzshen1, 2015/12/15 22:27:08]

(In response to your previous comment about reinterpret_cast<> has to be used.)
Have you tried it out? :)
Actually static_cast<> can be used between void* and other pointer types. I
always use it that way.

I don't think it is an important issue, but static_cast<> can not be used with
arbitrary types so it is a little safer.
(And some other reasons could be seen here:
http://stackoverflow.com/questions/310451/should-i-use-static-cast-or-reinter...)

[Ken Rockot(use gerrit already), 2015/12/16 00:09:33]

I thought I had... :D
I've updated things to static_cast

+  }
+}
+
+// Checks that ClaimBytes properly advances the write offset.
+TEST(PickleTest, ClaimBytes) {
+  std::string data("Hello, world!");
+
+  TestingPickle pickle;
+  pickle.WriteSizeT(data.size());
+  void* bytes = pickle.ClaimBytes(data.size());
+  pickle.WriteInt(42);
+  memcpy(bytes, data.data(), data.size());
+
+  PickleIterator iter(pickle);
+  size_t out_data_length;
+  EXPECT_TRUE(iter.ReadSizeT(&out_data_length));
+  EXPECT_EQ(data.size(), out_data_length);
+
+  const char* out_data = nullptr;
+  EXPECT_TRUE(iter.ReadBytes(&out_data, out_data_length));
+  EXPECT_EQ(data, std::string(out_data, out_data_length));
+
+  int out_value;
+  EXPECT_TRUE(iter.ReadInt(&out_value));
+  EXPECT_EQ(42, out_value);
+}
+
 }  // namespace base