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

device/bluetooth/bluetooth_remote_gatt_characteristic_win.cc

 // Copyright 2016 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_remote_gatt_characteristic_win.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 10 matching lines @@
     BTH_LE_GATT_CHARACTERISTIC* characteristic_info,
     scoped_refptr<base::SequencedTaskRunner>& ui_task_runner)
     : parent_service_(parent_service),
       characteristic_info_(characteristic_info),
       ui_task_runner_(ui_task_runner),
       characteristic_added_notified_(false),
       characteristic_value_read_or_write_in_progress_(false),
       gatt_event_registeration_in_progress_(false),
       gatt_event_handle_(nullptr),
       weak_ptr_factory_(this) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(parent_service_);
   DCHECK(characteristic_info_);
 
   task_manager_ =
       parent_service_->GetWinAdapter()->GetWinBluetoothTaskManager();
   DCHECK(task_manager_);
   characteristic_uuid_ =
       BluetoothTaskManagerWin::BluetoothLowEnergyUuidToBluetoothUuid(
           characteristic_info_->CharacteristicUuid);
   characteristic_identifier_ =
       parent_service_->GetIdentifier() + "_" +
       std::to_string(characteristic_info_->AttributeHandle);
   Update();
 }
 
 BluetoothRemoteGattCharacteristicWin::~BluetoothRemoteGattCharacteristicWin() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   ClearIncludedDescriptors();
 
   if (gatt_event_handle_ != nullptr) {
     task_manager_->PostUnregisterGattCharacteristicValueChangedEvent(
         gatt_event_handle_);
     gatt_event_handle_ = nullptr;
   }
   parent_service_->GetWinAdapter()->NotifyGattCharacteristicRemoved(this);
 
@@ skipping 88 matching lines @@
     const std::string& identifier) const {
   GattDescriptorMap::const_iterator it = included_descriptors_.find(identifier);
   if (it != included_descriptors_.end())
     return it->second.get();
   return nullptr;
 }
 
 void BluetoothRemoteGattCharacteristicWin::StartNotifySession(
     const NotifySessionCallback& callback,
     const ErrorCallback& error_callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   if (IsNotifying()) {
     std::unique_ptr<BluetoothGattNotifySession> notify_session(
         new BluetoothGattNotifySession(weak_ptr_factory_.GetWeakPtr()));
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, base::Passed(std::move(notify_session))));
     return;
   }
 
