mojo ArrayTraits<T>::Resize returns bool indicating success

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 119 matching lines @@
       memcpy(output->storage(), data, size * sizeof(DataElement));
     } else {
       for (size_t i = 0; i < size; ++i)
         output->at(i) = static_cast<DataElement>(input->GetNext());
     }
   }
 
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
-    Traits::Resize(*output, input->size());
+    if (!Traits::Resize(*output, input->size()))
+      return false;
     if (input->size()) {
       auto data = CallGetDataIfExists<Traits>(*output);
       if (data) {
         memcpy(data, input->storage(), input->size() * sizeof(DataElement));
       } else {
         for (size_t i = 0; i < input->size(); ++i)
           Traits::GetAt(*output, i) = static_cast<Element>(input->at(i));
       }
     }
     return true;
@@ skipping 30 matching lines @@
     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();
   }
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
-    Traits::Resize(*output, input->size());
+    if (!Traits::Resize(*output, input->size()))
+      return false;
     for (size_t i = 0; i < input->size(); ++i)
       Traits::GetAt(*output, i) = input->at(i);
     return true;
   }
 };
 
 // Serializes and deserializes arrays of handles.
 template <typename MojomType,
           typename MaybeConstUserType,
           typename UserTypeReader>
@@ skipping 31 matching lines @@
           !validate_params->element_is_nullable && !output->at(i).is_valid(),
           VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
           MakeMessageWithArrayIndex(
               "invalid handle in array expecting valid handles", size, i));
     }
   }
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
     using HandleType = typename Element::RawHandleType;
-    Traits::Resize(*output, input->size());
+    if (!Traits::Resize(*output, input->size()))
+      return false;
     for (size_t i = 0; i < input->size(); ++i) {
       Traits::GetAt(*output, i) = MakeScopedHandle(
           HandleType(context->handles.TakeHandle(input->at(i)).value()));
     }
     return true;
   }
 };
 
 // This template must only apply to pointer mojo entity (strings, structs,
 // arrays and maps).
@@ skipping 38 matching lines @@
           !validate_params->element_is_nullable && !element,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                     size, i));
     }
   }
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
     bool success = true;
-    Traits::Resize(*output, input->size());
+    if (!Traits::Resize(*output, input->size()))
+      return false;
     for (size_t i = 0; i < input->size(); ++i) {
       // Note that we rely on complete deserialization taking place in order to
       // transfer ownership of all encoded handles. Therefore we don't
       // short-circuit on failure here.
       if (!Deserialize<Element>(input->at(i), &Traits::GetAt(*output, i),
                                 context)) {
         success = false;
       }
     }
     return success;
@@ skipping 71 matching lines @@
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid unions",
                                     size, i));
     }
   }
 
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
     bool success = true;
-    Traits::Resize(*output, input->size());
+    if (!Traits::Resize(*output, input->size()))
+      return false;
     for (size_t i = 0; i < input->size(); ++i) {
       // Note that we rely on complete deserialization taking place in order to
       // transfer ownership of all encoded handles. Therefore we don't
       // short-circuit on failure here.
       if (!Deserialize<Element>(&input->at(i), &Traits::GetAt(*output, i),
                                 context)) {
         success = false;
       }
     }
     return success;
@@ skipping 47 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_