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

device/usb/usb_device_handle_impl.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 "device/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
+#include <numeric>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
@@ skipping 95 matching lines @@
     scoped_refptr<net::IOBuffer> buffer,
     size_t result) {
   if (callback_task_runner->RunsTasksOnCurrentThread()) {
     callback.Run(status, buffer, result);
   } else {
     callback_task_runner->PostTask(
         FROM_HERE, base::Bind(callback, status, buffer, result));
   }
 }
 
+void ReportIsochronousTransferError(
+    scoped_refptr<base::TaskRunner> callback_task_runner,
+    const UsbDeviceHandle::IsochronousTransferCallback& callback,
+    const std::vector<uint32_t> packet_lengths,
+    UsbTransferStatus status) {
+  std::vector<UsbDeviceHandle::IsochronousPacket> packets(
+      packet_lengths.size());
+  for (size_t i = 0; i < packet_lengths.size(); ++i) {
+    packets[i].length = packet_lengths[i];
+    packets[i].transferred_length = 0;
+    packets[i].status = status;
+  }
+  if (callback_task_runner->RunsTasksOnCurrentThread()) {
+    callback.Run(nullptr, packets);
+  } else {
+    callback_task_runner->PostTask(FROM_HERE,
+                                   base::Bind(callback, nullptr, packets));
+  }
+}
+
 }  // namespace
 
 class UsbDeviceHandleImpl::InterfaceClaimer
     : public base::RefCountedThreadSafe<UsbDeviceHandleImpl::InterfaceClaimer> {
  public:
   InterfaceClaimer(scoped_refptr<UsbDeviceHandleImpl> handle,
                    int interface_number);
 
   int alternate_setting() const { return alternate_setting_; }
   void set_alternate_setting(const int alternate_setting) {
@@ skipping 51 matching lines @@
       scoped_refptr<net::IOBuffer> buffer,
       int length,
       unsigned int timeout,
       scoped_refptr<base::TaskRunner> callback_task_runner,
       const TransferCallback& callback);
   static scoped_ptr<Transfer> CreateIsochronousTransfer(
       scoped_refptr<UsbDeviceHandleImpl> device_handle,
       uint8_t endpoint,
       scoped_refptr<net::IOBuffer> buffer,
       size_t length,
-      unsigned int packets,
-      unsigned int packet_length,
+      const std::vector<uint32_t>& packet_lengths,
       unsigned int timeout,
-      scoped_refptr<base::TaskRunner> task_runner,
-      const TransferCallback& callback);
+      scoped_refptr<base::TaskRunner> callback_task_runner,
+      const IsochronousTransferCallback& callback);
 
   ~Transfer();
 
   void Submit();
   void Cancel();
   void ProcessCompletion();
   void TransferComplete(UsbTransferStatus status, size_t bytes_transferred);
 
   const UsbDeviceHandleImpl::InterfaceClaimer* claimed_interface() const {
     return claimed_interface_.get();
   }
 
   scoped_refptr<base::TaskRunner> callback_task_runner() const {
     return callback_task_runner_;
   }
 
  private:
   Transfer(scoped_refptr<UsbDeviceHandleImpl> device_handle,
            scoped_refptr<InterfaceClaimer> claimed_interface,
            UsbTransferType transfer_type,
            scoped_refptr<net::IOBuffer> buffer,
            size_t length,
            scoped_refptr<base::TaskRunner> callback_task_runner,
            const TransferCallback& callback);
+  Transfer(scoped_refptr<UsbDeviceHandleImpl> device_handle,
+           scoped_refptr<InterfaceClaimer> claimed_interface,
+           scoped_refptr<net::IOBuffer> buffer,
+           scoped_refptr<base::TaskRunner> callback_task_runner,
+           const IsochronousTransferCallback& callback);
 
   static void LIBUSB_CALL PlatformCallback(PlatformUsbTransferHandle handle);
 
+  void IsochronousTransferComplete();
+
   UsbTransferType transfer_type_;
   scoped_refptr<UsbDeviceHandleImpl> device_handle_;
   PlatformUsbTransferHandle platform_transfer_ = nullptr;
   scoped_refptr<net::IOBuffer> buffer_;
   scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer> claimed_interface_;
   size_t length_;
   bool cancelled_ = false;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   scoped_refptr<base::TaskRunner> callback_task_runner_;
   TransferCallback callback_;
+  IsochronousTransferCallback iso_callback_;
 };
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateControlTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t type,
     uint8_t request,
     uint16_t value,
     uint16_t index,
@@ skipping 36 matching lines @@
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
       USB_TRANSFER_BULK, buffer, length, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate bulk transfer.";
     return nullptr;
   }
 
