Validate map keys in C++ Mojo 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 "mojo/public/cpp/bindings/array.h"
@@ skipping 95 matching lines @@
 
     return struct_overhead + keys_size + values_size;
   }
 
   // We don't need an ArrayValidateParams instance for key validation since
   // we can deduce it from the Key type. (which can only be primitive types or
   // non-nullable strings.)
   static void Serialize(MaybeConstUserType& input,
                         Buffer* buf,
                         Data** output,
-                        const ArrayValidateParams* value_validate_params,
+                        const ArrayValidateParams* validate_params,
                         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) {
       result->keys.ptr = Array<Key>::Data_::New(Traits::GetSize(input), buf);
       if (result->keys.ptr) {
-        const ArrayValidateParams* key_validate_params =
-            MapKeyValidateParamsFactory<
-                typename GetDataTypeAsArrayElement<Key>::Data>::Get();
         MapKeyReader<MaybeConstUserType> key_reader(input);
         KeyArraySerializer::SerializeElements(
-            &key_reader, buf, result->keys.ptr, key_validate_params, context);
+            &key_reader, buf, result->keys.ptr,
+            validate_params->key_validate_params, context);
       }
 
       result->values.ptr =
           Array<Value>::Data_::New(Traits::GetSize(input), buf);
       if (result->values.ptr) {
         MapValueReader<MaybeConstUserType> value_reader(input);
-        ValueArraySerializer::SerializeElements(&value_reader, buf,
-                                                result->values.ptr,
-                                                value_validate_params, context);
+        ValueArraySerializer::SerializeElements(
+            &value_reader, buf, result->values.ptr,
+            validate_params->element_validate_params, context);
       }
     }
     *output = result;
   }
 
   static bool Deserialize(Data* input,
                           UserType* output,
                           SerializationContext* context) {
     if (!input)
       return CallSetToNullIfExists<Traits>(output);
@@ skipping 15 matching lines @@
     for (size_t i = 0; i < size; ++i)
       Traits::Insert(*output, std::move(keys[i]), std::move(values[i]));
     return true;
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_SERIALIZATION_H_