Remove BrowserThread dependency from usb_service.

components/usb_service/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 "components/usb_service/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <vector>
 
-#include "base/message_loop/message_loop.h"
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
+#include "base/thread_task_runner_handle.h"
 #include "components/usb_service/usb_context.h"
 #include "components/usb_service/usb_device_impl.h"
 #include "components/usb_service/usb_error.h"
 #include "components/usb_service/usb_interface.h"
 #include "components/usb_service/usb_service.h"
-#include "content/public/browser/browser_thread.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
-using content::BrowserThread;
-
 namespace usb_service {
 
 typedef libusb_device* PlatformUsbDevice;
 
 void HandleTransferCompletion(usb_service::PlatformUsbTransferHandle transfer);
 
 namespace {
 
 static uint8 ConvertTransferDirection(const UsbEndpointDirection direction) {
   switch (direction) {
@@ skipping 62 matching lines @@
     case LIBUSB_TRANSFER_OVERFLOW:
       return USB_TRANSFER_OVERFLOW;
     case LIBUSB_TRANSFER_CANCELLED:
       return USB_TRANSFER_CANCELLED;
     default:
       NOTREACHED();
       return USB_TRANSFER_ERROR;
   }
 }
 
-static void LIBUSB_CALL
-PlatformTransferCompletionCallback(PlatformUsbTransferHandle transfer) {
-  BrowserThread::PostTask(BrowserThread::FILE,
-                          FROM_HERE,
-                          base::Bind(HandleTransferCompletion, transfer));
-}
-
 }  // namespace
 
-void HandleTransferCompletion(PlatformUsbTransferHandle transfer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  UsbDeviceHandleImpl* const device_handle =
-      reinterpret_cast<UsbDeviceHandleImpl*>(transfer->user_data);
-  CHECK(device_handle) << "Device handle is closed before transfer finishes.";
-  device_handle->TransferComplete(transfer);
-  libusb_free_transfer(transfer);
-}
-
 class UsbDeviceHandleImpl::InterfaceClaimer
     : public base::RefCountedThreadSafe<UsbDeviceHandleImpl::InterfaceClaimer> {
  public:
   InterfaceClaimer(const scoped_refptr<UsbDeviceHandleImpl> handle,
                    const int interface_number);
 
   bool Claim() const;
 
   int alternate_setting() const { return alternate_setting_; }
   void set_alternate_setting(const int alternate_setting) {
@@ skipping 29 matching lines @@
   if (rv != LIBUSB_SUCCESS) {
     VLOG(1) << "Failed to claim interface: " << ConvertErrorToString(rv);
   }
   return rv == LIBUSB_SUCCESS;
 }
 
 struct UsbDeviceHandleImpl::Transfer {
   Transfer();
   ~Transfer();
 
+  void Complete(UsbTransferStatus status, size_t bytes_transferred);
+
   UsbTransferType transfer_type;
   scoped_refptr<net::IOBuffer> buffer;
   scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer> claimed_interface;
-  scoped_refptr<base::MessageLoopProxy> message_loop_proxy;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner;
   size_t length;
   UsbTransferCallback callback;
 };
 
 UsbDeviceHandleImpl::Transfer::Transfer()
     : transfer_type(USB_TRANSFER_CONTROL), length(0) {
 }
 
 UsbDeviceHandleImpl::Transfer::~Transfer() {
 }
 
+void UsbDeviceHandleImpl::Transfer::Complete(UsbTransferStatus status,
+                                             size_t bytes_transferred) {
+  if (task_runner->RunsTasksOnCurrentThread()) {
+    callback.Run(status, buffer, bytes_transferred);
+  } else {
+    task_runner->PostTask(
+        FROM_HERE, base::Bind(callback, status, buffer, bytes_transferred));
+  }
+}
+
 UsbDeviceHandleImpl::UsbDeviceHandleImpl(
     scoped_refptr<UsbContext> context,
     UsbDeviceImpl* device,
     PlatformUsbDeviceHandle handle,
     scoped_refptr<UsbConfigDescriptor> interfaces)
     : device_(device),
       handle_(handle),
       interfaces_(interfaces),
-      context_(context) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+      context_(context),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   DCHECK(handle) << "Cannot create device with NULL handle.";
   DCHECK(interfaces_.get()) << "Unable to list interfaces";
 }
 
 UsbDeviceHandleImpl::~UsbDeviceHandleImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   libusb_close(handle_);
   handle_ = NULL;
 }
 
 scoped_refptr<UsbDevice> UsbDeviceHandleImpl::GetDevice() const {
   return static_cast<UsbDevice*>(device_);
 }
 
 void UsbDeviceHandleImpl::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device_)
     device_->Close(this);
 }
 