-  libusb_fill_bulk_transfer(
-      transfer->platform_transfer_, device_handle->handle_, endpoint,
-      reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
-      &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
-      timeout);
+  libusb_fill_bulk_transfer(transfer->platform_transfer_,
+                            device_handle->handle_, endpoint,
+                            reinterpret_cast<uint8_t*>(buffer->data()), length,
+                            &UsbDeviceHandleImpl::Transfer::PlatformCallback,
+                            transfer.get(), timeout);
 
   return transfer;
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
       USB_TRANSFER_INTERRUPT, buffer, length, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate interrupt transfer.";
     return nullptr;
   }
 
   libusb_fill_interrupt_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
-      reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
+      reinterpret_cast<uint8_t*>(buffer->data()), length,
       &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
       timeout);
 
   return transfer;
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateIsochronousTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
-    unsigned int packets,
-    unsigned int packet_length,
+    const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
-    const TransferCallback& callback) {
-  DCHECK(packets <= length && (packets * packet_length) <= length)
-      << "transfer length is too small";
-
+    const IsochronousTransferCallback& callback) {
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
-      USB_TRANSFER_ISOCHRONOUS, buffer, length, callback_task_runner,
-      callback));
+      buffer, callback_task_runner, callback));
 
-  transfer->platform_transfer_ = libusb_alloc_transfer(packets);
+  int num_packets = static_cast<int>(packet_lengths.size());
+  transfer->platform_transfer_ = libusb_alloc_transfer(num_packets);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate isochronous transfer.";
     return nullptr;
   }
 
   libusb_fill_iso_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
       reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(length),
-      packets, &Transfer::PlatformCallback, transfer.get(), timeout);
-  libusb_set_iso_packet_lengths(transfer->platform_transfer_, packet_length);
+      num_packets, &Transfer::PlatformCallback, transfer.get(), timeout);
+
+  for (size_t i = 0; i < packet_lengths.size(); ++i)
+    transfer->platform_transfer_->iso_packet_desc[i].length = packet_lengths[i];
 
   return transfer;
 }
 
 UsbDeviceHandleImpl::Transfer::Transfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     scoped_refptr<InterfaceClaimer> claimed_interface,
     UsbTransferType transfer_type,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback)
     : transfer_type_(transfer_type),
       device_handle_(device_handle),
       buffer_(buffer),
       claimed_interface_(claimed_interface),
       length_(length),
       callback_task_runner_(callback_task_runner),
       callback_(callback) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
+UsbDeviceHandleImpl::Transfer::Transfer(
+    scoped_refptr<UsbDeviceHandleImpl> device_handle,
+    scoped_refptr<InterfaceClaimer> claimed_interface,
+    scoped_refptr<net::IOBuffer> buffer,
+    scoped_refptr<base::TaskRunner> callback_task_runner,
+    const IsochronousTransferCallback& callback)
+    : transfer_type_(USB_TRANSFER_ISOCHRONOUS),
+      device_handle_(device_handle),
+      buffer_(buffer),
+      claimed_interface_(claimed_interface),
+      callback_task_runner_(callback_task_runner),
+      iso_callback_(callback) {
+  task_runner_ = base::ThreadTaskRunnerHandle::Get();
+}
+
 UsbDeviceHandleImpl::Transfer::~Transfer() {
   if (platform_transfer_) {
     libusb_free_transfer(platform_transfer_);
   }
 }
 
 void UsbDeviceHandleImpl::Transfer::Submit() {
   const int rv = libusb_submit_transfer(platform_transfer_);
   if (rv != LIBUSB_SUCCESS) {
     USB_LOG(EVENT) << "Failed to submit transfer: "
@@ skipping 31 matching lines @@
         if (length_ >= (LIBUSB_CONTROL_SETUP_SIZE + actual_length)) {
           // If the payload is zero bytes long, pad out the allocated buffer
           // size to one byte so that an IOBuffer of that size can be allocated.
           scoped_refptr<net::IOBuffer> resized_buffer = new net::IOBuffer(
               std::max(actual_length, static_cast<size_t>(1)));
           memcpy(resized_buffer->data(),
                  buffer_->data() + LIBUSB_CONTROL_SETUP_SIZE, actual_length);
           buffer_ = resized_buffer;
         }
       }
+    // Fall through!
+
+    case USB_TRANSFER_BULK:
+    case USB_TRANSFER_INTERRUPT:
+      TransferComplete(ConvertTransferStatus(platform_transfer_->status),
+                       actual_length);
       break;
 
     case USB_TRANSFER_ISOCHRONOUS:
-      // Isochronous replies might carry data in the different isoc packets even
-      // if the transfer actual_data value is zero. Furthermore, not all of the
-      // received packets might contain data, so we need to calculate how many
-      // data bytes we are effectively providing and pack the results.
-      if (actual_length == 0) {
-        size_t packet_buffer_start = 0;
-        for (int i = 0; i < platform_transfer_->num_iso_packets; ++i) {
-          PlatformUsbIsoPacketDescriptor packet =
-              &platform_transfer_->iso_packet_desc[i];
-          if (packet->actual_length > 0) {
-            // We don't need to copy as long as all packets until now provide
-            // all the data the packet can hold.
-            if (actual_length < packet_buffer_start) {
-              CHECK(packet_buffer_start + packet->actual_length <= length_);
-              memmove(buffer_->data() + actual_length,
-                      buffer_->data() + packet_buffer_start,
-                      packet->actual_length);
-            }
-            actual_length += packet->actual_length;
-          }
-
-          packet_buffer_start += packet->length;
-        }
-      }
-      break;
-
-    case USB_TRANSFER_BULK:
-    case USB_TRANSFER_INTERRUPT:
+      IsochronousTransferComplete();
       break;
 
     default:
       NOTREACHED() << "Invalid usb transfer type";
       break;
   }
