[mojo] Add pickling support for native-only structs

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

Index: mojo/public/cpp/bindings/lib/native_serialization.h
diff --git a/mojo/public/cpp/bindings/lib/native_serialization.h b/mojo/public/cpp/bindings/lib/native_serialization.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6d6fe0a07d6f06f92a1da2878fb351cb5d5fefd
--- /dev/null
+++ b/mojo/public/cpp/bindings/lib/native_serialization.h
@@ -0,0 +1,98 @@
+// 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_NATIVE_SERIALIZATION_H_
+#define MOJO_PUBLIC_CPP_BINDINGS_LIB_NATIVE_SERIALIZATION_H_
+
+#include <stdint.h>
+
+#include <limits>
+
+#include "base/logging.h"
+#include "base/pickle.h"
+#include "ipc/ipc_param_traits.h"
+#include "mojo/public/cpp/bindings/lib/array_internal.h"
+#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
+#include "mojo/public/cpp/bindings/lib/bindings_serialization.h"
+#include "mojo/public/cpp/bindings/lib/pickle_buffer.h"
+
+namespace mojo {
+namespace internal {
+
+template <typename T>
+size_t GetSerializedSizeNative_(const T& value) {
+  return IPC::ParamTraits<T>::GetSize(value);
+}
+
+template <typename T>
+void SerializeNative_(const T& value,
+                      Buffer* buffer,
+                      Array_Data<uint8_t>** out) {
+  PickleBuffer* pickler = buffer->AsPickleBuffer();
+  DCHECK(pickler) << "Native types can only be used with PickleBuffers.";
+
+  ArrayHeader* header =
+      reinterpret_cast<ArrayHeader*>(buffer->Allocate(sizeof(ArrayHeader)));
+
+  // Remember where the Pickle started before writing.
+  base::Pickle* pickle = pickler->pickle();
+  const char* data_start = pickle->end_of_payload();
+
+  IPC::ParamTraits<T>::Write(pickle, value);
+
+  // Fix up the ArrayHeader so that num_elements contains the length of the
+  // pickled data.
+  size_t pickled_size = pickle->end_of_payload() - data_start;
+  size_t total_size = pickled_size + sizeof(ArrayHeader);
+  DCHECK_LT(total_size, std::numeric_limits<uint32_t>::max());
+  header->num_bytes = static_cast<uint32_t>(total_size);
+  header->num_elements = static_cast<uint32_t>(pickled_size);
+
+  *out = reinterpret_cast<Array_Data<uint8_t>*>(header);
+}
+
+template <typename T>
+bool DeserializeNative_(Array_Data<uint8_t>* data,
+                        T* out,
+                        SerializationContext* context) {
+  if (!data)
+    return true;
+
+  // Construct a temporary base::Pickle view over the array data. Note that
+  // the Array_Data is laid out like this:
+  //
+  //   [num_bytes (4 bytes)] [num_elements (4 bytes)] [elements...]
+  //
+  // and base::Pickle expects to view data like this:
+  //
+  //   [payload_size (4 bytes)] [header bytes ...] [payload...]
+  //
+  // Because ArrayHeader's num_bytes includes the length of the header and
+  // Pickle's payload_size does not, we need to adjust the stored value
+  // momentarily so Pickle can view the data.
+  ArrayHeader* header = reinterpret_cast<ArrayHeader*>(data);
+  DCHECK_GE(header->num_bytes, sizeof(ArrayHeader));
+  header->num_bytes -= sizeof(ArrayHeader);
+
+  {
+    // Construct a view over the full Array_Data, including our hacked up
+    // header. Pickle will infer from this that the header is 8 bytes long,
+    // and the payload will contain all of the pickled bytes.
+    base::Pickle pickle_view(reinterpret_cast<const char*>(header),
+                             header->num_bytes + sizeof(ArrayHeader));
+    base::PickleIterator iter(pickle_view);
+    if (!IPC::ParamTraits<T>::Read(&pickle_view, &iter, out))
+      return false;
+  }
+
+  // Return the header to its original state.
+  header->num_bytes += sizeof(ArrayHeader);
+
+  return true;
+}
+
+}  // namespace internal
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_NATIVE_SERIALIZATION_H_