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

device/bluetooth/bluetooth_socket_win.cc

 // Copyright (c) 2012 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/bluetooth/bluetooth_socket_win.h"
 
 #include <objbase.h>
 
 #include <memory>
 #include <string>
@@ skipping 60 matching lines @@
   GUID uuid;
   base::string16 name;
   WSAQUERYSET service;
 };
 
 // static
 scoped_refptr<BluetoothSocketWin>
 BluetoothSocketWin::CreateBluetoothSocket(
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<device::BluetoothSocketThread> socket_thread) {
-  DCHECK(ui_task_runner->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner->RunsTasksInCurrentSequence());
 
   return make_scoped_refptr(
       new BluetoothSocketWin(ui_task_runner, socket_thread));
 }
 
 BluetoothSocketWin::BluetoothSocketWin(
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<BluetoothSocketThread> socket_thread)
     : BluetoothSocketNet(ui_task_runner, socket_thread),
       supports_rfcomm_(false),
       rfcomm_channel_(0xFF),
       bth_addr_(BTH_ADDR_NULL) {
 }
 
 BluetoothSocketWin::~BluetoothSocketWin() {
 }
 
 void BluetoothSocketWin::Connect(
     const BluetoothDeviceWin* device,
     const BluetoothUUID& uuid,
     const base::Closure& success_callback,
     const ErrorCompletionCallback& error_callback) {
-  DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner()->RunsTasksInCurrentSequence());
   DCHECK(device);
 
   if (!uuid.IsValid()) {
     error_callback.Run(kInvalidUUID);
     return;
   }
 
   const BluetoothServiceRecordWin* service_record_win =
       device->GetServiceRecord(uuid);
   if (!service_record_win) {
@@ skipping 16 matching lines @@
           base::Bind(&BluetoothSocketWin::PostSuccess, this, success_callback),
           base::Bind(
               &BluetoothSocketWin::PostErrorCompletion, this, error_callback)));
 }
 
 void BluetoothSocketWin::Listen(scoped_refptr<BluetoothAdapter> adapter,
                                 const BluetoothUUID& uuid,
                                 const BluetoothAdapter::ServiceOptions& options,
                                 const base::Closure& success_callback,
                                 const ErrorCompletionCallback& error_callback) {
-  DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner()->RunsTasksInCurrentSequence());
 
   adapter_ = adapter;
   int rfcomm_channel = options.channel ? *options.channel : 0;
 
   // TODO(xiyuan): Use |options.name|.
   socket_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothSocketWin::DoListen,
                  this,
                  uuid,
                  rfcomm_channel,
                  success_callback,
                  error_callback));
 }
 
 void BluetoothSocketWin::ResetData() {
   if (service_reg_data_) {
     if (WSASetService(&service_reg_data_->service,RNRSERVICE_DELETE, 0) ==
         SOCKET_ERROR) {
       LOG(WARNING) << "Failed to unregister service.";
     }
     service_reg_data_.reset();
   }
 }
 
 void BluetoothSocketWin::Accept(
     const AcceptCompletionCallback& success_callback,
     const ErrorCompletionCallback& error_callback) {
-  DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner()->RunsTasksInCurrentSequence());
 
   socket_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothSocketWin::DoAccept,
                  this,
                  success_callback,
                  error_callback));
 }
 
 void BluetoothSocketWin::DoConnect(
     const base::Closure& success_callback,
     const ErrorCompletionCallback& error_callback) {
-  DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(socket_thread()->task_runner()->RunsTasksInCurrentSequence());
   base::ThreadRestrictions::AssertIOAllowed();
 
   if (tcp_socket()) {
     error_callback.Run(kSocketAlreadyConnected);
     return;
   }
 
   if (!supports_rfcomm_) {
     // TODO(youngki) add support for L2CAP sockets as well.
     error_callback.Run(kL2CAPNotSupported);
@@ skipping 36 matching lines @@
 
   SetTCPSocket(std::move(scoped_socket));
   success_callback.Run();
 }
 
 void BluetoothSocketWin::DoListen(
     const BluetoothUUID& uuid,
     int rfcomm_channel,
     const base::Closure& success_callback,
     const ErrorCompletionCallback& error_callback) {
-  DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(socket_thread()->task_runner()->RunsTasksInCurrentSequence());
   DCHECK(!tcp_socket() && !service_reg_data_);
 
   // The valid range is 0-30. 0 means BT_PORT_ANY and 1-30 are the
   // valid RFCOMM port numbers of SOCKADDR_BTH.
   if (rfcomm_channel < 0 || rfcomm_channel > 30) {
     LOG(WARNING) << "Failed to start service: "
                  << "Invalid RFCCOMM port " << rfcomm_channel
                  << ", uuid=" << uuid.value();
     PostErrorCompletion(error_callback, kInvalidRfcommPort);
     return;
@@ skipping 79 matching lines @@
 
   SetTCPSocket(std::move(scoped_socket));
   service_reg_data_ = std::move(reg_data);
 
   PostSuccess(success_callback);
 }
 
 void BluetoothSocketWin::DoAccept(
     const AcceptCompletionCallback& success_callback,
     const ErrorCompletionCallback& error_callback) {
-  DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(socket_thread()->task_runner()->RunsTasksInCurrentSequence());
   int result = tcp_socket()->Accept(
       &accept_socket_,
       &accept_address_,
       base::Bind(&BluetoothSocketWin::OnAcceptOnSocketThread,
                  this,
                  success_callback,
                  error_callback));
   if (result != net::OK && result != net::ERR_IO_PENDING) {
     LOG(WARNING) << "Failed to accept, net err=" << result;
     PostErrorCompletion(error_callback, kFailedToAccept);
   }
 }
 
 void BluetoothSocketWin::OnAcceptOnSocketThread(
     const AcceptCompletionCallback& success_callback,
     const ErrorCompletionCallback& error_callback,
     int accept_result) {
-  DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(socket_thread()->task_runner()->RunsTasksInCurrentSequence());
   if (accept_result != net::OK) {
     LOG(WARNING) << "OnAccept error, net err=" << accept_result;
     PostErrorCompletion(error_callback, kFailedToAccept);
     return;
   }
 
   ui_task_runner()->PostTask(
     FROM_HERE,
     base::Bind(&BluetoothSocketWin::OnAcceptOnUI,
                this,
                base::Passed(&accept_socket_),
                accept_address_,
                success_callback,
                error_callback));
 }
 
 void BluetoothSocketWin::OnAcceptOnUI(
     std::unique_ptr<net::TCPSocket> accept_socket,
     const net::IPEndPoint& peer_address,
     const AcceptCompletionCallback& success_callback,
     const ErrorCompletionCallback& error_callback) {
-  DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner()->RunsTasksInCurrentSequence());
 
   const std::string peer_device_address =
       IPEndPointToBluetoothAddress(peer_address);
   const BluetoothDevice* peer_device = adapter_->GetDevice(peer_device_address);
   if (!peer_device) {
     LOG(WARNING) << "OnAccept failed with unknown device, addr="
                  << peer_device_address;
     error_callback.Run(kFailedToAccept);
     return;
   }
 
   scoped_refptr<BluetoothSocketWin> peer_socket =
       CreateBluetoothSocket(ui_task_runner(), socket_thread());
   peer_socket->SetTCPSocket(std::move(accept_socket));
   success_callback.Run(peer_device, peer_socket);
 }
 
 }  // namespace device