Move device/usb classes from the FILE thread to UI thread.

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 139 matching lines @@
                    << ConvertPlatformUsbErrorToString(rv);
   }
   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(
+      scoped_refptr<UsbDeviceHandleImpl> device_handle,
       uint8 type,
       uint8 request,
       uint16 value,
       uint16 index,
       uint16 length,
       scoped_refptr<net::IOBuffer> buffer,
       unsigned int timeout,
+      scoped_refptr<base::SequencedTaskRunner> task_runner,
       const UsbTransferCallback& callback);
   static scoped_ptr<Transfer> CreateBulkTransfer(
+      scoped_refptr<UsbDeviceHandleImpl> device_handle,
       uint8 endpoint,
       scoped_refptr<net::IOBuffer> buffer,
       int length,
       unsigned int timeout,
+      scoped_refptr<base::SequencedTaskRunner> task_runner,
       const UsbTransferCallback& callback);
   static scoped_ptr<Transfer> CreateInterruptTransfer(
+      scoped_refptr<UsbDeviceHandleImpl> device_handle,
       uint8 endpoint,
       scoped_refptr<net::IOBuffer> buffer,
       int length,
       unsigned int timeout,
+      scoped_refptr<base::SequencedTaskRunner> task_runner,
       const UsbTransferCallback& callback);
   static scoped_ptr<Transfer> CreateIsochronousTransfer(
+      scoped_refptr<UsbDeviceHandleImpl> device_handle,
       uint8 endpoint,
       scoped_refptr<net::IOBuffer> buffer,
       size_t length,
       unsigned int packets,
       unsigned int packet_length,
       unsigned int timeout,
+      scoped_refptr<base::SequencedTaskRunner> task_runner,
       const UsbTransferCallback& callback);
 
   ~Transfer();
 
-  bool Submit(base::WeakPtr<UsbDeviceHandleImpl> device_handle);
+  void Submit();
   void Cancel();
   void ProcessCompletion();
-  void Complete(UsbTransferStatus status, size_t bytes_transferred);
+  void TransferComplete(UsbTransferStatus status, size_t bytes_transferred);
 
   const UsbDeviceHandleImpl::InterfaceClaimer* claimed_interface() const {
     return claimed_interface_.get();
   }
 
  private:
-  Transfer(UsbTransferType transfer_type,
+  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::SequencedTaskRunner> task_runner,
            const UsbTransferCallback& callback);
 
   static void LIBUSB_CALL PlatformCallback(PlatformUsbTransferHandle handle);
 
   UsbTransferType transfer_type_;
-  base::WeakPtr<UsbDeviceHandleImpl> device_handle_;
+  scoped_refptr<UsbDeviceHandleImpl> device_handle_;
   PlatformUsbTransferHandle platform_transfer_;
   scoped_refptr<net::IOBuffer> buffer_;
   scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer> claimed_interface_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   size_t length_;
   bool cancelled_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
   UsbTransferCallback callback_;
