Mojo C++ bindings: introduce mojo::WTFMap for blink bindings.

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/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"
 
 namespace mojo {
 namespace internal {
 
@@ skipping 58 matching lines @@
 };
 
 template <typename Key, typename Value, typename MaybeConstUserType>
 struct Serializer<Map<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 Map<Key, Value>::Data_;
   using KeyArraySerializer = ArraySerializer<Array<Key>,
-                                             Array<UserKey>,
+                                             std::vector<UserKey>,
                                              MapKeyReader<MaybeConstUserType>>;
   using ValueArraySerializer =
       ArraySerializer<Array<Value>,
-                      Array<UserValue>,
+                      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);
     size_t keys_size =
@@ skipping 38 matching lines @@
     }
     *output = result;
   }
 
   static bool Deserialize(Data* input,
                           UserType* output,
                           SerializationContext* context) {
     if (!input)
       return CallSetToNullIfExists<Traits>(output);
 
-    Array<UserKey> keys;
-    Array<UserValue> values;
+    std::vector<UserKey> keys;
+    std::vector<UserValue> values;
 
     if (!KeyArraySerializer::DeserializeElements(input->keys.ptr, &keys,
                                                  context) ||
         !ValueArraySerializer::DeserializeElements(input->values.ptr, &values,
                                                    context)) {
       return false;
     }
 
     DCHECK_EQ(keys.size(), values.size());
     size_t size = keys.size();
     Traits::SetToEmpty(output);
 
-    for (size_t i = 0; i < size; ++i)
-      Traits::Insert(*output, std::move(keys[i]), std::move(values[i]));
+    for (size_t i = 0; i < size; ++i) {
+      if (!Traits::Insert(*output, std::move(keys[i]), std::move(values[i])))
+        return false;
+    }
     return true;
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_SERIALIZATION_H_