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

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

 // Copyright 2014 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_MAP_SERIALIZATION_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_SERIALIZATION_H_
 
 #include <type_traits>
 #include <vector>
 
-#include "mojo/public/cpp/bindings/array.h"
+#include "mojo/public/cpp/bindings/array_data_view.h"
 #include "mojo/public/cpp/bindings/lib/array_serialization.h"
 #include "mojo/public/cpp/bindings/lib/map_data_internal.h"
 #include "mojo/public/cpp/bindings/lib/serialization_forward.h"
-#include "mojo/public/cpp/bindings/map.h"
+#include "mojo/public/cpp/bindings/map_data_view.h"
 
 namespace mojo {
 namespace internal {
 
 template <typename MaybeConstUserType>
 class MapReaderBase {
  public:
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Traits = MapTraits<UserType>;
   using MaybeConstIterator =
@@ skipping 48 matching lines @@
   using GetNextResult =
       decltype(Traits::GetValue(std::declval<MaybeConstIterator&>()));
   GetNextResult GetNext() {
     GetNextResult value = Traits::GetValue(this->iter_);
     Traits::AdvanceIterator(this->iter_);
     return value;
   }
 };
 
 template <typename Key, typename Value, typename MaybeConstUserType>
-struct Serializer<Map<Key, Value>, MaybeConstUserType> {
+struct Serializer<MapDataView<Key, Value>, MaybeConstUserType> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Traits = MapTraits<UserType>;
   using UserKey = typename Traits::Key;
   using UserValue = typename Traits::Value;
-  using Data = typename MojomTypeTraits<Map<Key, Value>>::Data;
-  using KeyArraySerializer = ArraySerializer<Array<Key>,
+  using Data = typename MojomTypeTraits<MapDataView<Key, Value>>::Data;
+  using KeyArraySerializer = ArraySerializer<ArrayDataView<Key>,
                                              std::vector<UserKey>,
                                              MapKeyReader<MaybeConstUserType>>;
   using ValueArraySerializer =
-      ArraySerializer<Array<Value>,
+      ArraySerializer<ArrayDataView<Value>,
                       std::vector<UserValue>,
                       MapValueReader<MaybeConstUserType>>;
 
   static size_t PrepareToSerialize(MaybeConstUserType& input,
                                    SerializationContext* context) {
     if (CallIsNullIfExists<Traits>(input))
       return 0;
 
     size_t struct_overhead = sizeof(Data);
     MapKeyReader<MaybeConstUserType> key_reader(input);
@@ skipping 13 matching lines @@
                         SerializationContext* context) {
     DCHECK(validate_params->key_validate_params);
     DCHECK(validate_params->element_validate_params);
     if (CallIsNullIfExists<Traits>(input)) {
       *output = nullptr;
       return;
     }
 
     auto result = Data::New(buf);
     if (result) {
-      auto keys_ptr =
-          MojomTypeTraits<Array<Key>>::Data::New(Traits::GetSize(input), buf);
+      auto keys_ptr = MojomTypeTraits<ArrayDataView<Key>>::Data::New(
+          Traits::GetSize(input), buf);
       if (keys_ptr) {
         MapKeyReader<MaybeConstUserType> key_reader(input);
         KeyArraySerializer::SerializeElements(
             &key_reader, buf, keys_ptr, validate_params->key_validate_params,
             context);
         result->keys.Set(keys_ptr);
       }
 
-      auto values_ptr =
-          MojomTypeTraits<Array<Value>>::Data::New(Traits::GetSize(input), buf);
+      auto values_ptr = MojomTypeTraits<ArrayDataView<Value>>::Data::New(
+          Traits::GetSize(input), buf);
       if (values_ptr) {
         MapValueReader<MaybeConstUserType> value_reader(input);
         ValueArraySerializer::SerializeElements(
             &value_reader, buf, values_ptr,
             validate_params->element_validate_params, context);
         result->values.Set(values_ptr);
       }
     }
     *output = result;
   }
@@ skipping 23 matching lines @@
         return false;
     }
     return true;
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_SERIALIZATION_H_