Mojo C++ bindings: share DataView class between chromium and blink variants.

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 <functional>
 
 #include "base/template_util.h"
 #include "mojo/public/cpp/bindings/interface_id.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/public/cpp/system/core.h"
 
 namespace mojo {
 
 template <typename T>
-class Array;
-
-template <typename T>
 class ArrayDataView;
 
 template <typename T>
-class AssociatedInterfacePtrInfo;
+class AssociatedInterfacePtrInfoDataView;
 
 template <typename T>
-class AssociatedInterfaceRequest;
+class AssociatedInterfaceRequestDataView;
 
 template <typename T>
-class InterfacePtr;
+class InterfacePtrDataView;
 
 template <typename T>
-class InterfaceRequest;
-
-template <typename K, typename V>
-class Map;
+class InterfaceRequestDataView;
 
 template <typename K, typename V>
 class MapDataView;
 
-class NativeStruct;
-
 class NativeStructDataView;
 
-class String;
-
 class StringDataView;
 
-template <typename T>
-class StructPtr;
-
-template <typename T>
-class InlinedStructPtr;
-
-using NativeStructPtr = StructPtr<NativeStruct>;
-
 namespace internal {
 
 // Please note that this is a different value than |mojo::kInvalidHandleValue|,
 // which is the "decoded" invalid handle.
 const uint32_t kEncodedInvalidHandleValue = static_cast<uint32_t>(-1);
 
 // A serialized union always takes 16 bytes:
 //   4-byte size + 4-byte tag + 8-byte payload.
 const uint32_t kUnionDataSize = 16;
 
 template <typename T>
 class Array_Data;
 
 template <typename K, typename V>
 class Map_Data;
 
+class NativeStruct_Data;
+
 using String_Data = Array_Data<char>;
 
 inline size_t Align(size_t size) {
   return (size + 7) & ~0x7;
 }
 
 inline bool IsAligned(const void* ptr) {
   return !(reinterpret_cast<uintptr_t>(ptr) & 0x7);
 }
 
@@ skipping 140 matching lines @@
 
 template <typename T, bool is_enum = std::is_enum<T>::value>
 struct MojomTypeTraits {
   using Data = T;
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category = MojomTypeCategory::POD;
 };
 
 template <typename T>
-struct MojomTypeTraits<Array<T>, false> {
+struct MojomTypeTraits<ArrayDataView<T>, false> {
   using Data = Array_Data<typename MojomTypeTraits<T>::DataAsArrayElement>;
   using DataAsArrayElement = Pointer<Data>;
 
   static const MojomTypeCategory category = MojomTypeCategory::ARRAY;
 };
 
 template <typename T>
-struct MojomTypeTraits<AssociatedInterfacePtrInfo<T>, false> {
+struct MojomTypeTraits<AssociatedInterfacePtrInfoDataView<T>, false> {
   using Data = AssociatedInterface_Data;
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category =
       MojomTypeCategory::ASSOCIATED_INTERFACE;
 };
 
 template <typename T>
-struct MojomTypeTraits<AssociatedInterfaceRequest<T>, false> {
+struct MojomTypeTraits<AssociatedInterfaceRequestDataView<T>, false> {
   using Data = AssociatedInterfaceRequest_Data;
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category =
       MojomTypeCategory::ASSOCIATED_INTERFACE_REQUEST;
 };
 
 template <>
 struct MojomTypeTraits<bool, false> {
   using Data = bool;
@@ skipping 12 matching lines @@
 
 template <typename T>
 struct MojomTypeTraits<ScopedHandleBase<T>, false> {
   using Data = Handle_Data;
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category = MojomTypeCategory::HANDLE;
 };
 
 template <typename T>
-struct MojomTypeTraits<InterfacePtr<T>, false> {
+struct MojomTypeTraits<InterfacePtrDataView<T>, false> {
   using Data = Interface_Data;
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category = MojomTypeCategory::INTERFACE;
 };
 
 template <typename T>
-struct MojomTypeTraits<InterfaceRequest<T>, false> {
+struct MojomTypeTraits<InterfaceRequestDataView<T>, false> {
   using Data = Handle_Data;
   using DataAsArrayElement = Data;
 
   static const MojomTypeCategory category =
       MojomTypeCategory::INTERFACE_REQUEST;
 };
 
 template <typename K, typename V>
-struct MojomTypeTraits<Map<K, V>, false> {
+struct MojomTypeTraits<MapDataView<K, V>, false> {
   using Data = Map_Data<typename MojomTypeTraits<K>::DataAsArrayElement,
                         typename MojomTypeTraits<V>::DataAsArrayElement>;
   using DataAsArrayElement = Pointer<Data>;
 
   static const MojomTypeCategory category = MojomTypeCategory::MAP;
 };
 
 template <>
-struct MojomTypeTraits<String, false> {
+struct MojomTypeTraits<NativeStructDataView, false> {
+  using Data = internal::NativeStruct_Data;
+  using DataAsArrayElement = Pointer<Data>;
+
+  static const MojomTypeCategory category = MojomTypeCategory::STRUCT;
+};
+
+template <>
+struct MojomTypeTraits<StringDataView, false> {
   using Data = String_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,
-                                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,
-                                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;
 };
 
 template <typename T>
 struct EnumHashImpl {
   static_assert(std::is_enum<T>::value, "Incorrect hash function.");
 
   size_t operator()(T input) const {
     using UnderlyingType = typename base::underlying_type<T>::type;
     return std::hash<UnderlyingType>()(static_cast<UnderlyingType>(input));
   }
 };
 
-template <typename T>
-struct DataViewTraits {
-  using MojomType = T;
-};
-
-template <typename T>
-struct DataViewTraits<ArrayDataView<T>> {
-  using MojomType = Array<typename DataViewTraits<T>::MojomType>;
-};
-
-template <typename K, typename V>
-struct DataViewTraits<MapDataView<K, V>> {
-  using MojomType = Map<typename DataViewTraits<K>::MojomType,
-                        typename DataViewTraits<V>::MojomType>;
-};
-
-template <>
-struct DataViewTraits<StringDataView> {
-  using MojomType = String;
-};
-
-template <>
-struct DataViewTraits<NativeStructDataView> {
-  using MojomType = NativeStructPtr;
-};
-
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_