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

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 "mojo/public/cpp/bindings/lib/array_internal.h"
+#include "mojo/public/cpp/bindings/lib/array_serialization.h"
 #include "mojo/public/cpp/bindings/lib/map_internal.h"
 
 namespace mojo {
 namespace internal {
 
 template <typename MapType, typename DataType,
           bool kValueIsMoveOnlyType = IsMoveOnlyType<MapType>::value>
 struct MapSerializer;
 
 template <typename MapType, typename DataType>
@@ skipping 66 matching lines @@
 struct SizeAccumulator {
   SizeAccumulator(size_t* data_size) : size(data_size) {}
   size_t* size;
 
   void operator()(const MapKey& key, const MapValue& value) {
     *size += internal::MapSerializer<MapKey, DataKey>::GetItemSize(key);
     *size += internal::MapSerializer<MapValue, DataValue>::GetItemSize(value);
   }
 };
 
+
+template <typename MapKey>
+struct MapKeyValidateParams {
+ public:
+  typedef NoValidateParams ElementValidateParams;
+  static const uint32_t expected_num_elements = 0;
+  static const bool element_is_nullable = false;
+};
+
+
+template <> struct MapKeyValidateParams<String> {
+ public:
+  typedef ArrayValidateParams<0, false, NoValidateParams> ElementValidateParams;
+  static const uint32_t expected_num_elements = 0;
+  static const bool element_is_nullable = false;
+};
+
 }  // namespace internal
 
 template <typename MapKey, typename MapValue>
 inline size_t GetSerializedSize_(const Map<MapKey, MapValue>& input) {
   if (!input)
     return 0;
   typedef typename internal::WrapperTraits<MapKey>::DataType DataKey;
   typedef typename internal::WrapperTraits<MapValue>::DataType DataValue;
 
   size_t count = input.size();
@@ skipping 13 matching lines @@
     value_data_size +=
         internal::MapSerializer<MapValue, DataValue>::GetItemSize(
             it.GetValue());
   }
 
   return key_base_size + key_data_size +
       // SOME SORT OF ALIGNMENT GOES HERE?
       value_base_size + value_data_size;
 }
 
+
+// We don't need a KeyValidateParams, because we konw exactly what params are
+// needed. (Keys are primitive types or non-nullable strings.)
+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) {
+  if (input) {
+    Array<KeyWrapperType> keys;
+    Array<ValueWrapperType> values;
+    input.DecomposeMapTo(&keys, &values);
+    SerializeArray_<internal::MapKeyValidateParams<KeyWrapperType>>(
+        keys.Pass(), buf, &output->keys.ptr);
+    SerializeArray_<ValueValidateParams>(values.Pass(), buf,
+                                         &output->values.ptr);
+  } else {
+    output->keys.ptr = nullptr;
+    output->values.ptr = nullptr;
+  }
+}
+
+template <typename KeyWrapperType,
+          typename ValueWrapperType,
+          typename KeySerializationType,
+          typename ValueSerializationType>
+inline void Deserialize_(
+    internal::MapPointerPair<KeySerializationType,
+                             ValueSerializationType>* input,
+    Map<KeyWrapperType, ValueWrapperType>* output) {
+  if (input) {
+    Array<KeyWrapperType> keys;
+    Array<ValueWrapperType> values;
+
+    Deserialize_(input->keys.ptr, &keys);
+    Deserialize_(input->values.ptr, &values);
+
+    *output = Map<KeyWrapperType, ValueWrapperType>(keys.Pass(), values.Pass());
+  } else {
+    output->reset();
+  }
+}
+
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_SERIALIZATION_H_