Refactor device::BluetoothGattXXX classes to split into remote/local.

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 40 matching lines @@
 
   if (gatt_event_handle_ != nullptr) {
     task_manager_->PostUnregisterGattCharacteristicValueChangedEvent(
         gatt_event_handle_);
     gatt_event_handle_ = nullptr;
   }
   parent_service_->GetWinAdapter()->NotifyGattCharacteristicRemoved(this);
 
   // Clear pending StartNotifySession callbacks.
   for (const auto& callback : start_notify_session_callbacks_)
-    callback.second.Run(BluetoothGattService::GATT_ERROR_FAILED);
+    callback.second.Run(BluetoothRemoteGattService::GATT_ERROR_FAILED);
 }
 
 std::string BluetoothRemoteGattCharacteristicWin::GetIdentifier() const {
   return characteristic_identifier_;
 }
 
 BluetoothUUID BluetoothRemoteGattCharacteristicWin::GetUUID() const {
   return characteristic_uuid_;
 }
 
 bool BluetoothRemoteGattCharacteristicWin::IsLocal() const {
   return false;
 }
 
 std::vector<uint8_t>& BluetoothRemoteGattCharacteristicWin::GetValue() const {
   return const_cast<std::vector<uint8_t>&>(characteristic_value_);
 }
 
-BluetoothGattService* BluetoothRemoteGattCharacteristicWin::GetService() const {
+BluetoothRemoteGattService* BluetoothRemoteGattCharacteristicWin::GetService()
+    const {
   return parent_service_;
 }
 
-BluetoothGattCharacteristic::Properties
+BluetoothRemoteGattCharacteristic::Properties
 BluetoothRemoteGattCharacteristicWin::GetProperties() const {
-  BluetoothGattCharacteristic::Properties properties = PROPERTY_NONE;
+  BluetoothRemoteGattCharacteristic::Properties properties = PROPERTY_NONE;
 
   if (characteristic_info_->IsBroadcastable)
     properties = properties | PROPERTY_BROADCAST;
   if (characteristic_info_->IsReadable)
     properties = properties | PROPERTY_READ;
   if (characteristic_info_->IsWritableWithoutResponse)
     properties = properties | PROPERTY_WRITE_WITHOUT_RESPONSE;
   if (characteristic_info_->IsWritable)
     properties = properties | PROPERTY_WRITE;
   if (characteristic_info_->IsNotifiable)
     properties = properties | PROPERTY_NOTIFY;
   if (characteristic_info_->IsIndicatable)
     properties = properties | PROPERTY_INDICATE;
   if (characteristic_info_->IsSignedWritable)
     properties = properties | PROPERTY_AUTHENTICATED_SIGNED_WRITES;
   if (characteristic_info_->HasExtendedProperties)
     properties = properties | PROPERTY_EXTENDED_PROPERTIES;
 
   // TODO(crbug.com/589304): Information about PROPERTY_RELIABLE_WRITE and
   // PROPERTY_WRITABLE_AUXILIARIES is not available in characteristic_info_
   // (BTH_LE_GATT_CHARACTERISTIC).
 
   return properties;
 }
 
-BluetoothGattCharacteristic::Permissions
+BluetoothRemoteGattCharacteristic::Permissions
 BluetoothRemoteGattCharacteristicWin::GetPermissions() const {
-  BluetoothGattCharacteristic::Permissions permissions = PERMISSION_NONE;
+  BluetoothRemoteGattCharacteristic::Permissions permissions = PERMISSION_NONE;
 
   if (characteristic_info_->IsReadable)
     permissions = permissions | PERMISSION_READ;
   if (characteristic_info_->IsWritable)
     permissions = permissions | PERMISSION_WRITE;
 
   return permissions;
 }
 
 bool BluetoothRemoteGattCharacteristicWin::IsNotifying() const {
   return gatt_event_handle_ != nullptr;
 }
 
-std::vector<BluetoothGattDescriptor*>
+std::vector<BluetoothRemoteGattDescriptor*>
 BluetoothRemoteGattCharacteristicWin::GetDescriptors() const {
-  std::vector<BluetoothGattDescriptor*> descriptors;
+  std::vector<BluetoothRemoteGattDescriptor*> descriptors;
   for (const auto& descriptor : included_descriptors_)
     descriptors.push_back(descriptor.second.get());
   return descriptors;
 }
 
-BluetoothGattDescriptor* BluetoothRemoteGattCharacteristicWin::GetDescriptor(
+BluetoothRemoteGattDescriptor*
+BluetoothRemoteGattCharacteristicWin::GetDescriptor(
     const std::string& identifier) const {
   GattDescriptorMap::const_iterator it = included_descriptors_.find(identifier);
   if (it != included_descriptors_.end())
     return it->second.get();
   return nullptr;
 }
 
 bool BluetoothRemoteGattCharacteristicWin::AddDescriptor(
-    BluetoothGattDescriptor* descriptor) {
+    BluetoothRemoteGattDescriptor* descriptor) {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool BluetoothRemoteGattCharacteristicWin::UpdateValue(
     const std::vector<uint8_t>& value) {
   NOTIMPLEMENTED();
   return false;
 }
 
 void BluetoothRemoteGattCharacteristicWin::StartNotifySession(
     const NotifySessionCallback& callback,
     const ErrorCallback& error_callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   if (IsNotifying()) {
     std::unique_ptr<BluetoothGattNotifySessionWin> notify_session(
         new BluetoothGattNotifySessionWin(weak_ptr_factory_.GetWeakPtr()));
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, base::Passed(std::move(notify_session))));
     return;
   }
 
   if (!characteristic_info_->IsNotifiable &&
       !characteristic_info_->IsIndicatable) {
     ui_task_runner_->PostTask(
-        FROM_HERE, base::Bind(error_callback,
-                              BluetoothGattService::GATT_ERROR_NOT_SUPPORTED));
+        FROM_HERE,
+        base::Bind(error_callback,
+                   BluetoothRemoteGattService::GATT_ERROR_NOT_SUPPORTED));
     return;
   }
 
-  std::vector<BluetoothGattDescriptor*> ccc_descriptors = GetDescriptorsByUUID(
-      BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid());
+  std::vector<BluetoothRemoteGattDescriptor*> ccc_descriptors =
+      GetDescriptorsByUUID(BluetoothRemoteGattDescriptor::
+                               ClientCharacteristicConfigurationUuid());
   if (ccc_descriptors.size() < 1) {
     ui_task_runner_->PostTask(
-        FROM_HERE, base::Bind(error_callback,
-                              BluetoothGattService::GATT_ERROR_NOT_SUPPORTED));
+        FROM_HERE,
+        base::Bind(error_callback,
+                   BluetoothRemoteGattService::GATT_ERROR_NOT_SUPPORTED));
     return;
   }
   if (ccc_descriptors.size() > 1) {
     ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(error_callback, BluetoothGattService::GATT_ERROR_FAILED));
