Mojo: Report bindings validation errors via MojoNotifyBadMessage

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>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "mojo/public/c/system/macros.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
-#include "mojo/public/cpp/bindings/lib/bounds_checker.h"
 #include "mojo/public/cpp/bindings/lib/buffer.h"
 #include "mojo/public/cpp/bindings/lib/serialization_util.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/public/cpp/bindings/lib/validate_params.h"
+#include "mojo/public/cpp/bindings/lib/validation_context.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
 #include "mojo/public/cpp/bindings/lib/validation_util.h"
 
 namespace mojo {
 namespace internal {
 
 // std::numeric_limits<uint32_t>::max() is not a compile-time constant (until
 // C++11).
 const uint32_t kMaxUint32 = 0xFFFFFFFF;
 
@@ skipping 107 matching lines @@
   typedef typename ArrayDataTraits<T>::StorageType ElementType;
 
   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,
+                               ValidationContext* validation_context,
                                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) {
-      if (!validate_params->validate_enum_func(elements[i]))
+      if (!validate_params->validate_enum_func(elements[i], validation_context))
         return false;
     }
     return true;
   }
 };
 
 template <>
 struct ArraySerializationHelper<Handle_Data, false> {
   typedef ArrayDataTraits<Handle_Data>::StorageType ElementType;
 
   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,
+                               ValidationContext* validation_context,
                                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_context,
             VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
             MakeMessageWithArrayIndex(
                 "invalid handle in array expecting valid handles",
                 header->num_elements,
                 i).c_str());
         return false;
       }
-      if (!bounds_checker->ClaimHandle(elements[i])) {
-        ReportValidationError(VALIDATION_ERROR_ILLEGAL_HANDLE);
+      if (!validation_context->ClaimHandle(elements[i])) {
+        ReportValidationError(validation_context,
+                              VALIDATION_ERROR_ILLEGAL_HANDLE);
         return false;
       }
     }
     return true;
   }
 };
 
 template <typename P>
 struct ArraySerializationHelper<P*, false> {
   typedef typename ArrayDataTraits<P*>::StorageType ElementType;
 
   static void EncodePointers(const ArrayHeader* header, ElementType* elements) {
     for (uint32_t i = 0; i < header->num_elements; ++i)
       Encode(&elements[i]);
   }
 
   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,
+                               ValidationContext* validation_context,
                                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_context,
             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);
+        ReportValidationError(validation_context,
+                              VALIDATION_ERROR_ILLEGAL_POINTER);
         return false;
       }
       if (!ValidateCaller<P>::Run(DecodePointerRaw(&elements[i].offset),
-                                  bounds_checker,
+                                  validation_context,
                                   validate_params->element_validate_params)) {
         return false;
       }
     }
     return true;
   }
 
  private:
   template <typename T>
   struct ValidateCaller {
     static bool Run(const void* data,
-                    BoundsChecker* bounds_checker,
+                    ValidationContext* validation_context,
                     const ContainerValidateParams* validate_params) {
       DCHECK(!validate_params)
           << "Struct type should not have array validate params";
 
-      return T::Validate(data, bounds_checker);
+      return T::Validate(data, validation_context);
     }
   };
 
   template <typename Key, typename Value>
   struct ValidateCaller<Map_Data<Key, Value>> {
     static bool Run(const void* data,
-                    BoundsChecker* bounds_checker,
+                    ValidationContext* validation_context,
                     const ContainerValidateParams* validate_params) {
-      return Map_Data<Key, Value>::Validate(data, bounds_checker,
+      return Map_Data<Key, Value>::Validate(data, validation_context,
                                             validate_params);
     }
   };
 
   template <typename T>
   struct ValidateCaller<Array_Data<T>> {
     static bool Run(const void* data,
-                    BoundsChecker* bounds_checker,
+                    ValidationContext* validation_context,
                     const ContainerValidateParams* validate_params) {
-      return Array_Data<T>::Validate(data, bounds_checker, validate_params);
+      return Array_Data<T>::Validate(data, validation_context, 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,
+                               ValidationContext* validation_context,
                                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_context,
             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))
+      if (!ElementType::Validate(elements + i, validation_context, true))
         return false;
     }
     return true;
   }
 };
 
 template <typename T>
 class Array_Data {
  public:
   using Traits = ArrayDataTraits<T>;
   using StorageType = typename Traits::StorageType;
   using Ref = typename Traits::Ref;
   using ConstRef = typename Traits::ConstRef;
   using Helper = ArraySerializationHelper<T, IsUnionDataType<T>::value>;
   using Element = T;
 
   // Returns null if |num_elements| or the corresponding storage size cannot be
   // stored in uint32_t.
   static Array_Data<T>* New(size_t num_elements, Buffer* buf) {
     if (num_elements > Traits::kMaxNumElements)
       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,
+                       ValidationContext* validation_context,
                        const ContainerValidateParams* validate_params) {
     if (!data)
       return true;
     if (!IsAligned(data)) {
-      ReportValidationError(VALIDATION_ERROR_MISALIGNED_OBJECT);
+      ReportValidationError(validation_context,
+                            VALIDATION_ERROR_MISALIGNED_OBJECT);
       return false;
     }
-    if (!bounds_checker->IsValidRange(data, sizeof(ArrayHeader))) {
-      ReportValidationError(VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE);
+    if (!validation_context->IsValidRange(data, sizeof(ArrayHeader))) {
+      ReportValidationError(validation_context,
+                            VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE);
       return false;
     }
     const ArrayHeader* header = static_cast<const ArrayHeader*>(data);
     if (header->num_elements > Traits::kMaxNumElements ||
         header->num_bytes < Traits::GetStorageSize(header->num_elements)) {
-      ReportValidationError(VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER);
+      ReportValidationError(validation_context,
+                            VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER);
       return false;
     }
     if (validate_params->expected_num_elements != 0 &&
         header->num_elements != validate_params->expected_num_elements) {
       ReportValidationError(
+          validation_context,
           VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER,
           MakeMessageWithExpectedArraySize(
               "fixed-size array has wrong number of elements",
               header->num_elements,
               validate_params->expected_num_elements).c_str());
       return false;
     }
-    if (!bounds_checker->ClaimMemory(data, header->num_bytes)) {
-      ReportValidationError(VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE);
+    if (!validation_context->ClaimMemory(data, header->num_bytes)) {
+      ReportValidationError(validation_context,
+                            VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE);
       return false;
     }
 
     const Array_Data<T>* object = static_cast<const Array_Data<T>*>(data);
     return Helper::ValidateElements(&object->header_, object->storage(),
-                                    bounds_checker, validate_params);
+                                    validation_context, validate_params);
   }
 
   size_t size() const { return header_.num_elements; }
 
   Ref at(size_t offset) {
     DCHECK(offset < static_cast<size_t>(header_.num_elements));
     return Traits::ToRef(storage(), offset);
   }
 
   ConstRef at(size_t offset) const {
@@ skipping 27 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_