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

device/bluetooth/bluetooth_task_manager_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_task_manager_win.h"
 
 #include <stddef.h>
 #include <winsock2.h>
 
 #include <memory>
@@ skipping 225 matching lines @@
         bth_le_uuid.Value.LongUuid.Data4[3],
         bth_le_uuid.Value.LongUuid.Data4[4],
         bth_le_uuid.Value.LongUuid.Data4[5],
         bth_le_uuid.Value.LongUuid.Data4[6],
         bth_le_uuid.Value.LongUuid.Data4[7]));
   }
 }
 
 void BluetoothTaskManagerWin::AddObserver(Observer* observer) {
   DCHECK(observer);
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   observers_.AddObserver(observer);
 }
 
 void BluetoothTaskManagerWin::RemoveObserver(Observer* observer) {
   DCHECK(observer);
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   observers_.RemoveObserver(observer);
 }
 
 void BluetoothTaskManagerWin::Initialize() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   InitializeWithBluetoothTaskRunner(base::CreateSequencedTaskRunnerWithTraits(
       {base::MayBlock(), base::TaskPriority::BACKGROUND,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN}));
 }
 
 void BluetoothTaskManagerWin::InitializeWithBluetoothTaskRunner(
     scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_ = bluetooth_task_runner;
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::StartPolling, this));
 }
 
 void BluetoothTaskManagerWin::StartPolling() {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
 
   if (device::bluetooth_init_win::HasBluetoothStack()) {
     PollAdapter();
   } else {
     // IF the bluetooth stack is not available, we still send an empty state
     // to BluetoothAdapter so that it is marked initialized, but the adapter
     // will not be present.
     AdapterState* state = new AdapterState();
     ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged,
                  this,
                  base::Owned(state)));
   }
 }
 
 void BluetoothTaskManagerWin::PostSetPoweredBluetoothTask(
     bool powered,
     const base::Closure& callback,
     const BluetoothAdapter::ErrorCallback& error_callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::SetPowered,
                  this,
                  powered,
                  callback,
                  error_callback));
 }
 
 void BluetoothTaskManagerWin::PostStartDiscoveryTask() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::StartDiscovery, this));
 }
 
 void BluetoothTaskManagerWin::PostStopDiscoveryTask() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::StopDiscovery, this));
 }
 
 void BluetoothTaskManagerWin::LogPollingError(const char* message,
                                               int win32_error) {
   const int kLogPeriodInMilliseconds = 60 * 1000;
   const int kMaxMessagesPerLogPeriod = 10;
 
@@ skipping 18 matching lines @@
 
   // Log the message
   if (win32_error == 0)
     LOG(WARNING) << message;
   else
     LOG(WARNING) << message << ": "
                  << logging::SystemErrorCodeToString(win32_error);
 }
 
 void BluetoothTaskManagerWin::OnAdapterStateChanged(const AdapterState* state) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   for (auto& observer : observers_)
     observer.AdapterStateChanged(*state);
 }
 
 void BluetoothTaskManagerWin::OnDiscoveryStarted(bool success) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   for (auto& observer : observers_)
     observer.DiscoveryStarted(success);
 }
 
 void BluetoothTaskManagerWin::OnDiscoveryStopped() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   for (auto& observer : observers_)
     observer.DiscoveryStopped();
 }
 
 void BluetoothTaskManagerWin::OnDevicesPolled(
     std::vector<std::unique_ptr<DeviceState>> devices) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   for (auto& observer : observers_)
     observer.DevicesPolled(devices);
 }
 
 void BluetoothTaskManagerWin::PollAdapter() {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
 
   // Skips updating the adapter info if the adapter is in discovery mode.
   if (!discovering_) {
     const BLUETOOTH_FIND_RADIO_PARAMS adapter_param =
         { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) };
     HANDLE temp_adapter_handle;
     HBLUETOOTH_RADIO_FIND handle =
         win::BluetoothClassicWrapper::GetInstance()->FindFirstRadio(
             &adapter_param, &temp_adapter_handle);
 
     if (handle) {
       adapter_handle_ = temp_adapter_handle;
       GetKnownDevices();
       win::BluetoothClassicWrapper::GetInstance()->FindRadioClose(handle);
     }
 
     PostAdapterStateToUi();
   }
 
   // Re-poll.
   bluetooth_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::PollAdapter,
                  this),
       base::TimeDelta::FromMilliseconds(kPollIntervalMs));
 }
 
 void BluetoothTaskManagerWin::PostAdapterStateToUi() {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
   AdapterState* state = new AdapterState();
   GetAdapterState(adapter_handle_, state);
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged,
                  this,
                  base::Owned(state)));
 }
 
 void BluetoothTaskManagerWin::SetPowered(
     bool powered,
     const base::Closure& callback,
     const BluetoothAdapter::ErrorCallback& error_callback) {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
   bool success = false;
   if (adapter_handle_) {
     if (!powered) {
       win::BluetoothClassicWrapper::GetInstance()->EnableDiscovery(
           adapter_handle_, false);
     }
     success = !!win::BluetoothClassicWrapper::GetInstance()
                     ->EnableIncomingConnections(adapter_handle_, powered);
   }
 
   if (success) {
     PostAdapterStateToUi();
     ui_task_runner_->PostTask(FROM_HERE, callback);
   } else {
     ui_task_runner_->PostTask(FROM_HERE, error_callback);
   }
 }
 
 void BluetoothTaskManagerWin::StartDiscovery() {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
   ui_task_runner_->PostTask(
       FROM_HERE, base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStarted, this,
                             !!adapter_handle_));
   if (!adapter_handle_)
     return;
   discovering_ = true;
 
   DiscoverDevices(1);
 }
 
 void BluetoothTaskManagerWin::StopDiscovery() {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
   discovering_ = false;
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
 }
 
 void BluetoothTaskManagerWin::DiscoverDevices(int timeout_multiplier) {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
   if (!discovering_ || !adapter_handle_) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
     return;
   }
 
   std::vector<std::unique_ptr<DeviceState>> device_list;
   if (SearchDevices(timeout_multiplier, false, &device_list)) {
     ui_task_runner_->PostTask(
@@ skipping 113 matching lines @@
     device_state->connected = device_info->connected;
     device_state->path = device_info->path;
     device_list->push_back(std::move(device_state));
   }
   return true;
 }
 
 bool BluetoothTaskManagerWin::DiscoverServices(
     std::vector<std::unique_ptr<DeviceState>>* device_list,
     bool search_cached_services_only) {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
   net::EnsureWinsockInit();
   for (const auto& device : *device_list) {
     std::vector<std::unique_ptr<ServiceRecordState>>* service_record_states =
         &device->service_record_states;
 
     if (device->is_bluetooth_classic()) {
       if (!DiscoverClassicDeviceServices(device->address,
                                          L2CAP_PROTOCOL_UUID,
                                          search_cached_services_only,
                                          service_record_states)) {
@@ skipping 273 matching lines @@
 
   ui_task_runner_->PostTask(FROM_HERE, base::Bind(callback, hr));
 }
 
 void BluetoothTaskManagerWin::RegisterGattCharacteristicValueChangedEvent(
     base::FilePath service_path,
     BTH_LE_GATT_CHARACTERISTIC characteristic,
     BTH_LE_GATT_DESCRIPTOR ccc_descriptor,
     const GattEventRegistrationCallback& callback,
     const GattCharacteristicValueChangedCallback& registered_callback) {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
   BLUETOOTH_GATT_EVENT_HANDLE win_event_handle = NULL;
 
   BLUETOOTH_GATT_VALUE_CHANGED_EVENT_REGISTRATION win_event_parameter;
   memcpy(&(win_event_parameter.Characteristics[0]), &characteristic,
          sizeof(BTH_LE_GATT_CHARACTERISTIC));
   win_event_parameter.NumCharacteristics = 1;
   PVOID user_event_handle = (PVOID)&registered_callback;
   HRESULT hr =
       win::BluetoothLowEnergyWrapper::GetInstance()->RegisterGattEvents(
           service_path, CharacteristicValueChangedEvent, &win_event_parameter,
@@ skipping 27 matching lines @@
     g_characteristic_value_changed_registrations[user_event_handle] =
         std::move(registration);
   }
 
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(callback, user_event_handle, hr));
 }
 
 void BluetoothTaskManagerWin::UnregisterGattCharacteristicValueChangedEvent(
     PVOID event_handle) {
-  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(bluetooth_task_runner_->RunsTasksInCurrentSequence());
 
   base::AutoLock auto_lock(g_characteristic_value_changed_registrations_lock);
   CharacteristicValueChangedRegistrationMap::const_iterator it =
       g_characteristic_value_changed_registrations.find(event_handle);
   if (it != g_characteristic_value_changed_registrations.end()) {
     win::BluetoothLowEnergyWrapper::GetInstance()->UnregisterGattEvent(
         it->second->win_event_handle);
     g_characteristic_value_changed_registrations.erase(event_handle);
   }
 }
 
 void BluetoothTaskManagerWin::PostGetGattIncludedCharacteristics(
     const base::FilePath& service_path,
     const BluetoothUUID& uuid,
     uint16_t attribute_handle,
     const GetGattIncludedCharacteristicsCallback& callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::GetGattIncludedCharacteristics, this,
                  service_path, uuid, attribute_handle, callback));
 }
 
 void BluetoothTaskManagerWin::PostGetGattIncludedDescriptors(
     const base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
     const GetGattIncludedDescriptorsCallback& callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::GetGattIncludedDescriptors, this,
                  service_path, *characteristic, callback));
 }
 
 void BluetoothTaskManagerWin::PostReadGattCharacteristicValue(
     const base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
     const ReadGattCharacteristicValueCallback& callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::ReadGattCharacteristicValue, this,
                  service_path, *characteristic, callback));
 }
 
 void BluetoothTaskManagerWin::PostWriteGattCharacteristicValue(
     const base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
     const std::vector<uint8_t>& new_value,
     const HResultCallback& callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::WriteGattCharacteristicValue, this,
                  service_path, *characteristic, new_value, callback));
 }
 
 void BluetoothTaskManagerWin::PostRegisterGattCharacteristicValueChangedEvent(
     const base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic,
     const PBTH_LE_GATT_DESCRIPTOR ccc_descriptor,
     const GattEventRegistrationCallback& callback,
     const GattCharacteristicValueChangedCallback& registered_callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &BluetoothTaskManagerWin::RegisterGattCharacteristicValueChangedEvent,
           this, service_path, *characteristic, *ccc_descriptor, callback,
           registered_callback));
 }
 
 void BluetoothTaskManagerWin::PostUnregisterGattCharacteristicValueChangedEvent(
     PVOID event_handle) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   bluetooth_task_runner_->PostTask(
       FROM_HERE, base::Bind(&BluetoothTaskManagerWin::
                                 UnregisterGattCharacteristicValueChangedEvent,
                             this, event_handle));
 }
 
 }  // namespace device