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

device/usb/mojo/device_impl.cc

Index: device/usb/mojo/device_impl.cc
diff --git a/device/usb/mojo/device_impl.cc b/device/usb/mojo/device_impl.cc
index 6269b05bae419e7d01fbec5d3bc2a52c9f70fc61..2a834fa5d2ec64dd7d5727893cbe501f19898ab5 100644
--- a/device/usb/mojo/device_impl.cc
+++ b/device/usb/mojo/device_impl.cc
@@ -19,6 +19,7 @@
 #include "device/usb/mojo/type_converters.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
+#include "mojo/common/common_type_converters.h"
 #include "net/base/io_buffer.h"
 
 namespace device {
@@ -26,48 +27,43 @@ namespace usb {
 
 namespace {
 
-using MojoTransferInCallback =
-    base::Callback<void(TransferStatus, mojo::Array<uint8_t>)>;
-
-using MojoTransferOutCallback = base::Callback<void(TransferStatus)>;
-
 scoped_refptr<net::IOBuffer> CreateTransferBuffer(size_t size) {
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(
+  return new net::IOBuffer(
       std::max(static_cast<size_t>(1u), static_cast<size_t>(size)));
-  return buffer;
 }
 
-void OnTransferIn(std::unique_ptr<MojoTransferInCallback> callback,
+void OnTransferIn(std::unique_ptr<Device::GenericTransferInCallback> callback,
                   UsbTransferStatus status,
                   scoped_refptr<net::IOBuffer> buffer,
                   size_t buffer_size) {
-  mojo::Array<uint8_t> data;
+  std::vector<uint8_t> data;
   if (buffer) {
     // TODO(rockot/reillyg): We should change UsbDeviceHandle to use a
     // std::vector<uint8_t> instead of net::IOBuffer. Then we could move
     // instead of copy.
-    std::vector<uint8_t> bytes(buffer_size);
-    std::copy(buffer->data(), buffer->data() + buffer_size, bytes.begin());
-    data.Swap(&bytes);
+    data.resize(buffer_size);
+    std::copy(buffer->data(), buffer->data() + buffer_size, data.begin());
   }
-  callback->Run(mojo::ConvertTo<TransferStatus>(status), std::move(data));
+  callback->Run(mojo::ConvertTo<TransferStatus>(status), data);
 }
 
-void OnTransferOut(std::unique_ptr<MojoTransferOutCallback> callback,
+void OnTransferOut(std::unique_ptr<Device::GenericTransferOutCallback> callback,
                    UsbTransferStatus status,
                    scoped_refptr<net::IOBuffer> buffer,
                    size_t buffer_size) {
   callback->Run(mojo::ConvertTo<TransferStatus>(status));
 }
 
-mojo::Array<IsochronousPacketPtr> BuildIsochronousPacketArray(
-    mojo::Array<uint32_t> packet_lengths,
+std::vector<IsochronousPacketPtr> BuildIsochronousPacketArray(
+    const std::vector<uint32_t>& packet_lengths,
     TransferStatus status) {
-  mojo::Array<IsochronousPacketPtr> packets(packet_lengths.size());
-  for (size_t i = 0; i < packet_lengths.size(); ++i) {
-    packets[i] = IsochronousPacket::New();
-    packets[i]->length = packet_lengths[i];
-    packets[i]->status = status;
+  std::vector<IsochronousPacketPtr> packets;
+  packets.reserve(packet_lengths.size());
+  for (uint32_t packet_length : packet_lengths) {
+    auto packet = IsochronousPacket::New();
+    packet->length = packet_length;
+    packet->status = status;
+    packets.push_back(std::move(packet));
   }
   return packets;
 }
@@ -76,7 +72,7 @@ void OnIsochronousTransferIn(
     std::unique_ptr<Device::IsochronousTransferInCallback> callback,
     scoped_refptr<net::IOBuffer> buffer,
     const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
-  mojo::Array<uint8_t> data;
+  std::vector<uint8_t> data;
   if (buffer) {
     // TODO(rockot/reillyg): We should change UsbDeviceHandle to use a
     // std::vector<uint8_t> instead of net::IOBuffer. Then we could move
@@ -87,19 +83,19 @@ void OnIsochronousTransferIn(
                            const UsbDeviceHandle::IsochronousPacket& packet) {
                           return a + packet.length;
                         });
-    std::vector<uint8_t> bytes(buffer_size);
-    std::copy(buffer->data(), buffer->data() + buffer_size, bytes.begin());
-    data.Swap(&bytes);
+    data.resize(buffer_size);
+    std::copy(buffer->data(), buffer->data() + buffer_size, data.begin());
   }
-  callback->Run(std::move(data),
-                mojo::Array<IsochronousPacketPtr>::From(packets));
+
+  callback->Run(data,
+                mojo::ConvertTo<std::vector<IsochronousPacketPtr>>(packets));
 }
 
 void OnIsochronousTransferOut(
     std::unique_ptr<Device::IsochronousTransferOutCallback> callback,
     scoped_refptr<net::IOBuffer> buffer,
     const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
-  callback->Run(mojo::Array<IsochronousPacketPtr>::From(packets));
+  callback->Run(mojo::ConvertTo<std::vector<IsochronousPacketPtr>>(packets));
 }
 
 }  // namespace
@@ -322,7 +318,7 @@ void DeviceImpl::ControlTransferIn(ControlTransferParamsPtr params,
                                    uint32_t timeout,
                                    const ControlTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
+    callback.Run(TransferStatus::TRANSFER_ERROR, base::nullopt);
     return;
   }
 
@@ -337,14 +333,13 @@ void DeviceImpl::ControlTransferIn(ControlTransferParamsPtr params,
         params->request, params->value, params->index, buffer, length, timeout,
         base::Bind(&OnTransferIn, base::Passed(&callback_ptr)));
   } else {
-    mojo::Array<uint8_t> data;
-    callback.Run(TransferStatus::PERMISSION_DENIED, std::move(data));
+    callback.Run(TransferStatus::PERMISSION_DENIED, base::nullopt);
   }
 }
 
 void DeviceImpl::ControlTransferOut(
     ControlTransferParamsPtr params,
-    mojo::Array<uint8_t> data,
+    const std::vector<uint8_t>& data,
     uint32_t timeout,
     const ControlTransferOutCallback& callback) {
   if (!device_handle_) {
@@ -354,8 +349,7 @@ void DeviceImpl::ControlTransferOut(
 
   if (HasControlTransferPermission(params->recipient, params->index)) {
     scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
-    const std::vector<uint8_t>& storage = data.storage();
-    std::copy(storage.begin(), storage.end(), buffer->data());
+    std::copy(data.begin(), data.end(), buffer->data());
     auto callback_ptr =
         base::WrapUnique(new ControlTransferOutCallback(callback));
     device_handle_->ControlTransfer(
@@ -374,7 +368,7 @@ void DeviceImpl::GenericTransferIn(uint8_t endpoint_number,
                                    uint32_t timeout,
                                    const GenericTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
+    callback.Run(TransferStatus::TRANSFER_ERROR, base::nullopt);
     return;
   }
 
@@ -388,7 +382,7 @@ void DeviceImpl::GenericTransferIn(uint8_t endpoint_number,
 
 void DeviceImpl::GenericTransferOut(
     uint8_t endpoint_number,
-    mojo::Array<uint8_t> data,
+    const std::vector<uint8_t>& data,
     uint32_t timeout,
     const GenericTransferOutCallback& callback) {
   if (!device_handle_) {
@@ -400,8 +394,7 @@ void DeviceImpl::GenericTransferOut(
       base::WrapUnique(new GenericTransferOutCallback(callback));
   uint8_t endpoint_address = endpoint_number;
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
-  const std::vector<uint8_t>& storage = data.storage();
-  std::copy(storage.begin(), storage.end(), buffer->data());
+  std::copy(data.begin(), data.end(), buffer->data());
   device_handle_->GenericTransfer(
       USB_DIRECTION_OUTBOUND, endpoint_address, buffer, data.size(), timeout,
       base::Bind(&OnTransferOut, base::Passed(&callback_ptr)));
@@ -409,12 +402,12 @@ void DeviceImpl::GenericTransferOut(
 
 void DeviceImpl::IsochronousTransferIn(
     uint8_t endpoint_number,
-    mojo::Array<uint32_t> packet_lengths,
+    const std::vector<uint32_t>& packet_lengths,
     uint32_t timeout,
     const IsochronousTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(mojo::Array<uint8_t>(),
-                 BuildIsochronousPacketArray(std::move(packet_lengths),
+    callback.Run(base::nullopt,
+                 BuildIsochronousPacketArray(packet_lengths,
                                              TransferStatus::TRANSFER_ERROR));
     return;
   }
@@ -423,18 +416,18 @@ void DeviceImpl::IsochronousTransferIn(
       base::WrapUnique(new IsochronousTransferInCallback(callback));
   uint8_t endpoint_address = endpoint_number | 0x80;
   device_handle_->IsochronousTransferIn(
-      endpoint_address, packet_lengths.storage(), timeout,
+      endpoint_address, packet_lengths, timeout,
       base::Bind(&OnIsochronousTransferIn, base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::IsochronousTransferOut(
     uint8_t endpoint_number,
-    mojo::Array<uint8_t> data,
-    mojo::Array<uint32_t> packet_lengths,
+    const std::vector<uint8_t>& data,
+    const std::vector<uint32_t>& packet_lengths,
     uint32_t timeout,
     const IsochronousTransferOutCallback& callback) {
   if (!device_handle_) {
-    callback.Run(BuildIsochronousPacketArray(std::move(packet_lengths),
+    callback.Run(BuildIsochronousPacketArray(packet_lengths,
                                              TransferStatus::TRANSFER_ERROR));
     return;
   }
@@ -443,12 +436,9 @@ void DeviceImpl::IsochronousTransferOut(
       base::WrapUnique(new IsochronousTransferOutCallback(callback));
   uint8_t endpoint_address = endpoint_number;
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
-  {
-    const std::vector<uint8_t>& storage = data.storage();
-    std::copy(storage.begin(), storage.end(), buffer->data());
-  }
+  std::copy(data.begin(), data.end(), buffer->data());
   device_handle_->IsochronousTransferOut(
-      endpoint_address, buffer, packet_lengths.storage(), timeout,
+      endpoint_address, buffer, packet_lengths, timeout,
       base::Bind(&OnIsochronousTransferOut, base::Passed(&callback_ptr)));
 }