Remove callers of mojo::Array<size_t> constructor in favor of ::New

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 <vector>
 
@@ skipping 88 matching lines @@
     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 < num_elements; ++i, ++it)
       output->at(i) = *it;
   }
 
   static void DeserializeElements(Array_Data<bool>* input,
                                   Array<bool>* output) {
-    Array<bool> result(input->size());
+    auto result = Array<bool>::New(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);
   }
 };
 
 // Serializes and deserializes arrays of handles.
 template <typename H>
 struct ArraySerializer<ScopedHandleBase<H>, H, false> {
@@ skipping 17 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", num_elements,
               i));
     }
   }
 
   static void DeserializeElements(Array_Data<H>* input,
                                   Array<ScopedHandleBase<H>>* output) {
-    Array<ScopedHandleBase<H>> result(input->size());
+    auto result = Array<ScopedHandleBase<H>>::New(input->size());
     for (size_t i = 0; i < input->size(); ++i)
       result.at(i) = MakeScopedHandle(FetchAndReset(&input->at(i)));
     output->Swap(&result);
   }
 };
 
 // This template must only apply to pointer mojo entity (structs, arrays,
 // strings).  This is done by ensuring that WrapperTraits<S>::DataType is a
 // pointer.
 template <typename S>
@@ skipping 26 matching lines @@
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !element,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                     num_elements, i));
     }
   }
 
   static void DeserializeElements(Array_Data<S_Data*>* input,
                                   Array<S>* output) {
-    Array<S> result(input->size());
+    auto result = Array<S>::New(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
       DeserializeCaller::Run(input->at(i), &result[i]);
     }
     output->Swap(&result);
   }
 
  private:
   // SerializeCaller template is used by |ArraySerializer| to dispatch a
   // serialize call on a non-POD type.  This template is defined outside
   // |ArraySerializer| since you cannot specialize a struct within a class
@@ skipping 92 matching lines @@
       SerializeUnion_(it->get(), 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",
                                     num_elements, i));
     }
   }
 
   static void DeserializeElements(Array_Data<U_Data>* input, Array<U>* output) {
-    Array<U> result(input->size());
+    auto result = Array<U>::New(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
       auto& elem = input->at(i);
       if (!elem.is_null()) {
         using UnwrapedUnionType = typename RemoveStructPtr<U>::type;
         result[i] = UnwrapedUnionType::New();
         Deserialize_(&elem, result[i].get());
       }
     }
     output->Swap(&result);
   }
@@ skipping 42 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_