mojom: Add associative arrays to the mojom language.

mojo/public/cpp/bindings/lib/array_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_ARRAY_SERIALIZATION_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
 
 #include <string.h>  // For |memcpy()|.
 
 #include <vector>
 
 #include "mojo/public/c/system/macros.h"
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
+#include "mojo/public/cpp/bindings/lib/map_serialization.h"
 #include "mojo/public/cpp/bindings/lib/string_serialization.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
 
 namespace mojo {
 
 template <typename E>
 inline size_t GetSerializedSize_(const Array<E>& input);
 
 // Because ValidateParams requires explicit argument specification, the
 // argument-dependent loopup technique used to omit namespace when calling
 // Serialize_() doesn't seem to work. Therefore, this function is named
 // differently from those Serialize_() overloads.
 template <typename ValidateParams, typename E, typename F>
 inline void SerializeArray_(Array<E> input,
                             internal::Buffer* buf,
                             internal::Array_Data<F>** output);
 
+template <typename ValueValidateParams,
+          typename KeyWrapperType,
+          typename ValueWrapperType,
+          typename KeySerializationType,
+          typename ValueSerializationType>
+inline void SerializeMap_(
+    Map<KeyWrapperType, ValueWrapperType> input,
+    internal::Buffer* buf,
+    internal::Map_Data<KeySerializationType, ValueSerializationType>** output);
+
 template <typename E, typename F>
 inline void Deserialize_(internal::Array_Data<F>* data, Array<E>* output);
 
 namespace internal {
 
 template <typename E, typename F, bool move_only = IsMoveOnlyType<E>::value>
 struct ArraySerializer;
 
 template <typename E, typename F>
 struct ArraySerializer<E, F, false> {
@@ skipping 128 matching lines @@
   };
 
   template <typename T, typename Params>
   struct SerializeCaller<Array<T>, Params> {
     static void Run(Array<T> input,
                     Buffer* buf,
                     typename Array<T>::Data_** output) {
       SerializeArray_<Params>(input.Pass(), buf, output);
     }
   };
+
+  template <typename T, typename U, typename Params>
+  struct SerializeCaller<Map<T, U>, Params> {
+    static void Run(Map<T, U> input,
+                    Buffer* buf,
+                    typename Map<T, U>::Data_** output) {
+      SerializeMap_<Params>(input.Pass(), buf, output);
+    }
+  };
 };
 
 template <>
 struct ArraySerializer<String, String_Data*, false> {
   static size_t GetSerializedSize(const Array<String>& input) {
     size_t size = sizeof(Array_Data<String_Data*>) +
                   input.size() * sizeof(internal::StringPointer);
     for (size_t i = 0; i < input.size(); ++i)
       size += GetSerializedSize_(input[i]);
     return size;
@@ skipping 70 matching lines @@
   if (input) {
     internal::ArraySerializer<E, F>::DeserializeElements(input, output);
   } else {
     output->reset();
   }
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_