[mojo] Allow value deserialization to fail

mojo/public/cpp/bindings/lib/array_serialization.h

Index: mojo/public/cpp/bindings/lib/array_serialization.h
diff --git a/mojo/public/cpp/bindings/lib/array_serialization.h b/mojo/public/cpp/bindings/lib/array_serialization.h
index b6168033b606035fdeb72b8ea0a17213e121c200..9fc14ef4ba3129244005811c0eda424e2e404a1d 100644
--- a/mojo/public/cpp/bindings/lib/array_serialization.h
+++ b/mojo/public/cpp/bindings/lib/array_serialization.h
@@ -30,7 +30,7 @@ inline void SerializeArray_(
     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);
 
@@ -62,13 +62,14 @@ struct ArraySerializer<E, F, false> {
     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;
   }
 };
 
@@ -92,7 +93,7 @@ struct ArraySerializer<bool, bool, false> {
     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());
@@ -100,6 +101,7 @@ struct ArraySerializer<bool, bool, false> {
     for (size_t i = 0; i < input->size(); ++i)
       result.at(i) = input->at(i);
     output->Swap(&result);
+    return true;
   }
 };
 
@@ -127,13 +129,14 @@ struct ArraySerializer<ScopedHandleBase<H>, H, false> {
               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;
   }
 };
 
@@ -171,14 +174,16 @@ struct ArraySerializer<
                                     input.size(), i));
     }
   }
-  static void DeserializeElements(Array_Data<S_Data*>* input,
+  static bool DeserializeElements(Array_Data<S_Data*>* input,
                                   Array<S>* output,
                                   SerializationContext* context) {
     Array<S> result(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
-      Deserialize_(input->at(i), &result[i], context);
+      if (!Deserialize_(input->at(i), &result[i], context))
+        return false;

[yzshen1, 2015/12/14 20:45:19]

It may leak handles (here and elsewhere). Before deserialization, we have a step
called DecodePointersAndHandles(). One of its purposes is to take handles out of
Message::handles_ and place the raw handles in the right place of the message
payload.

Previously there isn't problem because Deserialize_() guarantees to consume all
those handles. With this CL it is no longer the case.

     }
     output->Swap(&result);
+    return true;
   }
 
  private:
@@ -244,14 +249,16 @@ struct ArraySerializer<U, U_Data, true> {
     }
   }
 
-  static void DeserializeElements(Array_Data<U_Data>* input,
+  static bool DeserializeElements(Array_Data<U_Data>* input,
                                   Array<U>* output,
                                   SerializationContext* context) {
     Array<U> result(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
-      Deserialize_(&input->at(i), &result[i], context);
+      if (!Deserialize_(&input->at(i), &result[i], context))
+        return false;
     }
     output->Swap(&result);
+    return true;
   }
 };
 
@@ -288,13 +295,16 @@ struct ArraySerializer<String, String_Data*> {
                                     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) {
+      if (!Deserialize_(input->at(i), &result[i], context))
+        return false;
+    }
     output->Swap(&result);
+    return true;
   }
 };
 
@@ -336,15 +346,18 @@ inline void SerializeArray_(
 }
 
 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