[mojo] Allow value deserialization to fail

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 <string.h>  // For |memcpy()|.
 
 #include <utility>
@@ skipping 12 matching lines @@
 inline size_t GetSerializedSize_(const Array<E>& input);
 
 template <typename E, typename F>
 inline void SerializeArray_(
     Array<E> input,
     internal::Buffer* buf,
     internal::Array_Data<F>** output,
     const internal::ArrayValidateParams* validate_params);
 
 template <typename E, typename F>
-inline void Deserialize_(internal::Array_Data<F>* data,
+inline bool Deserialize_(internal::Array_Data<F>* data,
                          Array<E>* output,
                          internal::SerializationContext* context);
 
 namespace internal {
 
 template <typename E,
           typename F,
           bool is_union =
               IsUnionDataType<typename RemovePointer<F>::type>::value>
 struct ArraySerializer;
@@ skipping 11 matching lines @@
                                 Array_Data<F>* output,
                                 const ArrayValidateParams* validate_params) {
     MOJO_DCHECK(!validate_params->element_is_nullable)
         << "Primitive type should be non-nullable";
     MOJO_DCHECK(!validate_params->element_validate_params)
         << "Primitive type should not have array validate params";
 
     if (input.size())
       memcpy(output->storage(), &input.storage()[0], input.size() * sizeof(E));
   }
-  static void DeserializeElements(Array_Data<F>* input,
+  static bool DeserializeElements(Array_Data<F>* input,
                                   Array<E>* output,
                                   SerializationContext* context) {
     std::vector<E> result(input->size());
     if (input->size())
       memcpy(&result[0], input->storage(), input->size() * sizeof(E));
     output->Swap(&result);
+    return true;
   }
 };
 
 // Serializes and deserializes arrays of bools.
 template <>
 struct ArraySerializer<bool, bool, false> {
   static size_t GetSerializedSize(const Array<bool>& input) {
     return sizeof(Array_Data<bool>) + Align((input.size() + 7) / 8);
   }
 
   static void SerializeElements(Array<bool> input,
                                 Buffer* buf,
                                 Array_Data<bool>* output,
                                 const ArrayValidateParams* validate_params) {
     MOJO_DCHECK(!validate_params->element_is_nullable)
         << "Primitive type should be non-nullable";
     MOJO_DCHECK(!validate_params->element_validate_params)
         << "Primitive type should not have array validate params";
 
     // TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
     for (size_t i = 0; i < input.size(); ++i)
       output->at(i) = input[i];
   }
-  static void DeserializeElements(Array_Data<bool>* input,
+  static bool DeserializeElements(Array_Data<bool>* input,
                                   Array<bool>* output,
                                   SerializationContext* context) {
     Array<bool> result(input->size());
     // TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
     for (size_t i = 0; i < input->size(); ++i)
       result.at(i) = input->at(i);
     output->Swap(&result);
+    return true;
   }
 };
 
 // Serializes and deserializes arrays of handles.
 template <typename H>
 struct ArraySerializer<ScopedHandleBase<H>, H, false> {
   static size_t GetSerializedSize(const Array<ScopedHandleBase<H>>& input) {
     return sizeof(Array_Data<H>) + Align(input.size() * sizeof(H));
   }
 
   static void SerializeElements(Array<ScopedHandleBase<H>> input,
                                 Buffer* buf,
                                 Array_Data<H>* output,
                                 const ArrayValidateParams* validate_params) {
     MOJO_DCHECK(!validate_params->element_validate_params)
         << "Handle type should not have array validate params";
 
     for (size_t i = 0; i < input.size(); ++i) {
       output->at(i) = input[i].release();  // Transfer ownership of the handle.
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !output->at(i).is_valid(),
           VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
           MakeMessageWithArrayIndex(
               "invalid handle in array expecting valid handles", input.size(),
               i));
     }
   }
-  static void DeserializeElements(Array_Data<H>* input,
+  static bool DeserializeElements(Array_Data<H>* input,
                                   Array<ScopedHandleBase<H>>* output,
                                   SerializationContext* context) {
     Array<ScopedHandleBase<H>> result(input->size());
     for (size_t i = 0; i < input->size(); ++i)
       result.at(i) = MakeScopedHandle(FetchAndReset(&input->at(i)));
     output->Swap(&result);
+    return true;
   }
 };
 
 // This template must only apply to pointer mojo entity (structs and arrays).
 // This is done by ensuring that WrapperTraits<S>::DataType is a pointer.
 template <typename S>
 struct ArraySerializer<
     S,
     typename EnableIf<IsPointer<typename WrapperTraits<S>::DataType>::value,
                       typename WrapperTraits<S>::DataType>::type,
@@ skipping 17 matching lines @@
       SerializeCaller<S>::Run(input[i].Pass(), buf, &element,
                               validate_params->element_validate_params);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !element,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                     input.size(), i));
     }
   }