@@ skipping 47 matching lines @@
   // TODO(http://crbug.com/636270): Remove this method and use the base version.
   //   Instead, we should implement SubscribeToNotifications and
   //   UnsubscribeFromNotifications.
 
   ui_task_runner_->PostTask(FROM_HERE, callback);
 }
 
 void BluetoothRemoteGattCharacteristicWin::ReadRemoteCharacteristic(
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   if (!characteristic_info_.get()->IsReadable) {
     error_callback.Run(BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED);
     return;
   }
 
   if (characteristic_value_read_or_write_in_progress_) {
     error_callback.Run(BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS);
     return;
   }
 
   characteristic_value_read_or_write_in_progress_ = true;
   read_characteristic_value_callbacks_ =
       std::make_pair(callback, error_callback);
   task_manager_->PostReadGattCharacteristicValue(
       parent_service_->GetServicePath(), characteristic_info_.get(),
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnReadRemoteCharacteristicValueCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothRemoteGattCharacteristicWin::WriteRemoteCharacteristic(
     const std::vector<uint8_t>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   if (!characteristic_info_.get()->IsWritable) {
     error_callback.Run(BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED);
     return;
   }
 
   if (characteristic_value_read_or_write_in_progress_) {
     error_callback.Run(BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS);
     return;
   }
 
   characteristic_value_read_or_write_in_progress_ = true;
   write_characteristic_value_callbacks_ =
       std::make_pair(callback, error_callback);
   task_manager_->PostWriteGattCharacteristicValue(
       parent_service_->GetServicePath(), characteristic_info_.get(), value,
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnWriteRemoteCharacteristicValueCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothRemoteGattCharacteristicWin::Update() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   task_manager_->PostGetGattIncludedDescriptors(
       parent_service_->GetServicePath(), characteristic_info_.get(),
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnGetIncludedDescriptorsCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 uint16_t BluetoothRemoteGattCharacteristicWin::GetAttributeHandle() const {
   return characteristic_info_->AttributeHandle;
@@ skipping 12 matching lines @@
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   // TODO(http://crbug.com/636270): Implement this method
   NOTIMPLEMENTED();
 }
 
 void BluetoothRemoteGattCharacteristicWin::OnGetIncludedDescriptorsCallback(
     std::unique_ptr<BTH_LE_GATT_DESCRIPTOR> descriptors,
     uint16_t num,
     HRESULT hr) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   UpdateIncludedDescriptors(descriptors.get(), num);
   if (!characteristic_added_notified_) {
     characteristic_added_notified_ = true;
     parent_service_->GetWinAdapter()->NotifyGattCharacteristicAdded(this);
   }
 }
 
 void BluetoothRemoteGattCharacteristicWin::UpdateIncludedDescriptors(
     PBTH_LE_GATT_DESCRIPTOR descriptors,
@@ skipping 61 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 void BluetoothRemoteGattCharacteristicWin::
     OnReadRemoteCharacteristicValueCallback(
         std::unique_ptr<BTH_LE_GATT_CHARACTERISTIC_VALUE> value,
         HRESULT hr) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   std::pair<ValueCallback, ErrorCallback> callbacks;
   callbacks.swap(read_characteristic_value_callbacks_);
   if (FAILED(hr)) {
     callbacks.second.Run(HRESULTToGattErrorCode(hr));
   } else {
     characteristic_value_.clear();
     for (ULONG i = 0; i < value->DataSize; i++)
       characteristic_value_.push_back(value->Data[i]);
 
     callbacks.first.Run(characteristic_value_);
   }
   characteristic_value_read_or_write_in_progress_ = false;
 }
 
 void BluetoothRemoteGattCharacteristicWin::
     OnWriteRemoteCharacteristicValueCallback(HRESULT hr) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   std::pair<base::Closure, ErrorCallback> callbacks;
   callbacks.swap(write_characteristic_value_callbacks_);
   if (FAILED(hr)) {
     callbacks.second.Run(HRESULTToGattErrorCode(hr));
   } else {
     callbacks.first.Run();
   }
   characteristic_value_read_or_write_in_progress_ = false;
 }
@@ skipping 13 matching lines @@
       return BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH;
     case E_BLUETOOTH_ATT_REQUEST_NOT_SUPPORTED:
       return BluetoothRemoteGattService::GATT_ERROR_NOT_SUPPORTED;
     default:
       return BluetoothRemoteGattService::GATT_ERROR_FAILED;
   }
 }
 
 void BluetoothRemoteGattCharacteristicWin::OnGattCharacteristicValueChanged(
     std::unique_ptr<std::vector<uint8_t>> new_value) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   characteristic_value_.assign(new_value->begin(), new_value->end());
   parent_service_->GetWinAdapter()->NotifyGattCharacteristicValueChanged(
       this, characteristic_value_);
 }
 
 void BluetoothRemoteGattCharacteristicWin::GattEventRegistrationCallback(
     BLUETOOTH_GATT_EVENT_HANDLE event_handle,
     HRESULT hr) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   gatt_event_registeration_in_progress_ = false;
   std::vector<std::pair<NotifySessionCallback, ErrorCallback>> callbacks;
   callbacks.swap(start_notify_session_callbacks_);
   if (SUCCEEDED(hr)) {
     gatt_event_handle_ = event_handle;
     for (const auto& callback : callbacks) {
       callback.first.Run(base::MakeUnique<BluetoothGattNotifySession>(
           weak_ptr_factory_.GetWeakPtr()));
     }
   } else {
     for (const auto& callback : callbacks)
       callback.second.Run(HRESULTToGattErrorCode(hr));
   }
 }
 
 void BluetoothRemoteGattCharacteristicWin::ClearIncludedDescriptors() {
   // Explicitly reset to null to ensure that calling GetDescriptor() on the
   // removed descriptor in GattDescriptorRemoved() returns null.
   for (auto& entry : included_descriptors_)
     entry.second.reset();
   included_descriptors_.clear();
 }
 
 }  // namespace device.