-  scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner_;
 };
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateControlTransfer(
+    scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8 type,
     uint8 request,
     uint16 value,
     uint16 index,
     uint16 length,
     scoped_refptr<net::IOBuffer> buffer,
     unsigned int timeout,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
     const UsbTransferCallback& callback) {
-  scoped_ptr<Transfer> transfer(new Transfer(USB_TRANSFER_CONTROL, buffer,
-                                             length + LIBUSB_CONTROL_SETUP_SIZE,
-                                             callback));
+  scoped_ptr<Transfer> transfer(
+      new Transfer(device_handle, nullptr, USB_TRANSFER_CONTROL, buffer,
+                   length + LIBUSB_CONTROL_SETUP_SIZE, task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_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() */
+                               device_handle->handle_,
                                reinterpret_cast<uint8*>(buffer->data()),
                                &UsbDeviceHandleImpl::Transfer::PlatformCallback,
                                transfer.get(), timeout);
 
   return transfer.Pass();
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateBulkTransfer(
+    scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8 endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
     const UsbTransferCallback& callback) {
-  scoped_ptr<Transfer> transfer(
-      new Transfer(USB_TRANSFER_BULK, buffer, length, callback));
+  scoped_ptr<Transfer> transfer(new Transfer(
+      device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
+      USB_TRANSFER_BULK, buffer, length, 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_,
-                            nullptr, /* filled in by Submit() */
-                            endpoint, reinterpret_cast<uint8*>(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*>(buffer->data()), static_cast<int>(length),
+      &UsbDeviceHandleImpl::Transfer::PlatformCallback, transfer.get(),
+      timeout);
 
   return transfer.Pass();
 }
 
 // static
 scoped_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer(
+    scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8 endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
     const UsbTransferCallback& callback) {
-  scoped_ptr<Transfer> transfer(
-      new Transfer(USB_TRANSFER_INTERRUPT, buffer, length, callback));
+  scoped_ptr<Transfer> transfer(new Transfer(
+      device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
+      USB_TRANSFER_INTERRUPT, buffer, length, 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_, nullptr, /* filled in by Submit() */
-      endpoint, reinterpret_cast<uint8*>(buffer->data()),
-      static_cast<int>(length),
+      transfer->platform_transfer_, device_handle->handle_, 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(
+    scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8 endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int packets,
     unsigned int packet_length,
     unsigned int timeout,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
     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));
+  scoped_ptr<Transfer> transfer(new Transfer(
+      device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
+      USB_TRANSFER_ISOCHRONOUS, buffer, length, task_runner, callback));
 
   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_, nullptr, /* filled in by Submit() */
-      endpoint, reinterpret_cast<uint8*>(buffer->data()),
-      static_cast<int>(length), packets, &Transfer::PlatformCallback,
-      transfer.get(), timeout);
+      transfer->platform_transfer_, device_handle->handle_, 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);
 
   return transfer.Pass();
 }
 
-UsbDeviceHandleImpl::Transfer::Transfer(UsbTransferType transfer_type,
-                                        scoped_refptr<net::IOBuffer> buffer,
-                                        size_t length,
-                                        const UsbTransferCallback& callback)
+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::SequencedTaskRunner> task_runner,
+    const UsbTransferCallback& callback)
     : transfer_type_(transfer_type),
+      device_handle_(device_handle),
+      platform_transfer_(NULL),
       buffer_(buffer),
+      claimed_interface_(claimed_interface),
       length_(length),
       cancelled_(false),
+      task_runner_(task_runner),
       callback_(callback) {
-  // Remember the thread from which this transfer was created so that |callback|
-  // can be dispatched there.
-  callback_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 UsbDeviceHandleImpl::Transfer::~Transfer() {
   if (platform_transfer_) {
     libusb_free_transfer(platform_transfer_);
   }
 }
 
-bool UsbDeviceHandleImpl::Transfer::Submit(
-    base::WeakPtr<UsbDeviceHandleImpl> device_handle) {
-  device_handle_ = device_handle;
-  // Remember the thread from which this transfer was submitted so that it can
-  // be marked complete there.
-  task_runner_ = base::ThreadTaskRunnerHandle::Get();
-  // GetClaimedInterfaceForEndpoint may return nullptr. libusb_submit_transfer
-  // will fail if it requires an interface we didn't claim.
-  claimed_interface_ = device_handle->GetClaimedInterfaceForEndpoint(
-      platform_transfer_->endpoint);
-  platform_transfer_->dev_handle = device_handle_->handle_;
-
+void UsbDeviceHandleImpl::Transfer::Submit() {
   const int rv = libusb_submit_transfer(platform_transfer_);
-  if (rv == LIBUSB_SUCCESS) {
-    return true;
-  } else {
+  if (rv != LIBUSB_SUCCESS) {
     USB_LOG(EVENT) << "Failed to submit transfer: "
                    << ConvertPlatformUsbErrorToString(rv);
-    Complete(USB_TRANSFER_ERROR, 0);
-    return false;
+    TransferComplete(USB_TRANSFER_ERROR, 0);
   }
 }
 
 void UsbDeviceHandleImpl::Transfer::Cancel() {
   if (!cancelled_) {
     libusb_cancel_transfer(platform_transfer_);
     claimed_interface_ = nullptr;
   }
   cancelled_ = true;
 }
@@ skipping 58 matching lines @@
 
     case USB_TRANSFER_BULK:
     case USB_TRANSFER_INTERRUPT:
       break;
 
     default:
       NOTREACHED() << "Invalid usb transfer type";
       break;
   }
 
-  Complete(ConvertTransferStatus(platform_transfer_->status), actual_length);
-}
-
-void UsbDeviceHandleImpl::Transfer::Complete(UsbTransferStatus status,
-                                             size_t bytes_transferred) {
-  if (callback_task_runner_->RunsTasksOnCurrentThread()) {
-    callback_.Run(status, buffer_, bytes_transferred);
-  } else {
-    callback_task_runner_->PostTask(
-        FROM_HERE, base::Bind(callback_, status, buffer_, bytes_transferred));
-  }
+  TransferComplete(ConvertTransferStatus(platform_transfer_->status),
+                   actual_length);
 }
 
 /* static */
 void LIBUSB_CALL UsbDeviceHandleImpl::Transfer::PlatformCallback(
     PlatformUsbTransferHandle platform_transfer) {
-  scoped_ptr<Transfer> transfer(
-      reinterpret_cast<Transfer*>(platform_transfer->user_data));
+  Transfer* transfer =
+      reinterpret_cast<Transfer*>(platform_transfer->user_data);
   DCHECK(transfer->platform_transfer_ == platform_transfer);
-
-  // Because device_handle_ is a weak pointer it is guaranteed that the callback
-  // will be discarded if the handle has been freed.
-  Transfer* tmp_transfer = transfer.get();  // base::Passed invalidates transfer
-  tmp_transfer->task_runner_->PostTask(
-      FROM_HERE, base::Bind(&UsbDeviceHandleImpl::CompleteTransfer,
-                            tmp_transfer->device_handle_,
-                            base::Passed(&transfer)));
+  transfer->ProcessCompletion();
 }
 
-UsbDeviceHandleImpl::UsbDeviceHandleImpl(scoped_refptr<UsbContext> context,
-                                         scoped_refptr<UsbDeviceImpl> device,
-                                         PlatformUsbDeviceHandle handle)
+void UsbDeviceHandleImpl::Transfer::TransferComplete(UsbTransferStatus status,
+                                                     size_t bytes_transferred) {
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandleImpl::TransferComplete, device_handle_,
+                 base::Owned(this),
+                 base::Bind(callback_, status, buffer_, bytes_transferred)));
+}
+
+UsbDeviceHandleImpl::UsbDeviceHandleImpl(
+    scoped_refptr<UsbContext> context,
+    scoped_refptr<UsbDeviceImpl> device,
+    PlatformUsbDeviceHandle handle,
+    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
     : device_(device),
       handle_(handle),
       context_(context),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      weak_factory_(this) {
+      blocking_task_runner_(blocking_task_runner) {
   DCHECK(handle) << "Cannot create device with NULL handle.";
 }
 
 UsbDeviceHandleImpl::~UsbDeviceHandleImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   libusb_close(handle_);
   handle_ = NULL;
 }
 
 scoped_refptr<UsbDevice> UsbDeviceHandleImpl::GetDevice() const {
   return device_;
 }
 
 void UsbDeviceHandleImpl::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device_)
     device_->Close(this);
 }
 