-
-  TransferComplete(ConvertTransferStatus(platform_transfer_->status),
-                   actual_length);
 }
 
 /* static */
 void LIBUSB_CALL UsbDeviceHandleImpl::Transfer::PlatformCallback(
     PlatformUsbTransferHandle platform_transfer) {
   Transfer* transfer =
       reinterpret_cast<Transfer*>(platform_transfer->user_data);
   DCHECK(transfer->platform_transfer_ == platform_transfer);
   transfer->ProcessCompletion();
 }
 
 void UsbDeviceHandleImpl::Transfer::TransferComplete(UsbTransferStatus status,
                                                      size_t bytes_transferred) {
+  base::Closure closure;
+  if (transfer_type_ == USB_TRANSFER_ISOCHRONOUS) {
+    DCHECK_NE(LIBUSB_TRANSFER_COMPLETED, platform_transfer_->status);
+    std::vector<IsochronousPacket> packets(platform_transfer_->num_iso_packets);
+    for (size_t i = 0; i < packets.size(); ++i) {
+      packets[i].length = platform_transfer_->iso_packet_desc[i].length;
+      packets[i].transferred_length = 0;
+      packets[i].status = status;
+    }
+    closure = base::Bind(iso_callback_, buffer_, packets);
+  } else {
+    closure = base::Bind(callback_, status, buffer_, bytes_transferred);
+  }
   task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&UsbDeviceHandleImpl::TransferComplete, device_handle_,
-                 base::Unretained(this),
-                 base::Bind(callback_, status, buffer_, bytes_transferred)));
+      FROM_HERE, base::Bind(&UsbDeviceHandleImpl::TransferComplete,
+                            device_handle_, base::Unretained(this), closure));
+}
+
+void UsbDeviceHandleImpl::Transfer::IsochronousTransferComplete() {
+  std::vector<IsochronousPacket> packets(platform_transfer_->num_iso_packets);
+  for (size_t i = 0; i < packets.size(); ++i) {
+    packets[i].length = platform_transfer_->iso_packet_desc[i].length;
+    packets[i].transferred_length =
+        platform_transfer_->iso_packet_desc[i].actual_length;
+    packets[i].status =
+        ConvertTransferStatus(platform_transfer_->iso_packet_desc[i].status);
+  }
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&UsbDeviceHandleImpl::TransferComplete,
+                            device_handle_, base::Unretained(this),
+                            base::Bind(iso_callback_, buffer_, packets)));
 }
 
 scoped_refptr<UsbDevice> UsbDeviceHandleImpl::GetDevice() const {
   return device_;
 }
 
 void UsbDeviceHandleImpl::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device_)
     device_->Close(this);
@@ skipping 123 matching lines @@
                             callback);
   } else {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ControlTransferInternal,
                               this, direction, request_type, recipient, request,
                               value, index, buffer, length, timeout,
                               base::ThreadTaskRunnerHandle::Get(), callback));
   }
 }
 