-void UsbDeviceHandleImpl::TransferComplete(PlatformUsbTransferHandle handle) {
+/* static */ void LIBUSB_CALL UsbDeviceHandleImpl::PlatformTransferCallback(

[Ken Rockot(use gerrit already), 2014/08/28 21:47:03]

// static 

on its own line

[Reilly Grant (use Gerrit), 2014/08/28 22:16:12]

Done.

+    PlatformUsbTransferHandle transfer) {
+  UsbDeviceHandleImpl* device_handle =
+      reinterpret_cast<UsbDeviceHandleImpl*>(transfer->user_data);
+  device_handle->task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &UsbDeviceHandleImpl::CompleteTransfer, device_handle, transfer));
+}
+
+void UsbDeviceHandleImpl::CompleteTransfer(PlatformUsbTransferHandle handle) {
   DCHECK(ContainsKey(transfers_, handle)) << "Missing transfer completed";
 
   Transfer transfer = transfers_[handle];
   transfers_.erase(handle);
 
   DCHECK_GE(handle->actual_length, 0) << "Negative actual length received";
   size_t actual_length =
       static_cast<size_t>(std::max(handle->actual_length, 0));
 
   DCHECK(transfer.length >= actual_length)
       << "data too big for our buffer (libusb failure?)";
 
-  scoped_refptr<net::IOBuffer> buffer = transfer.buffer;
   switch (transfer.transfer_type) {
     case USB_TRANSFER_CONTROL:
       // If the transfer is a control transfer we do not expose the control
       // setup header to the caller. This logic strips off the header if
       // present before invoking the callback provided with the transfer.
       if (actual_length > 0) {
         CHECK(transfer.length >= LIBUSB_CONTROL_SETUP_SIZE)
             << "buffer was not correctly set: too small for the control header";
 
         if (transfer.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(static_cast<int>(
                   std::max(actual_length, static_cast<size_t>(1))));
           memcpy(resized_buffer->data(),
-                 buffer->data() + LIBUSB_CONTROL_SETUP_SIZE,
+                 transfer.buffer->data() + LIBUSB_CONTROL_SETUP_SIZE,
                  actual_length);
-          buffer = resized_buffer;
+          transfer.buffer = resized_buffer;
         }
       }
       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 < handle->num_iso_packets; ++i) {
           PlatformUsbIsoPacketDescriptor packet = &handle->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 <=
                     transfer.length);
-              memmove(buffer->data() + actual_length,
-                      buffer->data() + packet_buffer_start,
+              memmove(transfer.buffer->data() + actual_length,
+                      transfer.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:
       break;
 
     default:
       NOTREACHED() << "Invalid usb transfer type";
       break;
   }
 
-  transfer.message_loop_proxy->PostTask(
-      FROM_HERE,
-      base::Bind(transfer.callback,
-                 ConvertTransferStatus(handle->status),
-                 buffer,
-                 actual_length));
+  transfer.Complete(ConvertTransferStatus(handle->status), actual_length);
+  libusb_free_transfer(handle);
 
   // Must release interface first before actually delete this.
   transfer.claimed_interface = NULL;
 }
 
 bool UsbDeviceHandleImpl::ClaimInterface(const int interface_number) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return false;
   if (ContainsKey(claimed_interfaces_, interface_number))
@@ skipping 237 matching lines @@
       CreateRequestType(direction, request_type, recipient);
   libusb_fill_control_setup(reinterpret_cast<uint8*>(resized_buffer->data()),
                             converted_type,
                             request,
                             value,
                             index,
                             static_cast<int16>(length));
   libusb_fill_control_transfer(transfer,
                                handle_,
                                reinterpret_cast<uint8*>(resized_buffer->data()),
-                               PlatformTransferCompletionCallback,
+                               &UsbDeviceHandleImpl::PlatformTransferCallback,
                                this,
                                timeout);
 
-  BrowserThread::PostTask(BrowserThread::FILE,
-                          FROM_HERE,
-                          base::Bind(&UsbDeviceHandleImpl::SubmitTransfer,
-                                     this,
-                                     transfer,
-                                     USB_TRANSFER_CONTROL,
-                                     resized_buffer,
-                                     resized_length,
-                                     base::MessageLoopProxy::current(),
-                                     callback));
+  PostOrSubmitTransfer(
+      transfer, USB_TRANSFER_CONTROL, resized_buffer, resized_length, callback);
 }
 
 void UsbDeviceHandleImpl::BulkTransfer(const UsbEndpointDirection direction,
                                        const uint8 endpoint,
                                        net::IOBuffer* buffer,
                                        const size_t length,
                                        const unsigned int timeout,
                                        const UsbTransferCallback& callback) {
   if (!device_) {
     callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
     return;
   }
 
   PlatformUsbTransferHandle const transfer = libusb_alloc_transfer(0);
   const uint8 new_endpoint = ConvertTransferDirection(direction) | endpoint;
   libusb_fill_bulk_transfer(transfer,
                             handle_,
                             new_endpoint,
                             reinterpret_cast<uint8*>(buffer->data()),
                             static_cast<int>(length),
-                            PlatformTransferCompletionCallback,
+                            &UsbDeviceHandleImpl::PlatformTransferCallback,
                             this,
                             timeout);
 
-  BrowserThread::PostTask(BrowserThread::FILE,
-                          FROM_HERE,
-                          base::Bind(&UsbDeviceHandleImpl::SubmitTransfer,
-                                     this,
-                                     transfer,
-                                     USB_TRANSFER_BULK,
-                                     make_scoped_refptr(buffer),
-                                     length,
-                                     base::MessageLoopProxy::current(),
-                                     callback));
+  PostOrSubmitTransfer(transfer, USB_TRANSFER_BULK, buffer, length, callback);
 }
 
 void UsbDeviceHandleImpl::InterruptTransfer(
     const UsbEndpointDirection direction,
     const uint8 endpoint,
     net::IOBuffer* buffer,
     const size_t length,
     const unsigned int timeout,
     const UsbTransferCallback& callback) {
   if (!device_) {
     callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
     return;
   }
 
   PlatformUsbTransferHandle const transfer = libusb_alloc_transfer(0);
   const uint8 new_endpoint = ConvertTransferDirection(direction) | endpoint;
   libusb_fill_interrupt_transfer(transfer,
                                  handle_,
                                  new_endpoint,
                                  reinterpret_cast<uint8*>(buffer->data()),
                                  static_cast<int>(length),
-                                 PlatformTransferCompletionCallback,
+                                 &UsbDeviceHandleImpl::PlatformTransferCallback,
                                  this,
                                  timeout);
-  BrowserThread::PostTask(BrowserThread::FILE,
-                          FROM_HERE,
-                          base::Bind(&UsbDeviceHandleImpl::SubmitTransfer,
-                                     this,
-                                     transfer,
-                                     USB_TRANSFER_INTERRUPT,
-                                     make_scoped_refptr(buffer),
-                                     length,
-                                     base::MessageLoopProxy::current(),
-                                     callback));
+
+  PostOrSubmitTransfer(
+      transfer, USB_TRANSFER_INTERRUPT, buffer, length, callback);
 }
 
 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) {
   if (!device_) {
     callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
     return;
   }
 
   const uint64 total_length = packets * packet_length;
   CHECK(packets <= length && total_length <= length)
       << "transfer length is too small";
 
   PlatformUsbTransferHandle const transfer = libusb_alloc_transfer(packets);
   const uint8 new_endpoint = ConvertTransferDirection(direction) | endpoint;
   libusb_fill_iso_transfer(transfer,
                            handle_,
                            new_endpoint,
                            reinterpret_cast<uint8*>(buffer->data()),
                            static_cast<int>(length),
                            packets,
-                           PlatformTransferCompletionCallback,
+                           &UsbDeviceHandleImpl::PlatformTransferCallback,
                            this,
                            timeout);
   libusb_set_iso_packet_lengths(transfer, packet_length);
 
-  BrowserThread::PostTask(BrowserThread::FILE,
-                          FROM_HERE,
-                          base::Bind(&UsbDeviceHandleImpl::SubmitTransfer,
-                                     this,
-                                     transfer,
-                                     USB_TRANSFER_ISOCHRONOUS,
-                                     make_scoped_refptr(buffer),
-                                     length,
-                                     base::MessageLoopProxy::current(),
-                                     callback));
+  PostOrSubmitTransfer(
+      transfer, USB_TRANSFER_ISOCHRONOUS, buffer, length, callback);
 }
 
 void UsbDeviceHandleImpl::RefreshEndpointMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
   endpoint_map_.clear();
   for (ClaimedInterfaceMap::iterator it = claimed_interfaces_.begin();
        it != claimed_interfaces_.end();
        ++it) {
     scoped_refptr<const UsbInterfaceAltSettingDescriptor> interface_desc =
         interfaces_->GetInterface(it->first)
             ->GetAltSetting(it->second->alternate_setting());
     for (size_t i = 0; i < interface_desc->GetNumEndpoints(); i++) {
       scoped_refptr<const UsbEndpointDescriptor> endpoint =
           interface_desc->GetEndpoint(i);
       endpoint_map_[endpoint->GetAddress()] = it->first;
     }
   }
 }
 
 scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer>
 UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(unsigned char endpoint) {
   unsigned char address = endpoint & LIBUSB_ENDPOINT_ADDRESS_MASK;
   if (ContainsKey(endpoint_map_, address))
     return claimed_interfaces_[endpoint_map_[address]];
   return NULL;
 }
 