-bool UsbDeviceHandleImpl::SetConfiguration(int configuration_value) {
+void UsbDeviceHandleImpl::SetConfiguration(int configuration_value,
+                                           const UsbSuccessCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_) {
-    return false;
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
+    return;
   }
 
   for (Transfer* transfer : transfers_) {
     transfer->Cancel();
   }
   claimed_interfaces_.clear();
 
-  int rv = libusb_set_configuration(handle_, configuration_value);
-  if (rv == LIBUSB_SUCCESS) {
-    device_->RefreshConfiguration();
-    RefreshEndpointMap();
-  } else {
-    USB_LOG(EVENT) << "Failed to set configuration " << configuration_value
-                   << ": " << ConvertPlatformUsbErrorToString(rv);
-  }
-  return rv == LIBUSB_SUCCESS;
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandleImpl::SetConfigurationOnBlockingThread, this,
+                 handle_, configuration_value, callback));
 }
 
-bool UsbDeviceHandleImpl::ClaimInterface(const int interface_number) {
+void UsbDeviceHandleImpl::ClaimInterface(int interface_number,
+                                         const UsbSuccessCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
+    return;
+  }
+  if (ContainsKey(claimed_interfaces_, interface_number)) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));

[Ken Rockot(use gerrit already), 2015/04/07 22:09:43]

nit: Maybe it doesn't matter, but is there realistically any concern over
ClaimInterface (and some of these other methods) supporting reentrancy? It seems
unlikely that calling the callback directly here would be a problem.

