Mojo C++ bindings: Fix bug: array<>, map<> should only initialize elements if they're not null when…

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.
 
 // TODO(vardhan):  Currently, the logic for serializing a mojom type exists in
 // two places: the C++ code generator template, and here.  However, most types
 // are serialized the same way within Arrays or outside, with the exception of
 // |bool|.  Consider defining serialization/deserialization traits for each
 // serializable type and call those traits from here.  This should help us
 // remove most of the ArraySerializer<> specializations here.
@@ skipping 282 matching lines @@
     typename std::enable_if<
         std::is_pointer<typename WrapperTraits<S>::DataType>::value,
         typename WrapperTraits<S>::DataType>::type,
     false> {
   typedef
       typename std::remove_pointer<typename WrapperTraits<S>::DataType>::type
           S_Data;
   static size_t GetSerializedSize(const Array<S>& input) {
     size_t size = sizeof(Array_Data<S_Data*>) +
                   input.size() * sizeof(StructPointer<S_Data>);
-    for (size_t i = 0; i < input.size(); ++i)
-      size += GetSerializedSize_(*(UnwrapConstStructPtr<S>::value(input[i])));
+    for (size_t i = 0; i < input.size(); ++i) {
+      if (!input[i].is_null())
+        size += GetSerializedSize_(*(UnwrapConstStructPtr<S>::value(input[i])));
+    }
     return size;
   }
 
   template <typename Iterator>
   static ValidationError SerializeElements(
       Iterator it,
       size_t num_elements,
       Buffer* buf,
       Array_Data<S_Data*>* output,
       const ArrayValidateParams* validate_params) {
@@ skipping 84 matching lines @@
     }
 
     // Since Deserialize_ takes in a |Struct*| (not |StructPtr|), we need to
     // initialize the |StructPtr| here before deserializing into its underlying
     // data.
     // TODO(vardhan):  Either all containers, or just Deserialize_(), should
     // support taking in an allocator.
     template <typename T>
     static void Run(typename WrapperTraits<StructPtr<T>>::DataType input,
                     StructPtr<T>* output) {
-      *output = T::New();
-      Deserialize_(input, output->get());
+      if (input != nullptr) {

[viettrungluu, 2015/12/07 22:03:51]

nit: probably "if (input)" should be fine and more idiomatic?

[vardhan, 2015/12/07 22:48:31]

Done.

I was trying to be more explicit about what type |input| is (ie a  pointer), but
I realize now that that should be abstracted away, in the same way
|WrapperTraits<>::DataType| is abstracted away.

+        *output = T::New();
+        Deserialize_(input, output->get());
+      }
     }
 
     template <typename T>
     static void Run(typename WrapperTraits<InlinedStructPtr<T>>::DataType input,
                     InlinedStructPtr<T>* output) {
-      *output = T::New();
-      Deserialize_(input, output->get());
+      if (input != nullptr) {

[viettrungluu, 2015/12/07 22:03:51]

"

[vardhan, 2015/12/07 22:48:31]

Done.

+        *output = T::New();
+        Deserialize_(input, output->get());
+      }
     }
   };
 };
 
 // Handles serialization and deserialization of arrays of unions.
 template <typename U, typename U_Data>
 struct ArraySerializer<U, U_Data, true> {
   static size_t GetSerializedSize(const Array<U>& input) {
     size_t size = sizeof(Array_Data<U_Data>);
     for (size_t i = 0; i < input.size(); ++i) {
@@ skipping 42 matching lines @@
     output->Swap(&result);
   }
 };
 
 }  // namespace internal
 
 template <typename E>
 inline size_t GetSerializedSize_(const Array<E>& input) {
   if (!input)
     return 0;
-  typedef typename internal::WrapperTraits<E>::DataType F;
+  using F = typename internal::WrapperTraits<E>::DataType;
   return internal::ArraySerializer<E, F>::GetSerializedSize(input);
 }
 
 // SerializeArray_ will return ValidationError::NONE on success and set
 // |output| accordingly.  On failure, |input| will be partially serialized into
 // |output| up until an error occurs (which is propagated up and returned by
 // SerializeArray_), in which case |buf| is also partially consumed.
 template <typename E, typename F>
 inline internal::ValidationError SerializeArray_(
     Array<E>* input,
@@ skipping 34 matching lines @@
   if (input) {
     internal::ArraySerializer<E, F>::DeserializeElements(input, output);
   } else {
     output->reset();
   }
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_