-  static void DeserializeElements(Array_Data<S_Data*>* input,
+  static bool DeserializeElements(Array_Data<S_Data*>* input,
                                   Array<S>* output,
                                   SerializationContext* context) {
+    bool success = true;
     Array<S> result(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
-      Deserialize_(input->at(i), &result[i], context);
+      // 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_(input->at(i), &result[i], context))
+        success = false;
     }
     output->Swap(&result);
+    return success;
   }
 
  private:
   template <typename T>
   struct SerializeCaller {
     static void Run(T input,
                     Buffer* buf,
                     typename WrapperTraits<T>::DataType* output,
                     const ArrayValidateParams* validate_params) {
       MOJO_DCHECK(!validate_params)
@@ skipping 45 matching lines @@
       U_Data* result = output->storage() + i;
       SerializeUnion_(input[i].Pass(), buf, &result, true);
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && output->at(i).is_null(),
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid unions",
                                     input.size(), i));
     }
   }
 
-  static void DeserializeElements(Array_Data<U_Data>* input,
+  static bool DeserializeElements(Array_Data<U_Data>* input,
                                   Array<U>* output,
                                   SerializationContext* context) {
+    bool success = true;
     Array<U> result(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
-      Deserialize_(&input->at(i), &result[i], context);
+      // 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_(&input->at(i), &result[i], context))
+        success = false;
     }
     output->Swap(&result);
+    return success;
   }
 };
 
 // Handles serialization and deserialization of arrays of strings.
 template <>
 struct ArraySerializer<String, String_Data*> {
   static size_t GetSerializedSize(const Array<String>& input) {
     size_t size =
         sizeof(Array_Data<String_Data*>) + input.size() * sizeof(StringPointer);
     for (size_t i = 0; i < input.size(); ++i)
@@ skipping 16 matching lines @@
       String_Data* element;
       Serialize_(input[i], buf, &element);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !element,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid strings",
                                     input.size(), i));
     }
   }
-  static void DeserializeElements(Array_Data<String_Data*>* input,
+  static bool DeserializeElements(Array_Data<String_Data*>* input,
                                   Array<String>* output,
                                   SerializationContext* context) {
     Array<String> result(input->size());
-    for (size_t i = 0; i < input->size(); ++i)
-      Deserialize_(input->at(i), &result[i], context);
+    for (size_t i = 0; i < input->size(); ++i) {
+      // It's OK to short-circuit here since string data cannot contain handles.
+      if (!Deserialize_(input->at(i), &result[i], context))
+        return false;
+    }
     output->Swap(&result);
+    return true;
   }
 };
 
 }  // namespace internal
 
 template <typename E>
 inline size_t GetSerializedSize_(const Array<E>& input) {
   if (!input)
     return 0;
   typedef typename internal::WrapperTraits<E>::DataType F;
@@ skipping 21 matching lines @@
       internal::ArraySerializer<E, F>::SerializeElements(
           std::move(input), buf, result, validate_params);
     }
     *output = result;
   } else {
     *output = nullptr;
   }
 }
 
 template <typename E, typename F>
-inline void Deserialize_(internal::Array_Data<F>* input,
+inline bool Deserialize_(internal::Array_Data<F>* input,
                          Array<E>* output,
                          internal::SerializationContext* context) {
   if (input) {
-    internal::ArraySerializer<E, F>::DeserializeElements(input, output,
-                                                         context);
+    if (!internal::ArraySerializer<E, F>::DeserializeElements(input, output,
+                                                              context)) {
+      return false;
+    }
   } else {
     output->reset();
   }
+  return true;
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_