[Reilly Grant (use Gerrit), 2015/04/08 21:39:03]

I'll change it because I've recently decided that no, I don't care about calling
the callback directly.

+    return;
+  }
+
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandleImpl::ClaimInterfaceOnBlockingThread, this,
+                 handle_, interface_number, callback));
+}
+
+bool UsbDeviceHandleImpl::ReleaseInterface(int interface_number) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return false;
-  if (ContainsKey(claimed_interfaces_, interface_number))
-    return true;
-
-  scoped_refptr<InterfaceClaimer> claimer =
-      new InterfaceClaimer(this, interface_number);
-
-  if (claimer->Claim()) {
-    claimed_interfaces_[interface_number] = claimer;
-    RefreshEndpointMap();
-    return true;
-  }
-  return false;
-}
-
-bool UsbDeviceHandleImpl::ReleaseInterface(const int interface_number) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!device_)
-    return false;
   if (!ContainsKey(claimed_interfaces_, interface_number))
     return false;
 
   // Cancel all the transfers on that interface.
   InterfaceClaimer* interface_claimer =
       claimed_interfaces_[interface_number].get();
   for (Transfer* transfer : transfers_) {
     if (transfer->claimed_interface() == interface_claimer) {
       transfer->Cancel();
     }
   }
   claimed_interfaces_.erase(interface_number);
 
   RefreshEndpointMap();
   return true;
 }
 
-bool UsbDeviceHandleImpl::SetInterfaceAlternateSetting(
-    const int interface_number,
-    const int alternate_setting) {
+void UsbDeviceHandleImpl::SetInterfaceAlternateSetting(
+    int interface_number,
+    int alternate_setting,
+    const UsbSuccessCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!device_)
-    return false;
-  if (!ContainsKey(claimed_interfaces_, interface_number))
-    return false;
-  const int rv = libusb_set_interface_alt_setting(
-      handle_, interface_number, alternate_setting);
-  if (rv == LIBUSB_SUCCESS) {
-    claimed_interfaces_[interface_number]->set_alternate_setting(
-        alternate_setting);
-    RefreshEndpointMap();
-  } else {
-    USB_LOG(EVENT) << "Failed to set interface " << interface_number
-                   << " to alternate setting " << alternate_setting << ": "
-                   << ConvertPlatformUsbErrorToString(rv);
+  if (!device_ || !ContainsKey(claimed_interfaces_, interface_number)) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
+    return;
   }
-  return rv == LIBUSB_SUCCESS;
+
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &UsbDeviceHandleImpl::SetInterfaceAlternateSettingOnBlockingThread,
+          this, handle_, interface_number, alternate_setting, callback));
 }
 
