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

mojo/public/cpp/bindings/tests/map_unittest.cc

 // 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.
 
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/lib/array_serialization.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/bindings/lib/map_serialization.h"
 #include "mojo/public/cpp/bindings/lib/validate_params.h"
@@ skipping 67 matching lines @@
   }
 }
 
 TEST_F(MapTest, TestIndexOperatorMoveOnly) {
   ASSERT_EQ(0u, MoveOnlyType::num_instances());
   mojo::Map<mojo::String, mojo::Array<int32_t>> map;
   std::vector<MoveOnlyType*> value_ptrs;
 
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     const char* key = kStringIntData[i].string_data;
-    Array<int32_t> array(1);
+    auto array = Array<int32_t>::New(1);
     array[0] = kStringIntData[i].int_data;
     map[key] = array.Pass();
     EXPECT_TRUE(map);
   }
 
   // We now read back that data, to test the behavior of operator[].
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     auto it = map.find(kStringIntData[i].string_data);
     ASSERT_TRUE(it != map.end());
     ASSERT_EQ(1u, it.GetValue().size());
     EXPECT_EQ(kStringIntData[i].int_data, it.GetValue()[0]);
   }
 }
 
 TEST_F(MapTest, ConstructedFromArray) {
-  Array<String> keys(kStringIntDataSize);
-  Array<int> values(kStringIntDataSize);
+  auto keys = Array<String>::New(kStringIntDataSize);
+  auto values = Array<int>::New(kStringIntDataSize);
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     keys[i] = kStringIntData[i].string_data;
     values[i] = kStringIntData[i].int_data;
   }
 
   Map<String, int> map(keys.Pass(), values.Pass());
 
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     EXPECT_EQ(kStringIntData[i].int_data,
               map.at(mojo::String(kStringIntData[i].string_data)));
@@ skipping 115 matching lines @@
   Map<String, Array<String>> m2 = m.Clone();
 
   for (auto it = m2.begin(); it != m2.end(); ++it) {
     ASSERT_EQ(1u, it.GetValue().size());
     EXPECT_EQ(it.GetKey(), it.GetValue().at(0));
   }
 }
 
 TEST_F(MapTest, ArrayOfMap) {
   {
-    Array<Map<int32_t, int8_t>> array(1);
+    auto array = Array<Map<int32_t, int8_t>>::New(1);
     array[0].insert(1, 42);
 
     size_t size = GetSerializedSize_(array);
     FixedBufferForTesting buf(size);
     Array_Data<Map_Data<int32_t, int8_t>*>* data;
     ArrayValidateParams validate_params(
         0, false, new ArrayValidateParams(0, false, nullptr));
     SerializeArray_(&array, &buf, &data, &validate_params);
 
     Array<Map<int32_t, int8_t>> deserialized_array;
     Deserialize_(data, &deserialized_array);
 
     ASSERT_EQ(1u, deserialized_array.size());
     ASSERT_EQ(1u, deserialized_array[0].size());
     ASSERT_EQ(42, deserialized_array[0].at(1));
   }
 
   {
-    Array<Map<String, Array<bool>>> array(1);
-    Array<bool> map_value(2);
+    auto array = Array<Map<String, Array<bool>>>::New(1);
+    auto map_value = Array<bool>::New(2);
     map_value[0] = false;
     map_value[1] = true;
     array[0].insert("hello world", map_value.Pass());
 
     size_t size = GetSerializedSize_(array);
     FixedBufferForTesting buf(size);
     Array_Data<Map_Data<String_Data*, Array_Data<bool>*>*>* data;
     ArrayValidateParams validate_params(
         0, false, new ArrayValidateParams(
                       0, false, new ArrayValidateParams(0, false, nullptr)));
     SerializeArray_(&array, &buf, &data, &validate_params);
 
     Array<Map<String, Array<bool>>> deserialized_array;
     Deserialize_(data, &deserialized_array);
 
     ASSERT_EQ(1u, deserialized_array.size());
     ASSERT_EQ(1u, deserialized_array[0].size());
     ASSERT_FALSE(deserialized_array[0].at("hello world")[0]);
     ASSERT_TRUE(deserialized_array[0].at("hello world")[1]);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo