Remove internal uses of mojo::Array and mojo::WTFArray.

mojo/public/cpp/bindings/tests/struct_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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
 
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
@@ skipping 448 matching lines @@
     EXPECT_EQ(nullptr, data);
 
     NativeStructPtr output_native;
     mojo::internal::Deserialize<NativeStructDataView>(data, &output_native,
                                                       nullptr);
     EXPECT_TRUE(output_native.is_null());
   }
 
   {
     NativeStructPtr native(NativeStruct::New());
-    native->data = Array<uint8_t>(2);
-    native->data[0] = 'X';
-    native->data[1] = 'Y';
+    native->data = std::vector<uint8_t>{'X', 'Y'};
 
     size_t size = mojo::internal::PrepareToSerialize<NativeStructDataView>(
         native, nullptr);
     EXPECT_EQ(16u, size);
     mojo::internal::FixedBufferForTesting buf(size);
 
     Data* data = nullptr;
     mojo::internal::Serialize<NativeStructDataView>(std::move(native), &buf,
                                                     &data, nullptr);
 
     EXPECT_NE(nullptr, data);
 
     NativeStructPtr output_native;
     mojo::internal::Deserialize<NativeStructDataView>(data, &output_native,
                                                       nullptr);
-    EXPECT_FALSE(output_native.is_null());
-    EXPECT_FALSE(output_native->data.is_null());
-    EXPECT_EQ(2u, output_native->data.size());
-    EXPECT_EQ('X', output_native->data[0]);
-    EXPECT_EQ('Y', output_native->data[1]);
+    ASSERT_TRUE(output_native);
+    ASSERT_FALSE(output_native->data->empty());
+    EXPECT_EQ(2u, output_native->data->size());
+    EXPECT_EQ('X', (*output_native->data)[0]);
+    EXPECT_EQ('Y', (*output_native->data)[1]);
   }
 }
 
 TEST_F(StructTest, Serialization_PublicAPI) {
   {
     // A null struct pointer.
     RectPtr null_struct;
-    mojo::Array<uint8_t> data = Rect::Serialize(&null_struct);
+    auto data = Rect::Serialize(&null_struct);
     EXPECT_TRUE(data.empty());
 
     // Initialize it to non-null.
     RectPtr output(Rect::New());
     ASSERT_TRUE(Rect::Deserialize(std::move(data), &output));
     EXPECT_TRUE(output.is_null());
   }
 
   {
     // A struct with no fields.
     EmptyStructPtr empty_struct(EmptyStruct::New());
-    mojo::Array<uint8_t> data = EmptyStruct::Serialize(&empty_struct);
+    auto data = EmptyStruct::Serialize(&empty_struct);
     EXPECT_FALSE(data.empty());
 
     EmptyStructPtr output;
     ASSERT_TRUE(EmptyStruct::Deserialize(std::move(data), &output));
     EXPECT_FALSE(output.is_null());
   }
 
   {
     // A simple struct.
     RectPtr rect = MakeRect();
     RectPtr cloned_rect = rect.Clone();
-    mojo::Array<uint8_t> data = Rect::Serialize(&rect);
+    auto data = Rect::Serialize(&rect);
 
     RectPtr output;
     ASSERT_TRUE(Rect::Deserialize(std::move(data), &output));
     EXPECT_TRUE(output.Equals(cloned_rect));
   }
 
   {
     // A struct containing other objects.
     NamedRegionPtr region(NamedRegion::New());
     region->name.emplace("region");
     region->rects.emplace(3);
     for (size_t i = 0; i < region->rects->size(); ++i)
       (*region->rects)[i] = MakeRect(static_cast<int32_t>(i) + 1);
 
     NamedRegionPtr cloned_region = region.Clone();
-    mojo::Array<uint8_t> data = NamedRegion::Serialize(&region);
+    auto data = NamedRegion::Serialize(&region);
 
     // Make sure that the serialized result gets pointers encoded properly.
-    mojo::Array<uint8_t> cloned_data = data.Clone();
+    auto cloned_data = data;
     NamedRegionPtr output;
     ASSERT_TRUE(NamedRegion::Deserialize(std::move(cloned_data), &output));
     EXPECT_TRUE(output.Equals(cloned_region));
   }
 
   {
     // Deserialization failure.
     RectPtr rect = MakeRect();
-    mojo::Array<uint8_t> data = Rect::Serialize(&rect);
+    auto data = Rect::Serialize(&rect);
 
     NamedRegionPtr output;
     EXPECT_FALSE(NamedRegion::Deserialize(std::move(data), &output));
   }
 }
 
 }  // namespace test
 }  // namespace mojo