-bool UsbDeviceHandleImpl::ResetDevice() {
+void UsbDeviceHandleImpl::ResetDevice(const UsbSuccessCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!device_)
-    return false;
-
-  const int rv = libusb_reset_device(handle_);
-  if (rv != LIBUSB_SUCCESS) {
-    USB_LOG(EVENT) << "Failed to reset device: "
-                   << ConvertPlatformUsbErrorToString(rv);
-  }
-  return rv == LIBUSB_SUCCESS;
-}
-
-bool UsbDeviceHandleImpl::GetStringDescriptor(uint8 string_id,
-                                              base::string16* string) {
-  if (!GetSupportedLanguages()) {
-    return false;
+  if (!device_) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
+    return;
   }
 
-  std::map<uint8, base::string16>::const_iterator it = strings_.find(string_id);
-  if (it != strings_.end()) {
-    *string = it->second;
-    return true;
-  }
-
-  for (size_t i = 0; i < languages_.size(); ++i) {
-    // Get the string using language ID.
-    uint16 language_id = languages_[i];
-    // The 1-byte length field limits the descriptor to 256-bytes (128 char16s).
-    base::char16 text[128];
-    int size =
-        libusb_get_string_descriptor(handle_,
-                                     string_id,
-                                     language_id,
-                                     reinterpret_cast<unsigned char*>(&text[0]),
-                                     sizeof(text));
-    if (size < 0) {
-      USB_LOG(EVENT) << "Failed to get string descriptor " << string_id
-                     << " (langid " << language_id
-                     << "): " << ConvertPlatformUsbErrorToString(size);
-      continue;
-    } else if (size < 2) {
-      USB_LOG(EVENT) << "String descriptor " << string_id << " (langid "
-                     << language_id << ") has no header.";
-      continue;
-      // The first 2 bytes of the descriptor are the total length and type tag.
-    } else if ((text[0] & 0xff) != size) {
-      USB_LOG(EVENT) << "String descriptor " << string_id << " (langid "
-                     << language_id << ") size mismatch: " << (text[0] & 0xff)
-                     << " != " << size;
-      continue;
-    } else if ((text[0] >> 8) != LIBUSB_DT_STRING) {
-      USB_LOG(EVENT) << "String descriptor " << string_id << " (langid "
-                     << language_id << ") is not a string descriptor.";
-      continue;
-    }
-
-    *string = base::string16(text + 1, (size - 2) / 2);
-    strings_[string_id] = *string;
-    return true;
-  }
-
-  return false;
+  blocking_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ResetDeviceOnBlockingThread,
+                            this, handle_, callback));
 }
 
 void UsbDeviceHandleImpl::ControlTransfer(UsbEndpointDirection direction,
                                           TransferRequestType request_type,
                                           TransferRecipient recipient,
                                           uint8 request,
                                           uint16 value,
                                           uint16 index,
                                           net::IOBuffer* buffer,
                                           size_t length,
                                           unsigned int timeout,
                                           const UsbTransferCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!device_) {
+    callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
+    return;
+  }
+
   if (length > UINT16_MAX) {
     USB_LOG(USER) << "Transfer too long.";
     callback.Run(USB_TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   const size_t resized_length = LIBUSB_CONTROL_SETUP_SIZE + length;
   scoped_refptr<net::IOBuffer> resized_buffer(
       new net::IOBufferWithSize(static_cast<int>(resized_length)));
   if (!resized_buffer.get()) {
     callback.Run(USB_TRANSFER_ERROR, buffer, 0);
     return;
   }
   memcpy(resized_buffer->data() + LIBUSB_CONTROL_SETUP_SIZE, buffer->data(),
          length);
 
   scoped_ptr<Transfer> transfer = Transfer::CreateControlTransfer(
-      CreateRequestType(direction, request_type, recipient), request, value,
-      index, static_cast<uint16>(length), resized_buffer, timeout, callback);
+      this, CreateRequestType(direction, request_type, recipient), request,
+      value, index, static_cast<uint16>(length), resized_buffer, timeout,
+      task_runner_, callback);
   if (!transfer) {
     callback.Run(USB_TRANSFER_ERROR, buffer, 0);
     return;
   }
 
-  PostOrSubmitTransfer(transfer.Pass());
+  SubmitTransfer(transfer.Pass());
 }
 
 void UsbDeviceHandleImpl::BulkTransfer(const UsbEndpointDirection direction,
                                        const uint8 endpoint,
                                        net::IOBuffer* buffer,
                                        const size_t length,
                                        const unsigned int timeout,
                                        const UsbTransferCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!device_) {
+    callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
+    return;
+  }
+
   if (length > INT_MAX) {
     USB_LOG(USER) << "Transfer too long.";
     callback.Run(USB_TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   scoped_ptr<Transfer> transfer = Transfer::CreateBulkTransfer(
-      ConvertTransferDirection(direction) | endpoint, buffer,
-      static_cast<int>(length), timeout, callback);
+      this, ConvertTransferDirection(direction) | endpoint, buffer,
+      static_cast<int>(length), timeout, task_runner_, callback);
 
-  PostOrSubmitTransfer(transfer.Pass());
+  SubmitTransfer(transfer.Pass());
 }
 
 void UsbDeviceHandleImpl::InterruptTransfer(
     UsbEndpointDirection direction,
     uint8 endpoint,
     net::IOBuffer* buffer,
     size_t length,
     unsigned int timeout,
     const UsbTransferCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!device_) {
+    callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
+    return;
+  }
+
   if (length > INT_MAX) {
     USB_LOG(USER) << "Transfer too long.";
     callback.Run(USB_TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   scoped_ptr<Transfer> transfer = Transfer::CreateInterruptTransfer(
-      ConvertTransferDirection(direction) | endpoint, buffer,
-      static_cast<int>(length), timeout, callback);
+      this, ConvertTransferDirection(direction) | endpoint, buffer,
+      static_cast<int>(length), timeout, task_runner_, callback);
 
-  PostOrSubmitTransfer(transfer.Pass());
+  SubmitTransfer(transfer.Pass());
 }
 
 void UsbDeviceHandleImpl::IsochronousTransfer(
     const UsbEndpointDirection direction,
     const uint8 endpoint,
     net::IOBuffer* buffer,
     const size_t length,
     const unsigned int packets,
     const unsigned int packet_length,
     const unsigned int timeout,
     const UsbTransferCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!device_) {
+    callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
+    return;
+  }
+
   if (length > INT_MAX) {
     USB_LOG(USER) << "Transfer too long.";
     callback.Run(USB_TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   scoped_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
-      ConvertTransferDirection(direction) | endpoint, buffer,
-      static_cast<int>(length), packets, packet_length, timeout, callback);
+      this, ConvertTransferDirection(direction) | endpoint, buffer,
+      static_cast<int>(length), packets, packet_length, timeout, task_runner_,
+      callback);
 
