Mojo C++ bindings: support Arrays that contain Maps.

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/bindings_internal.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 E, typename F>
 inline void Deserialize_(internal::Array_Data<F>* data, Array<E>* output);
 
+template <typename ValueValidateParams,
+          typename KeyWrapperType,
+          typename ValueWrapperType,
+          typename KeySerializationType,
+          typename ValueSerializationType>
+inline void SerializeMap_(
+    Map<KeyWrapperType, ValueWrapperType> input,
+    internal::Buffer* buf,
+    internal::MapPointerPair<KeySerializationType,
+                             ValueSerializationType>* 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> {
   MOJO_COMPILE_ASSERT(sizeof(E) == sizeof(F), wrong_array_serializer);
   static size_t GetSerializedSize(const Array<E>& input) {
     return sizeof(Array_Data<F>) + Align(input.size() * sizeof(E));
   }
@@ skipping 161 matching lines @@
   }
   static void DeserializeElements(
       Array_Data<String_Data*>* input, Array<String>* output) {
     Array<String> result(input->size());
     for (size_t i = 0; i < input->size(); ++i)
       Deserialize_(input->at(i), &result[i]);
     output->Swap(&result);
   }
 };
 
+template <typename KeyWrapperType, typename ValueWrapperType,
+          typename KeySerializationType, typename ValueSerializationType>
+    struct ArraySerializer<
+        Map<KeyWrapperType, ValueWrapperType>,
+        MapPointerPair<KeySerializationType, ValueSerializationType>,
+        true> {
+  static size_t GetSerializedSize(
+      const Array<Map<KeyWrapperType, ValueWrapperType>>& input) {
+    size_t size = sizeof(ArrayHeader) +
+        input.size() * sizeof(MapPointerPair<KeySerializationType,
+                                             ValueSerializationType>);
+    for (size_t i = 0; i < input.size(); ++i)
+      size += GetSerializedSize_(input[i]);
+    return size;
+  }
+
+  template <bool element_is_nullable, typename ElementValidateParams>
+  static void SerializeElements(
+      Array<Map<KeyWrapperType, ValueWrapperType>> input,
+      Buffer* buf,
+      Array_Data<MapPointerPair<KeySerializationType,
+                                ValueSerializationType>>* output) {
+    for (size_t i = 0; i < input.size(); ++i) {
+      MapPointerPair<KeySerializationType, ValueSerializationType> element;
+      SerializeMap_<ElementValidateParams>(input[i].Pass(), buf, &element);
+      output->at(i) = element;
+      MOJO_DCHECK(!!element.keys.ptr == !!element.values.ptr);
+      MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
+          !element_is_nullable && !element.keys.ptr,
+          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+          MakeMessageWithArrayIndex(
+              "null in array expecting valid pointers", input.size(), i));
+    }
+  }
+
+  static void DeserializeElements(
+      Array_Data<
+          MapPointerPair<KeySerializationType, ValueSerializationType>>* input,
+      Array<Map<KeyWrapperType, ValueWrapperType>>* output) {
+    Array<Map<KeyWrapperType, ValueWrapperType>> result(input->size());
+    for (size_t i = 0; i < input->size(); ++i) {
+      Map<KeyWrapperType, ValueWrapperType> element;
+      Deserialize_(&input->at(i), &element);
+      result[i] = element.Pass();
+    }
+    output->Swap(&result);
+  }
+};
+
 }  // namespace internal
 
 template <typename E>
 inline size_t GetSerializedSize_(const Array<E>& input) {
   if (!input)
     return 0;
   typedef typename internal::WrapperTraits<E>::DataType F;
   return internal::ArraySerializer<E, F>::GetSerializedSize(input);
 }
 
@@ skipping 28 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_