Update device/usb and its Mojo interface for variable size ISO packets.

device/devices_app/usb/device_impl.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/devices_app/usb/device_impl.h"
 
 #include <stddef.h>
+
+#include <algorithm>
+#include <numeric>
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "device/devices_app/usb/type_converters.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
 #include "net/base/io_buffer.h"
 
 namespace device {
@@ skipping 102 matching lines @@
         USB_DIRECTION_OUTBOUND,
         mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type),
         mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient),
         params->request, params->value, params->index, buffer, data.size(),
         timeout, base::Bind(&OnTransferOut, base::Passed(&callback)));
   } else {
     callback->Run(TransferStatus::PERMISSION_DENIED);
   }
 }
 
+mojo::Array<IsochronousPacketPtr> BuildIsochronousPacketArray(
+    mojo::Array<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;
+  }
+  return packets;
+}
+
 void OnIsochronousTransferIn(
     scoped_ptr<Device::IsochronousTransferInCallback> callback,
-    uint32_t packet_size,
-    UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
-    size_t buffer_size) {
-  size_t num_packets = buffer_size / packet_size;
-  mojo::Array<mojo::Array<uint8_t>> packets(num_packets);
+    const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
+  mojo::Array<uint8_t> data;
   if (buffer) {
-    for (size_t i = 0; i < num_packets; ++i) {
-      size_t packet_index = i * packet_size;
-      std::vector<uint8_t> bytes(packet_size);
-      std::copy(buffer->data() + packet_index,
-                buffer->data() + packet_index + packet_size, bytes.begin());
-      packets[i].Swap(&bytes);
-    }
+    // 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.
+    uint32_t buffer_size =
+        std::accumulate(packets.begin(), packets.end(), 0u,
+                        [](const uint32_t& a,
+                           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);
   }
-  callback->Run(mojo::ConvertTo<TransferStatus>(status), std::move(packets));
+  callback->Run(std::move(data),
+                mojo::Array<IsochronousPacketPtr>::From(packets));
 }
 
 void OnIsochronousTransferOut(
     scoped_ptr<Device::IsochronousTransferOutCallback> callback,
-    UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
-    size_t buffer_size) {
-  callback->Run(mojo::ConvertTo<TransferStatus>(status));
+    const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
+  callback->Run(mojo::Array<IsochronousPacketPtr>::From(packets));
 }
 
 }  // namespace
 
 DeviceImpl::DeviceImpl(scoped_refptr<UsbDevice> device,
                        PermissionProviderPtr permission_provider,
                        mojo::InterfaceRequest<Device> request)
     : binding_(this, std::move(request)),
       device_(device),
       permission_provider_(std::move(permission_provider)),
@@ skipping 224 matching lines @@
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
   const std::vector<uint8_t>& storage = data.storage();
   std::copy(storage.begin(), storage.end(), buffer->data());
   device_handle_->GenericTransfer(
       USB_DIRECTION_OUTBOUND, endpoint_address, buffer, data.size(), timeout,
       base::Bind(&OnTransferOut, base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::IsochronousTransferIn(
     uint8_t endpoint_number,
-    uint32_t num_packets,
-    uint32_t packet_length,
+    mojo::Array<uint32_t> packet_lengths,
     uint32_t timeout,
     const IsochronousTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TransferStatus::TRANSFER_ERROR,
-                 mojo::Array<mojo::Array<uint8_t>>());
+    callback.Run(mojo::Array<uint8_t>(),
+                 BuildIsochronousPacketArray(std::move(packet_lengths),
+                                             TransferStatus::TRANSFER_ERROR));
     return;
   }
 
   auto callback_ptr =
       make_scoped_ptr(new IsochronousTransferInCallback(callback));
   uint8_t endpoint_address = endpoint_number | 0x80;
-  size_t transfer_size = static_cast<size_t>(num_packets) * packet_length;
-  scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(transfer_size);
-  device_handle_->IsochronousTransfer(
-      USB_DIRECTION_INBOUND, endpoint_address, buffer, transfer_size,
-      num_packets, packet_length, timeout,
-      base::Bind(&OnIsochronousTransferIn, base::Passed(&callback_ptr),
-                 packet_length));
+  device_handle_->IsochronousTransferIn(
+      endpoint_address, packet_lengths.storage(), timeout,
+      base::Bind(&OnIsochronousTransferIn, base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::IsochronousTransferOut(
     uint8_t endpoint_number,
-    mojo::Array<mojo::Array<uint8_t>> packets,
+    mojo::Array<uint8_t> data,
+    mojo::Array<uint32_t> packet_lengths,
     uint32_t timeout,
     const IsochronousTransferOutCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TransferStatus::TRANSFER_ERROR);
+    callback.Run(BuildIsochronousPacketArray(std::move(packet_lengths),
+                                             TransferStatus::TRANSFER_ERROR));
     return;
   }
 
   auto callback_ptr =
       make_scoped_ptr(new IsochronousTransferOutCallback(callback));
   uint8_t endpoint_address = endpoint_number;
-  uint32_t packet_size = 0;
-  for (size_t i = 0; i < packets.size(); ++i) {
-    packet_size =
-        std::max(packet_size, static_cast<uint32_t>(packets[i].size()));
+  scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
+  {
+    const std::vector<uint8_t>& storage = data.storage();
+    std::copy(storage.begin(), storage.end(), buffer->data());
   }
-  size_t transfer_size = packet_size * packets.size();
-  scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(transfer_size);
-  memset(buffer->data(), 0, transfer_size);
-  for (size_t i = 0; i < packets.size(); ++i) {
-    uint8_t* packet =
-        reinterpret_cast<uint8_t*>(&buffer->data()[i * packet_size]);
-    DCHECK_LE(packets[i].size(), static_cast<size_t>(packet_size));
-    memcpy(packet, packets[i].storage().data(), packets[i].size());
-  }
-  device_handle_->IsochronousTransfer(
-      USB_DIRECTION_OUTBOUND, endpoint_address, buffer, transfer_size,
-      static_cast<uint32_t>(packets.size()), packet_size, timeout,
+  device_handle_->IsochronousTransferOut(
+      endpoint_address, buffer, packet_lengths.storage(), timeout,
       base::Bind(&OnIsochronousTransferOut, base::Passed(&callback_ptr)));
 }
 
 }  // namespace usb
 }  // namespace device