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

mojo/public/cpp/bindings/lib/pickle_buffer.h

+// Copyright 2015 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 MOJO_PUBLIC_CPP_BINDINGS_LIB_PICKLE_BUFFER_H_
+#define MOJO_PUBLIC_CPP_BINDINGS_LIB_PICKLE_BUFFER_H_
+
+#include "base/macros.h"
+#include "base/pickle.h"
+#include "mojo/public/cpp/bindings/lib/buffer.h"
+
+namespace mojo {
+namespace internal {
+
+// An implementation of Buffer which uses base::Pickle for its backing. Note
+// that this does not use Pickle's header structure at all, instead storing
+// the complete Message (including header) in the Pickle's payload.
+class PickleBuffer : public base::Pickle, public Buffer {
+ public:
+  PickleBuffer();
+  ~PickleBuffer() override;
+
+  const void* data() const {
+    return reinterpret_cast<const void*>(
+        reinterpret_cast<const char*>(base::Pickle::data())
+            + sizeof(PaddedHeader));
+  }
+
+  void* data() {
+    return const_cast<void*>(static_cast<const PickleBuffer*>(this)->data());
+  }
+
+  size_t data_num_bytes() const { return payload_size(); }
+
+  // Resizes and zeroes the underlying Pickle's capacity.
+  void ReserveCapacity(uint32_t num_bytes);

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

"Reserve capacity" doesn't sound like it zero out the memory.

Maybe we should call it ReserveCapacityAndClear(), and the next one
ReserveCapacity().

As you said, the best names probably should be Allocate once we change the
current Allocate to Claim.

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

PickleBuffer doesn't actually need to be resizable if we treat allocation as an
initialization-only step of Message. I've changed PickleBuffer to take size and
zero_initialized args in its constructor.

+
+  // Resizes the underlying Pickle's capacity without zeroing.
+  void ReserveUninitializedCapacity(uint32_t num_bytes);
+
+  // Buffer:
+  PickleBuffer* AsPickleBuffer() override;
+
+ private:
+  // Buffer implementation. Note that this cannot grow the Pickle's capacity and
+  // it is an error to Allocate() more bytes in total than have been
+  // pre-allocated using ReserveCapacity() or ReserveUninitializedCapacity().
+  //
+  // This guarantees that the returned data is aligned on an 8-byte boundary.
+  void* Allocate(size_t num_bytes) override;
+
+  // TODO(rockot): Stop wasting 8 bytes per buffer.
+  //
+  // We don't use Pickle's header at all, but its base header type consumes 4
+  // bytes. We waste another 4 bytes to keep our actual buffer aligned to an
+  // 8-byte boundary.
+  //
+  // The reason we don't use base::Pickle's header (yet) is that it stores
+  // payload length in the first 4 bytes. Mojo Messages are packed like structs,
+  // where the first 4 bytes are header size rather than payload size.
+  struct PaddedHeader : public base::Pickle::Header {
+    uint32_t padding;
+  };
+
+  static_assert(sizeof(PaddedHeader) % 8 == 0,
+      "PickleBuffer requires a Pickle header size with 8-byte alignment.");
+
+  // The index into the message payload where the next Buffer::Allocate should
+  // claim memory.
+  size_t allocation_cursor_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(PickleBuffer);
+};
+
+}  // namespace internal
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_PICKLE_BUFFER_H_