Resolve two USB transfer handling regressions.

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 <vector>
 
 #include "base/bind.h"
@@ skipping 140 matching lines @@
   return rv == LIBUSB_SUCCESS;
 }
 
 // This inner class owns the underlying libusb_transfer and may outlast
 // the UsbDeviceHandle that created it.
 class UsbDeviceHandleImpl::Transfer {
  public:
   static scoped_ptr<Transfer> CreateControlTransfer(
       uint8 type,
       uint8 request,
-      uint8 value,
-      uint8 index,
+      uint16 value,
+      uint16 index,
       uint16 length,
       scoped_refptr<net::IOBuffer> buffer,
       unsigned int timeout,
       const UsbTransferCallback& callback);
   static scoped_ptr<Transfer> CreateBulkTransfer(
       uint8 endpoint,
       scoped_refptr<net::IOBuffer> buffer,
       int length,
       unsigned int timeout,
       const UsbTransferCallback& callback);
@@ skipping 40 matching lines @@
   size_t length_;
   UsbTransferCallback callback_;
   scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner_;
 };
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateControlTransfer(
     uint8 type,
     uint8 request,
-    uint8 value,
-    uint8 index,
+    uint16 value,
+    uint16 index,
     uint16 length,
     scoped_refptr<net::IOBuffer> buffer,
     unsigned int timeout,
     const UsbTransferCallback& callback) {
   scoped_ptr<Transfer> transfer(new Transfer(USB_TRANSFER_CONTROL, buffer,
                                              length + LIBUSB_CONTROL_SETUP_SIZE,
                                              callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
+    LOG(ERROR) << "Failed to allocate control transfer.";
     return nullptr;
   }
 
   libusb_fill_control_setup(reinterpret_cast<uint8*>(buffer->data()), type,
                             request, value, index, length);
   libusb_fill_control_transfer(transfer->platform_transfer_,
                                nullptr, /* filled in by Submit() */
                                reinterpret_cast<uint8*>(buffer->data()),
                                &UsbDeviceHandleImpl::Transfer::PlatformCallback,
                                transfer.get(), timeout);
 
   return transfer.Pass();
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateBulkTransfer(
     uint8 endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     const UsbTransferCallback& callback) {
   scoped_ptr<Transfer> transfer(
       new Transfer(USB_TRANSFER_BULK, buffer, length, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
+    LOG(ERROR) << "Failed to allocate bulk transfer.";
     return nullptr;
   }
 
   libusb_fill_bulk_transfer(transfer->platform_transfer_,
                             nullptr, /* filled in by Submit() */
                             endpoint, reinterpret_cast<uint8*>(buffer->data()),
                             static_cast<int>(length),
                             &UsbDeviceHandleImpl::Transfer::PlatformCallback,
                             transfer.get(), timeout);
 
   return transfer.Pass();
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer(
     uint8 endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     const UsbTransferCallback& callback) {
   scoped_ptr<Transfer> transfer(
       new Transfer(USB_TRANSFER_INTERRUPT, buffer, length, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
+    LOG(ERROR) << "Failed to allocate interrupt transfer.";
     return nullptr;
   }
 
   libusb_fill_interrupt_transfer(
       transfer->platform_transfer_, nullptr, /* filled in by Submit() */
       endpoint, reinterpret_cast<uint8*>(buffer->data()),
       static_cast<int>(length),
       &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
       timeout);
 
   return transfer.Pass();
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateIsochronousTransfer(
     uint8 endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int packets,
     unsigned int packet_length,
     unsigned int timeout,
     const UsbTransferCallback& callback) {
   DCHECK(packets <= length && (packets * packet_length) <= length)
       << "transfer length is too small";
 
   scoped_ptr<Transfer> transfer(
       new Transfer(USB_TRANSFER_ISOCHRONOUS, buffer, length, callback));
 
-  transfer->platform_transfer_ = libusb_alloc_transfer(0);
+  transfer->platform_transfer_ = libusb_alloc_transfer(packets);
   if (!transfer->platform_transfer_) {
+    LOG(ERROR) << "Failed to allocate isochronous transfer.";
     return nullptr;
   }
 
   libusb_fill_iso_transfer(
       transfer->platform_transfer_, nullptr, /* filled in by Submit() */
       endpoint, reinterpret_cast<uint8*>(buffer->data()),
       static_cast<int>(length), packets, &Transfer::PlatformCallback,
       transfer.get(), timeout);
   libusb_set_iso_packet_lengths(transfer->platform_transfer_, packet_length);
 
@@ skipping 504 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