Mojo C++ binding: make device/usb mojom targets use STD string/vector types

device/usb/mojo/device_impl_unittest.cc

 // Copyright 2015 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 "device/usb/mojo/device_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 70 matching lines @@
   continuation.Run();
 }
 
 void ExpectResultAndThen(bool expected_result,
                          const base::Closure& continuation,
                          bool actual_result) {
   EXPECT_EQ(expected_result, actual_result);
   continuation.Run();
 }
 
-void ExpectTransferInAndThen(TransferStatus expected_status,
-                             const std::vector<uint8_t>& expected_bytes,
-                             const base::Closure& continuation,
-                             TransferStatus actual_status,
-                             mojo::Array<uint8_t> actual_bytes) {
+void ExpectTransferInAndThen(
+    TransferStatus expected_status,
+    const std::vector<uint8_t>& expected_bytes,
+    const base::Closure& continuation,
+    TransferStatus actual_status,
+    const base::Optional<std::vector<uint8_t>>& actual_bytes) {
   EXPECT_EQ(expected_status, actual_status);
-  ASSERT_EQ(expected_bytes.size(), actual_bytes.size());
-  for (size_t i = 0; i < actual_bytes.size(); ++i) {
-    EXPECT_EQ(expected_bytes[i], actual_bytes[i])
+  ASSERT_TRUE(actual_bytes);
+  ASSERT_EQ(expected_bytes.size(), actual_bytes->size());
+  for (size_t i = 0; i < actual_bytes->size(); ++i) {
+    EXPECT_EQ(expected_bytes[i], (*actual_bytes)[i])
         << "Contents differ at index: " << i;
   }
   continuation.Run();
 }
 
 void ExpectPacketsOutAndThen(const std::vector<uint32_t>& expected_packets,
                              const base::Closure& continuation,
-                             mojo::Array<IsochronousPacketPtr> actual_packets) {
+                             std::vector<IsochronousPacketPtr> actual_packets) {
   ASSERT_EQ(expected_packets.size(), actual_packets.size());
   for (size_t i = 0; i < expected_packets.size(); ++i) {
     EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length)
         << "Packet lengths differ at index: " << i;
     EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status)
         << "Packet at index " << i << " not completed.";
   }
   continuation.Run();
 }
 
-void ExpectPacketsInAndThen(const std::vector<uint8_t>& expected_bytes,
-                            const std::vector<uint32_t>& expected_packets,
-                            const base::Closure& continuation,
-                            mojo::Array<uint8_t> actual_bytes,
-                            mojo::Array<IsochronousPacketPtr> actual_packets) {
+void ExpectPacketsInAndThen(
+    const std::vector<uint8_t>& expected_bytes,
+    const std::vector<uint32_t>& expected_packets,
+    const base::Closure& continuation,
+    const base::Optional<std::vector<uint8_t>>& actual_bytes,
+    std::vector<IsochronousPacketPtr> actual_packets) {
   ASSERT_EQ(expected_packets.size(), actual_packets.size());
   for (size_t i = 0; i < expected_packets.size(); ++i) {
     EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length)
         << "Packet lengths differ at index: " << i;
     EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status)
         << "Packet at index " << i << " not completed.";
   }
-  ASSERT_EQ(expected_bytes.size(), actual_bytes.size());
-  for (size_t i = 0; i < expected_bytes.size(); ++i) {
-    EXPECT_EQ(expected_bytes[i], actual_bytes[i])
+  ASSERT_TRUE(actual_bytes);
+  ASSERT_EQ(expected_bytes.size(), actual_bytes->size());
+  for (size_t i = 0; i < actual_bytes->size(); ++i) {
+    EXPECT_EQ(expected_bytes[i], (*actual_bytes)[i])
         << "Contents differ at index: " << i;
   }
   continuation.Run();
 }
 
 void ExpectTransferStatusAndThen(TransferStatus expected_status,
                                  const base::Closure& continuation,
                                  TransferStatus actual_status) {
   EXPECT_EQ(expected_status, actual_status);
   continuation.Run();
@@ skipping 620 matching lines @@
 
   {
     auto params = ControlTransferParams::New();
     params->type = ControlTransferType::STANDARD;
     params->recipient = ControlTransferRecipient::INTERFACE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferOut(
-        std::move(params), mojo::Array<uint8_t>::From(fake_data), 0,
+        std::move(params), fake_data, 0,
         base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, GenericTransfer) {
   DevicePtr device = GetMockDeviceProxy();
@@ skipping 18 matching lines @@
   AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
   AddMockOutboundData(fake_outbound_data);
   AddMockInboundData(fake_inbound_data);
 
   EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_OUTBOUND, 0x01, _,
                                              fake_outbound_data.size(), 0, _));
 
   {
     base::RunLoop loop;
     device->GenericTransferOut(
-        1, mojo::Array<uint8_t>::From(fake_outbound_data), 0,
+        1, fake_outbound_data, 0,
         base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_INBOUND, 0x81, _,
                                              fake_inbound_data.size(), 0, _));
 
   {
     base::RunLoop loop;
@@ skipping 42 matching lines @@
   AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
   AddMockOutboundPackets(fake_outbound_data, fake_packets);
   AddMockInboundPackets(fake_inbound_data, fake_packets);
 
   EXPECT_CALL(mock_handle(),
               IsochronousTransferOut(0x01, _, fake_packet_lengths, 0, _));
 
   {
     base::RunLoop loop;
     device->IsochronousTransferOut(
-        1, mojo::Array<uint8_t>::From(fake_outbound_data),
-        mojo::Array<uint32_t>::From(fake_packet_lengths), 0,
+        1, fake_outbound_data, fake_packet_lengths, 0,
         base::Bind(&ExpectPacketsOutAndThen, expected_transferred_lengths,
                    loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(),
               IsochronousTransferIn(0x81, fake_packet_lengths, 0, _));
 
   {
     base::RunLoop loop;
     device->IsochronousTransferIn(
-        1, mojo::Array<uint32_t>::From(fake_packet_lengths), 0,
+        1, fake_packet_lengths, 0,
         base::Bind(&ExpectPacketsInAndThen, fake_inbound_data,
                    expected_transferred_lengths, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 }  // namespace usb
 }  // namespace device