-  PostOrSubmitTransfer(transfer.Pass());
+  SubmitTransfer(transfer.Pass());
+}
+
+void UsbDeviceHandleImpl::SetConfigurationOnBlockingThread(
+    PlatformUsbDeviceHandle handle,
+    int configuration_value,
+    const UsbSuccessCallback& callback) {
+  int rv = libusb_set_configuration(handle_, configuration_value);
+  if (rv != LIBUSB_SUCCESS) {
+    USB_LOG(EVENT) << "Failed to set configuration " << configuration_value
+                   << ": " << ConvertPlatformUsbErrorToString(rv);
+  }
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&UsbDeviceHandleImpl::SetConfigurationComplete,
+                            this, rv == LIBUSB_SUCCESS, callback));
+}
+
+void UsbDeviceHandleImpl::SetConfigurationComplete(
+    bool success,
+    const UsbSuccessCallback& callback) {
+  if (success) {
+    device_->RefreshConfiguration();
+    RefreshEndpointMap();
+  }
+  callback.Run(success);
+}
+
+void UsbDeviceHandleImpl::ClaimInterfaceOnBlockingThread(
+    PlatformUsbDeviceHandle handle,
+    int interface_number,
+    const UsbSuccessCallback& callback) {
+  int rv = libusb_claim_interface(handle, interface_number);
+  if (rv != LIBUSB_SUCCESS) {
+    VLOG(1) << "Failed to claim interface: "
+            << ConvertPlatformUsbErrorToString(rv);
+  }
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ClaimInterfaceComplete, this,
+                            interface_number, rv == LIBUSB_SUCCESS, callback));
+}
+
+void UsbDeviceHandleImpl::ClaimInterfaceComplete(
+    int interface_number,
+    bool success,
+    const UsbSuccessCallback& callback) {
+  if (success) {
+    claimed_interfaces_[interface_number] =
+        new InterfaceClaimer(this, interface_number);
+    RefreshEndpointMap();
+  }
+  callback.Run(success);
+}
+
+void UsbDeviceHandleImpl::SetInterfaceAlternateSettingOnBlockingThread(
+    PlatformUsbDeviceHandle handle,
+    int interface_number,
+    int alternate_setting,
+    const UsbSuccessCallback& callback) {
+  int rv = libusb_set_interface_alt_setting(handle, interface_number,
+                                            alternate_setting);
+  if (rv != LIBUSB_SUCCESS) {
+    USB_LOG(EVENT) << "Failed to set interface " << interface_number
+                   << " to alternate setting " << alternate_setting << ": "
+                   << ConvertPlatformUsbErrorToString(rv);
+  }
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandleImpl::SetInterfaceAlternateSettingComplete,
+                 this, interface_number, alternate_setting,
+                 rv == LIBUSB_SUCCESS, callback));
+}
+
+void UsbDeviceHandleImpl::SetInterfaceAlternateSettingComplete(
+    int interface_number,
+    int alternate_setting,
+    bool success,
+    const UsbSuccessCallback& callback) {
+  if (success) {
+    claimed_interfaces_[interface_number]->set_alternate_setting(
+        alternate_setting);
+    RefreshEndpointMap();
+  }
+  callback.Run(success);
+}
+
+void UsbDeviceHandleImpl::ResetDeviceOnBlockingThread(
+    PlatformUsbDeviceHandle handle,
+    const UsbSuccessCallback& callback) {
+  int rv = libusb_reset_device(handle);
+  if (rv != LIBUSB_SUCCESS) {
+    USB_LOG(EVENT) << "Failed to reset device: "
+                   << ConvertPlatformUsbErrorToString(rv);
+  }
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ResetDeviceComplete, this,
+                            rv == LIBUSB_SUCCESS, callback));
+}
+
+void UsbDeviceHandleImpl::ResetDeviceComplete(
+    bool success,
+    const UsbSuccessCallback& callback) {
+  callback.Run(success);
 }
 
 void UsbDeviceHandleImpl::RefreshEndpointMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
   endpoint_map_.clear();
   const UsbConfigDescriptor* config = device_->GetConfiguration();
   if (config) {
     for (const auto& map_entry : claimed_interfaces_) {
       int interface_number = map_entry.first;
       const scoped_refptr<InterfaceClaimer>& claimed_iface = map_entry.second;
@@ skipping 11 matching lines @@
   }
 }
 
 scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer>
 UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(unsigned char endpoint) {
   if (ContainsKey(endpoint_map_, endpoint))
     return claimed_interfaces_[endpoint_map_[endpoint]];
   return NULL;
 }
 