+void UsbDeviceHandleImpl::PostOrSubmitTransfer(
+    PlatformUsbTransferHandle transfer,
+    UsbTransferType transfer_type,
+    net::IOBuffer* buffer,
+    size_t length,
+    const UsbTransferCallback& callback) {
+  if (task_runner_->RunsTasksOnCurrentThread()) {
+    SubmitTransfer(transfer,
+                   transfer_type,
+                   buffer,
+                   length,
+                   base::ThreadTaskRunnerHandle::Get(),
+                   callback);
+  } else {
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&UsbDeviceHandleImpl::SubmitTransfer,
+                                      this,
+                                      transfer,
+                                      transfer_type,
+                                      make_scoped_refptr(buffer),
+                                      length,
+                                      base::ThreadTaskRunnerHandle::Get(),
+                                      callback));
+  }
+}
+
 void UsbDeviceHandleImpl::SubmitTransfer(
     PlatformUsbTransferHandle handle,
     UsbTransferType transfer_type,
     net::IOBuffer* buffer,
     const size_t length,
-    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const UsbTransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!device_) {
-    message_loop_proxy->PostTask(
-        FROM_HERE,
-        base::Bind(
-            callback, USB_TRANSFER_DISCONNECT, make_scoped_refptr(buffer), 0));
-  }
 
   Transfer transfer;
   transfer.transfer_type = transfer_type;
   transfer.buffer = buffer;
   transfer.length = length;
   transfer.callback = callback;
