Revert of 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,
-      const std::vector<uint32_t>& packet_lengths,
+      unsigned int packets,
+      unsigned int packet_length,
       unsigned int timeout,
-      scoped_refptr<base::TaskRunner> callback_task_runner,
-      const IsochronousTransferCallback& callback);
+      scoped_refptr<base::TaskRunner> task_runner,
+      const TransferCallback& 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()), length,
-                            &UsbDeviceHandleImpl::Transfer::PlatformCallback,
-                            transfer.get(), timeout);
+  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);
 
   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()), length,
+      reinterpret_cast<uint8_t*>(buffer->data()), static_cast<int>(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,
-    const std::vector<uint32_t>& packet_lengths,
+    unsigned int packets,
+    unsigned int packet_length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
-    const IsochronousTransferCallback& callback) {
+    const TransferCallback& callback) {
+  DCHECK(packets <= length && (packets * packet_length) <= length)
+      << "transfer length is too small";
+
   scoped_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
-      buffer, callback_task_runner, callback));
+      USB_TRANSFER_ISOCHRONOUS, buffer, length, callback_task_runner,
+      callback));
 
-  int num_packets = static_cast<int>(packet_lengths.size());
-  transfer->platform_transfer_ = libusb_alloc_transfer(num_packets);
+  transfer->platform_transfer_ = libusb_alloc_transfer(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),
-      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];
+      packets, &Transfer::PlatformCallback, transfer.get(), timeout);
+  libusb_set_iso_packet_lengths(transfer->platform_transfer_, packet_length);
 
   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!
+      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:
-      TransferComplete(ConvertTransferStatus(platform_transfer_->status),
-                       actual_length);
-      break;
-
-    case USB_TRANSFER_ISOCHRONOUS:
-      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), 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)));
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandleImpl::TransferComplete, device_handle_,
+                 base::Unretained(this),
+                 base::Bind(callback_, status, buffer_, bytes_transferred)));
 }
 
 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::IsochronousTransferIn(
+void UsbDeviceHandleImpl::IsochronousTransfer(
+    UsbEndpointDirection direction,
     uint8_t endpoint_number,
-    const std::vector<uint32_t>& packet_lengths,
+    scoped_refptr<net::IOBuffer> buffer,
+    size_t length,
+    unsigned int packets,
+    unsigned int packet_length,
     unsigned int timeout,
-    const IsochronousTransferCallback& callback) {
+    const TransferCallback& callback) {
   uint8_t endpoint_address =
-      ConvertTransferDirection(USB_DIRECTION_INBOUND) | endpoint_number;
+      ConvertTransferDirection(direction) | endpoint_number;
   if (task_runner_->BelongsToCurrentThread()) {
-    IsochronousTransferInInternal(endpoint_address, packet_lengths, timeout,
-                                  task_runner_, callback);
+    IsochronousTransferInternal(endpoint_address, buffer, length, packets,
+                                packet_length, timeout, task_runner_, callback);
   } else {
     task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&UsbDeviceHandleImpl::IsochronousTransferInInternal, this,
-                   endpoint_address, packet_lengths, timeout,
-                   base::ThreadTaskRunnerHandle::Get(), callback));
+        base::Bind(&UsbDeviceHandleImpl::IsochronousTransferInternal, this,
+                   endpoint_address, buffer, length, packets, packet_length,
+                   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::IsochronousTransferInInternal(
+void UsbDeviceHandleImpl::IsochronousTransferInternal(
     uint8_t endpoint_address,
-    const std::vector<uint32_t>& packet_lengths,
+    scoped_refptr<net::IOBuffer> buffer,
+    size_t length,
+    unsigned int packets,
+    unsigned int packet_length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
-    const IsochronousTransferCallback& callback) {
+    const TransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
-    ReportIsochronousTransferError(callback_task_runner, callback,
-                                   packet_lengths, USB_TRANSFER_DISCONNECT);
+    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_DISCONNECT,
+                        buffer, 0);
     return;
   }
 
-  size_t length =
-      std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
-  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(length));
+  if (!base::IsValueInRangeForNumericType<int>(length)) {
+    USB_LOG(USER) << "Transfer too long.";
+    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
+                        buffer, 0);
+    return;
+  }
+
   scoped_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
-      this, endpoint_address, buffer, length, packet_lengths, timeout,
-      callback_task_runner, callback);
+      this, endpoint_address, buffer, static_cast<int>(length), packets,
+      packet_length, 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, 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,
     const TransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 83 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