Mojo C++ bindings: rename ArrayValidateParams for clarity

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 <stddef.h>
 #include <string.h>  // For |memcpy()|.
 
@@ skipping 95 matching lines @@
                 "Incorrect array serializer");
 
   static size_t GetSerializedSize(UserTypeReader* input,
                                   SerializationContext* context) {
     return sizeof(Data) + Align(input->GetSize() * sizeof(DataElement));
   }
 
   static void SerializeElements(UserTypeReader* input,
                                 Buffer* buf,
                                 Data* output,
-                                const ArrayValidateParams* validate_params,
+                                const ContainerValidateParams* validate_params,
                                 SerializationContext* context) {
     DCHECK(!validate_params->element_is_nullable)
         << "Primitive type should be non-nullable";
     DCHECK(!validate_params->element_validate_params)
         << "Primitive type should not have array validate params";
 
     size_t size = input->GetSize();
     if (size == 0)
       return;
 
@@ skipping 39 matching lines @@
                 "Incorrect array serializer");
 
   static size_t GetSerializedSize(UserTypeReader* input,
                                   SerializationContext* context) {
     return sizeof(Data) + Align((input->GetSize() + 7) / 8);
   }
 
   static void SerializeElements(UserTypeReader* input,
                                 Buffer* buf,
                                 Data* output,
-                                const ArrayValidateParams* validate_params,
+                                const ContainerValidateParams* validate_params,
                                 SerializationContext* context) {
     DCHECK(!validate_params->element_is_nullable)
         << "Primitive type should be non-nullable";
     DCHECK(!validate_params->element_validate_params)
         << "Primitive type should not have array validate params";
 
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i)
       output->at(i) = input->GetNext();
   }
@@ skipping 25 matching lines @@
 
   static size_t GetSerializedSize(UserTypeReader* input,
                                   SerializationContext* context) {
     return sizeof(Data) +
            Align(input->GetSize() * sizeof(typename Data::Element));
   }
 
   static void SerializeElements(UserTypeReader* input,
                                 Buffer* buf,
                                 Data* output,
-                                const ArrayValidateParams* validate_params,
+                                const ContainerValidateParams* validate_params,
                                 SerializationContext* context) {
     DCHECK(!validate_params->element_validate_params)
         << "Handle type should not have array validate params";
 
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i) {
       // Transfer ownership of the handle.
       output->at(i) = context->handles.AddHandle(input->GetNext().release());
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !output->at(i).is_valid(),
@@ skipping 38 matching lines @@
         element_count *
             sizeof(Pointer<typename std::remove_pointer<DataElement>::type>);
     for (size_t i = 0; i < element_count; ++i)
       size += PrepareToSerialize<Element>(input->GetNext(), context);
     return size;
   }
 
   static void SerializeElements(UserTypeReader* input,
                                 Buffer* buf,
                                 Data* output,
-                                const ArrayValidateParams* validate_params,
+                                const ContainerValidateParams* validate_params,
                                 SerializationContext* context) {
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i) {
       DataElement element;
       SerializeCaller<Element>::Run(input->GetNext(), buf, &element,
                                     validate_params->element_validate_params,
                                     context);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !element,
@@ skipping 21 matching lines @@
 
  private:
   template <typename T,
             bool is_array_or_map = IsSpecializationOf<Array, T>::value ||
                                    IsSpecializationOf<Map, T>::value>
   struct SerializeCaller {
     template <typename InputElementType>
     static void Run(InputElementType&& input,
                     Buffer* buf,
                     DataElement* output,
-                    const ArrayValidateParams* validate_params,
+                    const ContainerValidateParams* validate_params,
                     SerializationContext* context) {
       Serialize<T>(std::forward<InputElementType>(input), buf, output, context);
     }
   };
 
   template <typename T>
   struct SerializeCaller<T, true> {
     template <typename InputElementType>
     static void Run(InputElementType&& input,
                     Buffer* buf,
                     DataElement* output,
-                    const ArrayValidateParams* validate_params,
+                    const ContainerValidateParams* validate_params,
                     SerializationContext* context) {
       Serialize<T>(std::forward<InputElementType>(input), buf, output,
                    validate_params, context);
     }
   };
 };
 
 // Handles serialization and deserialization of arrays of unions.
 template <typename MojomType,
           typename MaybeConstUserType,
@@ skipping 19 matching lines @@
       // Call with |inlined| set to false, so that it will account for both the
       // data in the union and the space in the array used to hold the union.
       size += PrepareToSerialize<Element>(input->GetNext(), false, context);
     }
     return size;
   }
 
   static void SerializeElements(UserTypeReader* input,
                                 Buffer* buf,
                                 Data* output,
-                                const ArrayValidateParams* validate_params,
+                                const ContainerValidateParams* validate_params,
                                 SerializationContext* context) {
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i) {
       typename Data::Element* result = output->storage() + i;
       Serialize<Element>(input->GetNext(), buf, &result, true, context);
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && output->at(i).is_null(),
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid unions",
                                     size, i));
@@ skipping 31 matching lines @@
                                    SerializationContext* context) {
     if (CallIsNullIfExists<Traits>(input))
       return 0;
     ArrayReader<MaybeConstUserType> reader(input);
     return Impl::GetSerializedSize(&reader, context);
   }
 
   static void Serialize(MaybeConstUserType& input,
                         Buffer* buf,
                         Data** output,
-                        const ArrayValidateParams* validate_params,
+                        const ContainerValidateParams* validate_params,
                         SerializationContext* context) {
     if (!CallIsNullIfExists<Traits>(input)) {
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           validate_params->expected_num_elements != 0 &&
               Traits::GetSize(input) != validate_params->expected_num_elements,
           internal::VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER,
           internal::MakeMessageWithExpectedArraySize(
               "fixed-size array has wrong number of elements",
               Traits::GetSize(input), validate_params->expected_num_elements));
       Data* result = Data::New(Traits::GetSize(input), buf);
@@ skipping 13 matching lines @@
     if (!input)
       return CallSetToNullIfExists<Traits>(output);
     return Impl::DeserializeElements(input, output, context);
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_