-  transfer.message_loop_proxy = message_loop_proxy;
+  transfer.task_runner = task_runner;
+
+  if (!device_) {
+    transfer.Complete(USB_TRANSFER_DISCONNECT, 0);
+    return;
+  }
 
   // It's OK for this method to return NULL. libusb_submit_transfer will fail if
   // it requires an interface we didn't claim.
   transfer.claimed_interface = GetClaimedInterfaceForEndpoint(handle->endpoint);
 
   const int rv = libusb_submit_transfer(handle);
   if (rv == LIBUSB_SUCCESS) {
     transfers_[handle] = transfer;
   } else {
     VLOG(1) << "Failed to submit transfer: " << ConvertErrorToString(rv);
-    message_loop_proxy->PostTask(
-        FROM_HERE,
-        base::Bind(
-            callback, USB_TRANSFER_ERROR, make_scoped_refptr(buffer), 0));
+    transfer.Complete(USB_TRANSFER_ERROR, 0);
   }
 }
 
 void UsbDeviceHandleImpl::InternalClose() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return;
 
   // Cancel all the transfers.
   for (TransferMap::iterator it = transfers_.begin(); it != transfers_.end();
        ++it) {
     // The callback will be called some time later.
     libusb_cancel_transfer(it->first);
   }
 
   // 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 usb_service