Mojo C++ bindings: Merge EncodePointers/DecodePointers into Serialize/Deserialize, respectively.

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

 // Copyright 2013 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_BINDINGS_INTERNAL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_
 
 #include <stdint.h>
 
 #include "mojo/public/cpp/bindings/interface_id.h"
@@ skipping 39 matching lines @@
 const uint32_t kUnionDataSize = 16;
 
 template <typename T>
 class Array_Data;
 
 template <typename K, typename V>
 class Map_Data;
 
 using String_Data = Array_Data<char>;
 
+size_t Align(size_t size);
+char* AlignPointer(char* ptr);
+
+bool IsAligned(const void* ptr);
+
+// Pointers are encoded as relative offsets. The offsets are relative to the
+// address of where the offset value is stored, such that the pointer may be
+// recovered with the expression:
+//
+//   ptr = reinterpret_cast<char*>(offset) + *offset
+//
+// A null pointer is encoded as an offset value of 0.
+//
+void EncodePointer(const void* ptr, uint64_t* offset);
+// Note: This function doesn't validate the encoded pointer value.
+inline const void* DecodePointer(const uint64_t* offset) {
+  if (!*offset)
+    return nullptr;
+  return reinterpret_cast<const char*>(offset) + *offset;
+}
+
 #pragma pack(push, 1)
 
 struct StructHeader {
   uint32_t num_bytes;
   uint32_t version;
 };
 static_assert(sizeof(StructHeader) == 8, "Bad sizeof(StructHeader)");
 
 struct ArrayHeader {
   uint32_t num_bytes;
   uint32_t num_elements;
 };
 static_assert(sizeof(ArrayHeader) == 8, "Bad_sizeof(ArrayHeader)");
 
 template <typename T>
-union Pointer {
+struct Pointer {
+  using BaseType = T;
+
+  void Set(T* ptr) { EncodePointer(ptr, &offset); }
+  const T* Get() const { return static_cast<const T*>(DecodePointer(&offset)); }
+  T* Get() {
+    return static_cast<T*>(const_cast<void*>(DecodePointer(&offset)));
+  }
+
+  bool is_null() const { return offset == 0; }
+
   uint64_t offset;
-  T* ptr;
 };
 static_assert(sizeof(Pointer<char>) == 8, "Bad_sizeof(Pointer)");
 
 struct Handle_Data {
   Handle_Data() = default;
   explicit Handle_Data(uint32_t value) : value(value) {}
 
   bool is_valid() const { return value != kEncodedInvalidHandleValue; }
 
   uint32_t value;
@@ skipping 77 matching lines @@
 struct MojomTypeTraits {
   using Data = T;
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category = MojomTypeCategory::POD;
 };
 
 template <typename T>
 struct MojomTypeTraits<Array<T>, false> {
   using Data = Array_Data<typename MojomTypeTraits<T>::DataAsArrayElement>;
-  using DataAsArrayElement = Data*;
+  using DataAsArrayElement = Pointer<Data>;
 
   static const MojomTypeCategory category = MojomTypeCategory::ARRAY;
 };
 
 template <typename T>
 struct MojomTypeTraits<AssociatedInterfacePtrInfo<T>, false> {
   using Data = AssociatedInterface_Data;
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category =
@@ skipping 47 matching lines @@
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category =
       MojomTypeCategory::INTERFACE_REQUEST;
 };
 
 template <typename K, typename V>
 struct MojomTypeTraits<Map<K, V>, false> {
   using Data = Map_Data<typename MojomTypeTraits<K>::DataAsArrayElement,
                         typename MojomTypeTraits<V>::DataAsArrayElement>;
-  using DataAsArrayElement = Data*;
+  using DataAsArrayElement = Pointer<Data>;
 
   static const MojomTypeCategory category = MojomTypeCategory::MAP;
 };
 
 template <>
 struct MojomTypeTraits<String, false> {
   using Data = String_Data;
-  using DataAsArrayElement = Data*;
+  using DataAsArrayElement = Pointer<Data>;
 
   static const MojomTypeCategory category = MojomTypeCategory::STRING;
 };
 
 template <typename T>
 struct MojomTypeTraits<StructPtr<T>, false> {
   using Data = typename T::Data_;
   using DataAsArrayElement =
       typename std::conditional<IsUnionDataType<Data>::value,
                                 Data,
-                                Data*>::type;
+                                Pointer<Data>>::type;
 
   static const MojomTypeCategory category = IsUnionDataType<Data>::value
                                                 ? MojomTypeCategory::UNION
                                                 : MojomTypeCategory::STRUCT;
 };
 
 template <typename T>
 struct MojomTypeTraits<InlinedStructPtr<T>, false> {
   using Data = typename T::Data_;
   using DataAsArrayElement =
       typename std::conditional<IsUnionDataType<Data>::value,
                                 Data,
-                                Data*>::type;
+                                Pointer<Data>>::type;
 
   static const MojomTypeCategory category = IsUnionDataType<Data>::value
                                                 ? MojomTypeCategory::UNION
                                                 : MojomTypeCategory::STRUCT;
 };
 
 template <typename T, MojomTypeCategory categories>
 struct BelongsTo {
   static const bool value =
       static_cast<uint32_t>(MojomTypeTraits<T>::category & categories) != 0;
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_