Mojo cpp bindings: report the reason of validation failure.

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 <new>
 #include <vector>
 
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/bindings_serialization.h"
 #include "mojo/public/cpp/bindings/lib/bounds_checker.h"
 #include "mojo/public/cpp/bindings/lib/buffer.h"
+#include "mojo/public/cpp/bindings/lib/validation_errors.h"
 
 namespace mojo {
 template <typename T> class Array;
 class String;
 
 namespace internal {
 
 template <typename T>
 struct ArrayDataTraits {
   typedef T StorageType;
@@ skipping 151 matching lines @@
                                        ElementType* elements,
                                        std::vector<Handle>* handles) {
     for (uint32_t i = 0; i < header->num_elements; ++i)
       Decode(&elements[i], handles);
   }
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                BoundsChecker* bounds_checker) {
     for (uint32_t i = 0; i < header->num_elements; ++i) {
-      if (!ValidateEncodedPointer(&elements[i].offset) ||
-          !P::Validate(DecodePointerRaw(&elements[i].offset), bounds_checker)) {
+      if (!ValidateEncodedPointer(&elements[i].offset)) {
+        ReportValidationError(VALIDATION_ERROR_ILLEGAL_POINTER);
         return false;
       }
+      if (!P::Validate(DecodePointerRaw(&elements[i].offset), bounds_checker))
+        return false;
     }
     return true;
   }
 };
 
 template <typename T>
 class Array_Data {
  public:
   typedef ArrayDataTraits<T> Traits;
   typedef typename Traits::StorageType StorageType;
   typedef typename Traits::Ref Ref;
   typedef typename Traits::ConstRef ConstRef;
   typedef ArraySerializationHelper<T, IsHandle<T>::value> Helper;
 
   static Array_Data<T>* New(size_t num_elements, Buffer* buf) {
     size_t num_bytes = sizeof(Array_Data<T>) +
                        Traits::GetStorageSize(num_elements);
     return new (buf->Allocate(num_bytes)) Array_Data<T>(num_bytes,
                                                         num_elements);
   }
 
   static bool Validate(const void* data, BoundsChecker* bounds_checker) {
     if (!data)
       return true;
-    if (!IsAligned(data))
+    if (!IsAligned(data)) {
+      ReportValidationError(VALIDATION_ERROR_MISALIGNED_OBJECT);
       return false;
-    if (!bounds_checker->IsValidRange(data, sizeof(ArrayHeader)))
+    }
+    if (!bounds_checker->IsValidRange(data, sizeof(ArrayHeader))) {
+      ReportValidationError(VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE);
       return false;
+    }
     const ArrayHeader* header = static_cast<const ArrayHeader*>(data);
     if (header->num_bytes < (sizeof(Array_Data<T>) +
                              Traits::GetStorageSize(header->num_elements))) {
+      ReportValidationError(VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER);
       return false;
     }
-    if (!bounds_checker->ClaimMemory(data, header->num_bytes))
+    if (!bounds_checker->ClaimMemory(data, header->num_bytes)) {
+      ReportValidationError(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);
   }
 
   size_t size() const { return header_.num_elements; }
 
   Ref at(size_t offset) {
     assert(offset < static_cast<size_t>(header_.num_elements));
@@ skipping 81 matching lines @@
 };
 
 template <> struct WrapperTraits<String, false> {
   typedef String_Data* DataType;
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_