Mojo C++ bindings: rename ArrayValidateParams for clarity

mojo/public/cpp/bindings/lib/array_internal.h

 // Copyright 2013 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_INTERNAL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <new>
@@ skipping 129 matching lines @@
 
   static void EncodePointers(const ArrayHeader* header,
                              ElementType* elements) {}
 
   static void DecodePointers(const ArrayHeader* header,
                              ElementType* elements) {}
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                BoundsChecker* bounds_checker,
-                               const ArrayValidateParams* validate_params) {
+                               const ContainerValidateParams* validate_params) {
     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";
 
     if (!validate_params->validate_enum_func)
       return true;
 
     // Enum validation.
     for (uint32_t i = 0; i < header->num_elements; ++i) {
@@ skipping 10 matching lines @@
 
   static void EncodePointers(const ArrayHeader* header,
                              ElementType* elements) {}
 
   static void DecodePointers(const ArrayHeader* header,
                              ElementType* elements) {}
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                BoundsChecker* bounds_checker,
-                               const ArrayValidateParams* validate_params) {
+                               const ContainerValidateParams* validate_params) {
     DCHECK(!validate_params->element_validate_params)
         << "Handle type should not have array validate params";
 
     for (uint32_t i = 0; i < header->num_elements; ++i) {
       if (!validate_params->element_is_nullable && !elements[i].is_valid()) {
         ReportValidationError(
             VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
             MakeMessageWithArrayIndex(
                 "invalid handle in array expecting valid handles",
                 header->num_elements,
@@ skipping 19 matching lines @@
   }
 
   static void DecodePointers(const ArrayHeader* header, ElementType* elements) {
     for (uint32_t i = 0; i < header->num_elements; ++i)
       Decode(&elements[i]);
   }
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                BoundsChecker* bounds_checker,
-                               const ArrayValidateParams* validate_params) {
+                               const ContainerValidateParams* validate_params) {
     for (uint32_t i = 0; i < header->num_elements; ++i) {
       if (!validate_params->element_is_nullable && !elements[i].offset) {
         ReportValidationError(
             VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
             MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                       header->num_elements,
                                       i).c_str());
         return false;
       }
       if (!ValidateEncodedPointer(&elements[i].offset)) {
         ReportValidationError(VALIDATION_ERROR_ILLEGAL_POINTER);
         return false;
       }
       if (!ValidateCaller<P>::Run(DecodePointerRaw(&elements[i].offset),
                                   bounds_checker,
                                   validate_params->element_validate_params)) {
         return false;
       }
     }
     return true;
   }
 
  private:
   template <typename T>
   struct ValidateCaller {
     static bool Run(const void* data,
                     BoundsChecker* bounds_checker,
-                    const ArrayValidateParams* validate_params) {
+                    const ContainerValidateParams* validate_params) {
       DCHECK(!validate_params)
           << "Struct type should not have array validate params";
 
       return T::Validate(data, bounds_checker);
     }
   };
 
   template <typename Key, typename Value>
   struct ValidateCaller<Map_Data<Key, Value>> {
     static bool Run(const void* data,
                     BoundsChecker* bounds_checker,
-                    const ArrayValidateParams* validate_params) {
+                    const ContainerValidateParams* validate_params) {
       return Map_Data<Key, Value>::Validate(data, bounds_checker,
                                             validate_params);
     }
   };
 
   template <typename T>
   struct ValidateCaller<Array_Data<T>> {
     static bool Run(const void* data,
                     BoundsChecker* bounds_checker,
-                    const ArrayValidateParams* validate_params) {
+                    const ContainerValidateParams* validate_params) {
       return Array_Data<T>::Validate(data, bounds_checker, validate_params);
     }
   };
 };
 
 template <typename U>
 struct ArraySerializationHelper<U, true> {
   typedef typename ArrayDataTraits<U>::StorageType ElementType;
 
   static void EncodePointers(const ArrayHeader* header, ElementType* elements) {
     for (uint32_t i = 0; i < header->num_elements; ++i)
       elements[i].EncodePointers();
   }
 
   static void DecodePointers(const ArrayHeader* header, ElementType* elements) {
     for (uint32_t i = 0; i < header->num_elements; ++i)
       elements[i].DecodePointers();
   }
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                BoundsChecker* bounds_checker,
-                               const ArrayValidateParams* validate_params) {
+                               const ContainerValidateParams* validate_params) {
     for (uint32_t i = 0; i < header->num_elements; ++i) {
       if (!validate_params->element_is_nullable && elements[i].is_null()) {
         ReportValidationError(
             VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
             MakeMessageWithArrayIndex("null in array expecting valid unions",
                                       header->num_elements, i)
                 .c_str());
         return false;
       }
       if (!ElementType::Validate(elements + i, bounds_checker, true))
@@ skipping 20 matching lines @@
       return nullptr;
 
     uint32_t num_bytes =
         Traits::GetStorageSize(static_cast<uint32_t>(num_elements));
     return new (buf->Allocate(num_bytes))
         Array_Data<T>(num_bytes, static_cast<uint32_t>(num_elements));
   }
 
   static bool Validate(const void* data,
                        BoundsChecker* bounds_checker,
-                       const ArrayValidateParams* validate_params) {
+                       const ContainerValidateParams* validate_params) {
     if (!data)
       return true;
     if (!IsAligned(data)) {
       ReportValidationError(VALIDATION_ERROR_MISALIGNED_OBJECT);
       return false;
     }
     if (!bounds_checker->IsValidRange(data, sizeof(ArrayHeader))) {
       ReportValidationError(VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE);
       return false;
     }
@@ skipping 61 matching lines @@
 };
 static_assert(sizeof(Array_Data<char>) == 8, "Bad sizeof(Array_Data)");
 
 // UTF-8 encoded
 using String_Data = Array_Data<char>;
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_