Mojo cpp bindings: remove redundant validation in Decode*().

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>
 
@@ skipping 88 matching lines @@
 
 template <typename T>
 struct ArraySerializationHelper<T, false> {
   typedef typename ArrayDataTraits<T>::StorageType ElementType;
 
   static void EncodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        std::vector<Handle>* handles) {
   }
 
-  static bool DecodePointersAndHandles(const ArrayHeader* header,
+  static void DecodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
-                                       Message* message) {
-    return true;
+                                       std::vector<Handle>* handles) {
   }
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                BoundsChecker* bounds_checker) {
     return true;
   }
 };
 
 template <>
 struct ArraySerializationHelper<Handle, true> {
   typedef ArrayDataTraits<Handle>::StorageType ElementType;
 
   static void EncodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        std::vector<Handle>* handles);
 
-  static bool DecodePointersAndHandles(const ArrayHeader* header,
+  static void DecodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
-                                       Message* message);
+                                       std::vector<Handle>* handles);
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                BoundsChecker* bounds_checker);
 };
 
 template <typename H>
 struct ArraySerializationHelper<H, true> {
   typedef typename ArrayDataTraits<H>::StorageType ElementType;
 
   static void EncodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        std::vector<Handle>* handles) {
     ArraySerializationHelper<Handle, true>::EncodePointersAndHandles(
         header, elements, handles);
   }
 
-  static bool DecodePointersAndHandles(const ArrayHeader* header,
+  static void DecodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
-                                       Message* message) {
-    return ArraySerializationHelper<Handle, true>::DecodePointersAndHandles(
-        header, elements, message);
+                                       std::vector<Handle>* handles) {
+    ArraySerializationHelper<Handle, true>::DecodePointersAndHandles(
+        header, elements, handles);
   }
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                BoundsChecker* bounds_checker) {
     return ArraySerializationHelper<Handle, true>::ValidateElements(
         header, elements, bounds_checker);
   }
 };
 
 template <typename P>
 struct ArraySerializationHelper<P*, false> {
   typedef typename ArrayDataTraits<P*>::StorageType ElementType;
 
   static void EncodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        std::vector<Handle>* handles) {
     for (uint32_t i = 0; i < header->num_elements; ++i)
       Encode(&elements[i], handles);
   }
 
-  static bool DecodePointersAndHandles(const ArrayHeader* header,
+  static void DecodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
-                                       Message* message) {
-    for (uint32_t i = 0; i < header->num_elements; ++i) {
-      if (!Decode(&elements[i], message))
-        return false;
-    }
-    return true;
+                                       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)) {
         return false;
       }
@@ skipping 57 matching lines @@
 
   const StorageType* storage() const {
     return reinterpret_cast<const StorageType*>(
         reinterpret_cast<const char*>(this) + sizeof(*this));
   }
 
   void EncodePointersAndHandles(std::vector<Handle>* handles) {
     Helper::EncodePointersAndHandles(&header_, storage(), handles);
   }
 
-  bool DecodePointersAndHandles(Message* message) {
-    return Helper::DecodePointersAndHandles(&header_, storage(), message);
+  void DecodePointersAndHandles(std::vector<Handle>* handles) {
+    Helper::DecodePointersAndHandles(&header_, storage(), handles);
   }
 
  private:
   Array_Data(size_t num_bytes, size_t num_elements) {
     header_.num_bytes = static_cast<uint32_t>(num_bytes);
     header_.num_elements = static_cast<uint32_t>(num_elements);
   }
   ~Array_Data() {}
 
   internal::ArrayHeader header_;
@@ skipping 47 matching lines @@
 };
 
 template <> struct WrapperTraits<String, false> {
   typedef String_Data* DataType;
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_