-void UsbDeviceHandleImpl::PostOrSubmitTransfer(scoped_ptr<Transfer> transfer) {
-  if (task_runner_->RunsTasksOnCurrentThread()) {
-    SubmitTransfer(transfer.Pass());
-  } else {
-    task_runner_->PostTask(
-        FROM_HERE, base::Bind(&UsbDeviceHandleImpl::SubmitTransfer, this,
-                              base::Passed(&transfer)));
-  }
-}
-
 void UsbDeviceHandleImpl::SubmitTransfer(scoped_ptr<Transfer> transfer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (device_) {
-    if (transfer->Submit(weak_factory_.GetWeakPtr())) {
-      // Transfer is now owned by libusb until its completion callback is run.
-      // This object holds a weak reference.
-      transfers_.insert(transfer.release());
-    }
-  } else {
-    transfer->Complete(USB_TRANSFER_DISCONNECT, 0);
-  }
+  // Transfer is owned by libusb until its completion callback is run. This
+  // object holds a weak reference.
+  transfers_.insert(transfer.get());
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&Transfer::Submit, base::Unretained(transfer.release())));
 }
 
-void UsbDeviceHandleImpl::CompleteTransfer(scoped_ptr<Transfer> transfer) {
-  DCHECK(ContainsKey(transfers_, transfer.get()))
-      << "Missing transfer completed";
-  transfers_.erase(transfer.get());
-  transfer->ProcessCompletion();
-}
-
-bool UsbDeviceHandleImpl::GetSupportedLanguages() {
-  if (!languages_.empty()) {
-    return true;
-  }
-
-  // The 1-byte length field limits the descriptor to 256-bytes (128 uint16s).
-  uint16 languages[128];
-  int size = libusb_get_string_descriptor(
-      handle_,
-      0,
-      0,
-      reinterpret_cast<unsigned char*>(&languages[0]),
-      sizeof(languages));
-  if (size < 0) {
-    USB_LOG(EVENT) << "Failed to get list of supported languages: "
-                   << ConvertPlatformUsbErrorToString(size);
-    return false;
-  } else if (size < 2) {
-    USB_LOG(EVENT) << "String descriptor zero has no header.";
-    return false;
-    // The first 2 bytes of the descriptor are the total length and type tag.
-  } else if ((languages[0] & 0xff) != size) {
-    USB_LOG(EVENT) << "String descriptor zero size mismatch: "
-                   << (languages[0] & 0xff) << " != " << size;
-    return false;
-  } else if ((languages[0] >> 8) != LIBUSB_DT_STRING) {
-    USB_LOG(EVENT) << "String descriptor zero is not a string descriptor.";
-    return false;
-  }
-
-  languages_.assign(languages[1], languages[(size - 2) / 2]);
-  return true;
+void UsbDeviceHandleImpl::TransferComplete(Transfer* transfer,
+                                           const base::Closure& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(ContainsKey(transfers_, transfer)) << "Missing transfer completed";
+  transfers_.erase(transfer);
+  callback.Run();
 }
 
 void UsbDeviceHandleImpl::InternalClose() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return;
 
   // Cancel all the transfers.
   for (Transfer* transfer : transfers_) {
     // The callback will be called some time later.
     transfer->Cancel();
   }
 
   // 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