-void UsbDeviceHandleImpl::IsochronousTransfer(
-    UsbEndpointDirection direction,
+void UsbDeviceHandleImpl::IsochronousTransferIn(
     uint8_t endpoint_number,
-    scoped_refptr<net::IOBuffer> buffer,
-    size_t length,
-    unsigned int packets,
-    unsigned int packet_length,
+    const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
-    const TransferCallback& callback) {
+    const IsochronousTransferCallback& callback) {
   uint8_t endpoint_address =
-      ConvertTransferDirection(direction) | endpoint_number;
+      ConvertTransferDirection(USB_DIRECTION_INBOUND) | endpoint_number;
   if (task_runner_->BelongsToCurrentThread()) {
-    IsochronousTransferInternal(endpoint_address, buffer, length, packets,
-                                packet_length, timeout, task_runner_, callback);
+    IsochronousTransferInInternal(endpoint_address, packet_lengths, timeout,
+                                  task_runner_, callback);
   } else {
     task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&UsbDeviceHandleImpl::IsochronousTransferInternal, this,
-                   endpoint_address, buffer, length, packets, packet_length,
-                   timeout, base::ThreadTaskRunnerHandle::Get(), callback));
+        base::Bind(&UsbDeviceHandleImpl::IsochronousTransferInInternal, this,
+                   endpoint_address, packet_lengths, timeout,
+                   base::ThreadTaskRunnerHandle::Get(), callback));
   }
 }
 
+void UsbDeviceHandleImpl::IsochronousTransferOut(
+    uint8_t endpoint_number,
+    scoped_refptr<net::IOBuffer> buffer,
+    const std::vector<uint32_t>& packet_lengths,
+    unsigned int timeout,
+    const IsochronousTransferCallback& callback) {
+  uint8_t endpoint_address =
+      ConvertTransferDirection(USB_DIRECTION_OUTBOUND) | endpoint_number;
+  if (task_runner_->BelongsToCurrentThread()) {
+    IsochronousTransferOutInternal(endpoint_address, buffer, packet_lengths,
+                                   timeout, task_runner_, callback);
+  } else {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&UsbDeviceHandleImpl::IsochronousTransferOutInternal, this,
+                   endpoint_address, buffer, packet_lengths, timeout,
+                   base::ThreadTaskRunnerHandle::Get(), callback));
+  }
+}
+
 void UsbDeviceHandleImpl::GenericTransfer(UsbEndpointDirection direction,
                                           uint8_t endpoint_number,
                                           scoped_refptr<net::IOBuffer> buffer,
                                           size_t length,
                                           unsigned int timeout,
                                           const TransferCallback& callback) {
   uint8_t endpoint_address =
       ConvertTransferDirection(direction) | endpoint_number;
   if (task_runner_->BelongsToCurrentThread()) {
     GenericTransferInternal(endpoint_address, buffer, length, timeout,
@@ skipping 211 matching lines @@
       callback_task_runner, callback);
   if (!transfer) {
     RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
                         buffer, 0);
     return;
   }
 
   SubmitTransfer(std::move(transfer));
 }
 
-void UsbDeviceHandleImpl::IsochronousTransferInternal(
+void UsbDeviceHandleImpl::IsochronousTransferInInternal(
     uint8_t endpoint_address,
-    scoped_refptr<net::IOBuffer> buffer,
-    size_t length,
-    unsigned int packets,
-    unsigned int packet_length,
+    const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
-    const TransferCallback& callback) {
+    const IsochronousTransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_DISCONNECT,
-                        buffer, 0);
+    ReportIsochronousTransferError(callback_task_runner, callback,
+                                   packet_lengths, USB_TRANSFER_DISCONNECT);
     return;
   }
 
-  if (!base::IsValueInRangeForNumericType<int>(length)) {
-    USB_LOG(USER) << "Transfer too long.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+  size_t length =
+      std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(length));
+  scoped_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
+      this, endpoint_address, buffer, length, packet_lengths, timeout,
+      callback_task_runner, callback);
+
+  SubmitTransfer(std::move(transfer));
+}
+
+void UsbDeviceHandleImpl::IsochronousTransferOutInternal(
+    uint8_t endpoint_address,
+    scoped_refptr<net::IOBuffer> buffer,
+    const std::vector<uint32_t>& packet_lengths,
+    unsigned int timeout,
+    scoped_refptr<base::TaskRunner> callback_task_runner,
+    const IsochronousTransferCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!device_) {
+    ReportIsochronousTransferError(callback_task_runner, callback,
+                                   packet_lengths, USB_TRANSFER_DISCONNECT);
     return;
   }
 
+  size_t length =
+      std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
   scoped_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
-      this, endpoint_address, buffer, static_cast<int>(length), packets,
-      packet_length, timeout, callback_task_runner, callback);
+      this, endpoint_address, buffer, length, packet_lengths, timeout,
+      callback_task_runner, callback);
 
   SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::GenericTransferInternal(
     uint8_t endpoint_address,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
@@ skipping 86 matching lines @@
   // Attempt-release all the interfaces.
   // It will be retained until the transfer cancellation is finished.
   claimed_interfaces_.clear();
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = NULL;
 }
 
 }  // namespace device