+        FROM_HERE, base::Bind(error_callback,
+                              BluetoothRemoteGattService::GATT_ERROR_FAILED));
     return;
   }
 
   start_notify_session_callbacks_.push_back(
       std::make_pair(callback, error_callback));
   if (gatt_event_registeration_in_progress_)
     return;
 
   task_manager_->PostRegisterGattCharacteristicValueChangedEvent(
       parent_service_->GetServicePath(), characteristic_info_.get(),
       static_cast<BluetoothRemoteGattDescriptorWin*>(ccc_descriptors[0])
           ->GetWinDescriptorInfo(),
       base::Bind(
           &BluetoothRemoteGattCharacteristicWin::GattEventRegistrationCallback,
           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnGattCharacteristicValueChanged,
                  weak_ptr_factory_.GetWeakPtr()));
   gatt_event_registeration_in_progress_ = true;
 }
 
 void BluetoothRemoteGattCharacteristicWin::ReadRemoteCharacteristic(
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   if (!characteristic_info_.get()->IsReadable) {
-    error_callback.Run(BluetoothGattService::GATT_ERROR_NOT_PERMITTED);
+    error_callback.Run(BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED);
     return;
   }
 
   if (characteristic_value_read_or_write_in_progress_) {
-    error_callback.Run(BluetoothGattService::GATT_ERROR_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>& new_value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   if (!characteristic_info_.get()->IsWritable) {
-    error_callback.Run(BluetoothGattService::GATT_ERROR_NOT_PERMITTED);
+    error_callback.Run(BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED);
     return;
   }
 
   if (characteristic_value_read_or_write_in_progress_) {
-    error_callback.Run(BluetoothGattService::GATT_ERROR_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(), new_value,
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnWriteRemoteCharacteristicValueCallback,
@@ skipping 122 matching lines @@
   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;
 }
 
-BluetoothGattService::GattErrorCode
+BluetoothRemoteGattService::GattErrorCode
 BluetoothRemoteGattCharacteristicWin::HRESULTToGattErrorCode(HRESULT hr) {
   if (HRESULT_FROM_WIN32(ERROR_INVALID_USER_BUFFER) == hr)
-    return BluetoothGattService::GATT_ERROR_INVALID_LENGTH;
+    return BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH;
 
   switch (hr) {
     case E_BLUETOOTH_ATT_READ_NOT_PERMITTED:
     case E_BLUETOOTH_ATT_WRITE_NOT_PERMITTED:
-      return BluetoothGattService::GATT_ERROR_NOT_PERMITTED;
+      return BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED;
     case E_BLUETOOTH_ATT_UNKNOWN_ERROR:
-      return BluetoothGattService::GATT_ERROR_UNKNOWN;
+      return BluetoothRemoteGattService::GATT_ERROR_UNKNOWN;
     case E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH:
-      return BluetoothGattService::GATT_ERROR_INVALID_LENGTH;
+      return BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH;
     case E_BLUETOOTH_ATT_REQUEST_NOT_SUPPORTED:
-      return BluetoothGattService::GATT_ERROR_NOT_SUPPORTED;
+      return BluetoothRemoteGattService::GATT_ERROR_NOT_SUPPORTED;
     default:
-      return BluetoothGattService::GATT_ERROR_FAILED;
+      return BluetoothRemoteGattService::GATT_ERROR_FAILED;
   }
 }
 
 void BluetoothRemoteGattCharacteristicWin::OnGattCharacteristicValueChanged(
     std::unique_ptr<std::vector<uint8_t>> new_value) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   characteristic_value_.assign(new_value->begin(), new_value->end());
   parent_service_->GetWinAdapter()->NotifyGattCharacteristicValueChanged(
       this, characteristic_value_);
@@ skipping 21 matching lines @@
 
 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.