Rename TaskRunner::RunsTasksOnCurrentThread() in //device, //services

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 <memory>
 #include <numeric>
 #include <utility>
@@ skipping 94 matching lines @@
   NOTREACHED();
   return UsbTransferStatus::TRANSFER_ERROR;
 }
 
 static void RunTransferCallback(
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const UsbDeviceHandle::TransferCallback& callback,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t result) {
-  if (callback_task_runner->RunsTasksOnCurrentThread()) {
+  if (callback_task_runner->RunsTasksInCurrentSequence()) {
     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()) {
+  if (callback_task_runner->RunsTasksInCurrentSequence()) {
     callback.Run(nullptr, packets);
   } else {
     callback_task_runner->PostTask(FROM_HERE,
                                    base::Bind(callback, nullptr, packets));
   }
 }
 
 }  // namespace
 
 class UsbDeviceHandleImpl::InterfaceClaimer
@@ skipping 653 matching lines @@
       blocking_task_runner_(blocking_task_runner) {
   DCHECK(handle) << "Cannot create device with NULL handle.";
 }
 
 UsbDeviceHandleImpl::~UsbDeviceHandleImpl() {
   DCHECK(!device_) << "UsbDeviceHandle must be closed before it is destroyed.";
 
   // This class is RefCountedThreadSafe and so the destructor may be called on
   // any thread. libusb is not safe to reentrancy so be sure not to try to close
   // the device from inside a transfer completion callback.
-  if (blocking_task_runner_->RunsTasksOnCurrentThread()) {
+  if (blocking_task_runner_->RunsTasksInCurrentSequence()) {
     libusb_close(handle_);
   } else {
     blocking_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&libusb_close, handle_));
   }
 }
 
 void UsbDeviceHandleImpl::SetConfigurationOnBlockingThread(
     int configuration_value,
     const ResultCallback& callback) {
@@ skipping 313 matching lines @@
       base::Bind(&Transfer::Submit, base::Unretained(transfer.release())));
 }
 
 void UsbDeviceHandleImpl::TransferComplete(Transfer* transfer,
                                            const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(base::ContainsKey(transfers_, transfer))
       << "Missing transfer completed";
   transfers_.erase(transfer);
 
-  if (transfer->callback_task_runner()->RunsTasksOnCurrentThread()) {
+  if (transfer->callback_task_runner()->RunsTasksInCurrentSequence()) {
     callback.Run();
   } else {
     transfer->callback_task_runner()->PostTask(FROM_HERE, callback);
   }
 
   // libusb_free_transfer races with libusb_submit_transfer and only work-
   // around is to make sure to call them on the same thread.
   blocking_task_runner_->DeleteSoon(FROM_HERE, transfer);
 }
 
 }  // namespace device