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

device/bluetooth/test/bluetooth_test_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/test/bluetooth_test_win.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 186 matching lines @@
 
   for (auto uuid : uuids) {
     fake_bt_le_wrapper_->SimulateGattService(
         simulated_device, nullptr, CanonicalStringToBTH_LE_UUID(uuid));
   }
 
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::SimulateGattServiceRemoved(
-    BluetoothGattService* service) {
+    BluetoothRemoteGattService* service) {
   std::string device_address = service->GetDevice()->GetAddress();
   win::BLEDevice* target_device =
       fake_bt_le_wrapper_->GetSimulatedBLEDevice(device_address);
   CHECK(target_device);
 
   BluetoothRemoteGattServiceWin* win_service =
       static_cast<BluetoothRemoteGattServiceWin*>(service);
   std::string service_att_handle =
       std::to_string(win_service->GetAttributeHandle());
   fake_bt_le_wrapper_->SimulateGattServiceRemoved(target_device, nullptr,
                                                   service_att_handle);
 
   ForceRefreshDevice();
 }
 
-void BluetoothTestWin::SimulateGattCharacteristic(BluetoothGattService* service,
-                                                  const std::string& uuid,
-                                                  int properties) {
+void BluetoothTestWin::SimulateGattCharacteristic(
+    BluetoothRemoteGattService* service,
+    const std::string& uuid,
+    int properties) {
   std::string device_address = service->GetDevice()->GetAddress();
   win::BLEDevice* target_device =
       fake_bt_le_wrapper_->GetSimulatedBLEDevice(device_address);
   CHECK(target_device);
   win::GattService* target_service =
       GetSimulatedService(target_device, service);
   CHECK(target_service);
 
   BTH_LE_GATT_CHARACTERISTIC win_characteristic_info;
   win_characteristic_info.CharacteristicUuid =
       CanonicalStringToBTH_LE_UUID(uuid);
   win_characteristic_info.IsBroadcastable = FALSE;
   win_characteristic_info.IsReadable = FALSE;
   win_characteristic_info.IsWritableWithoutResponse = FALSE;
   win_characteristic_info.IsWritable = FALSE;
   win_characteristic_info.IsNotifiable = FALSE;
   win_characteristic_info.IsIndicatable = FALSE;
   win_characteristic_info.IsSignedWritable = FALSE;
   win_characteristic_info.HasExtendedProperties = FALSE;
-  if (properties & BluetoothGattCharacteristic::PROPERTY_BROADCAST)
+  if (properties & BluetoothRemoteGattCharacteristic::PROPERTY_BROADCAST)
     win_characteristic_info.IsBroadcastable = TRUE;
-  if (properties & BluetoothGattCharacteristic::PROPERTY_READ)
+  if (properties & BluetoothRemoteGattCharacteristic::PROPERTY_READ)
     win_characteristic_info.IsReadable = TRUE;
-  if (properties & BluetoothGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE)
+  if (properties &
+      BluetoothRemoteGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE)
     win_characteristic_info.IsWritableWithoutResponse = TRUE;
-  if (properties & BluetoothGattCharacteristic::PROPERTY_WRITE)
+  if (properties & BluetoothRemoteGattCharacteristic::PROPERTY_WRITE)
     win_characteristic_info.IsWritable = TRUE;
-  if (properties & BluetoothGattCharacteristic::PROPERTY_NOTIFY)
+  if (properties & BluetoothRemoteGattCharacteristic::PROPERTY_NOTIFY)
     win_characteristic_info.IsNotifiable = TRUE;
-  if (properties & BluetoothGattCharacteristic::PROPERTY_INDICATE)
+  if (properties & BluetoothRemoteGattCharacteristic::PROPERTY_INDICATE)
     win_characteristic_info.IsIndicatable = TRUE;
   if (properties &
-      BluetoothGattCharacteristic::PROPERTY_AUTHENTICATED_SIGNED_WRITES) {
+      BluetoothRemoteGattCharacteristic::PROPERTY_AUTHENTICATED_SIGNED_WRITES) {
     win_characteristic_info.IsSignedWritable = TRUE;
   }
-  if (properties & BluetoothGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES)
+  if (properties &
+      BluetoothRemoteGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES)
     win_characteristic_info.HasExtendedProperties = TRUE;
 
   fake_bt_le_wrapper_->SimulateGattCharacterisc(device_address, target_service,
                                                 win_characteristic_info);
 
   ForceRefreshDevice();
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicRemoved(
-    BluetoothGattService* service,
-    BluetoothGattCharacteristic* characteristic) {
+    BluetoothRemoteGattService* service,
+    BluetoothRemoteGattCharacteristic* characteristic) {
   CHECK(service);
   CHECK(characteristic);
 
   std::string device_address = service->GetDevice()->GetAddress();
   win::GattService* target_service = GetSimulatedService(
       fake_bt_le_wrapper_->GetSimulatedBLEDevice(device_address), service);
   CHECK(target_service);
 
   std::string characteristic_att_handle = std::to_string(
       static_cast<BluetoothRemoteGattCharacteristicWin*>(characteristic)
           ->GetAttributeHandle());
   fake_bt_le_wrapper_->SimulateGattCharacteriscRemove(
       target_service, characteristic_att_handle);
 
   ForceRefreshDevice();
 }
 
 void BluetoothTestWin::RememberCharacteristicForSubsequentAction(
-    BluetoothGattCharacteristic* characteristic) {
+    BluetoothRemoteGattCharacteristic* characteristic) {
   CHECK(characteristic);
   BluetoothRemoteGattCharacteristicWin* win_characteristic =
       static_cast<BluetoothRemoteGattCharacteristicWin*>(characteristic);
 
   std::string device_address =
       win_characteristic->GetService()->GetDevice()->GetAddress();
   win::BLEDevice* target_device =
       fake_bt_le_wrapper_->GetSimulatedBLEDevice(device_address);
   CHECK(target_device);
   win::GattService* target_service =
       GetSimulatedService(target_device, win_characteristic->GetService());
   CHECK(target_service);
   fake_bt_le_wrapper_->RememberCharacteristicForSubsequentAction(
       target_service, std::to_string(win_characteristic->GetAttributeHandle()));
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicRead(
-    BluetoothGattCharacteristic* characteristic,
+    BluetoothRemoteGattCharacteristic* characteristic,
     const std::vector<uint8_t>& value) {
   win::GattCharacteristic* target_simulated_characteristic = nullptr;
   if (characteristic) {
     target_simulated_characteristic =
         GetSimulatedCharacteristic(characteristic);
   }
 
   fake_bt_le_wrapper_->SimulateGattCharacteristicValue(
       target_simulated_characteristic, value);
 
   RunPendingTasksUntilCallback();
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicReadError(
-    BluetoothGattCharacteristic* characteristic,
-    BluetoothGattService::GattErrorCode error_code) {
+    BluetoothRemoteGattCharacteristic* characteristic,
+    BluetoothRemoteGattService::GattErrorCode error_code) {
   win::GattCharacteristic* target_characteristic =
       GetSimulatedCharacteristic(characteristic);
   CHECK(target_characteristic);
   HRESULT hr = HRESULT_FROM_WIN32(ERROR_SEM_TIMEOUT);
-  if (error_code == BluetoothGattService::GATT_ERROR_INVALID_LENGTH)
+  if (error_code == BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH)
     hr = E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH;
   fake_bt_le_wrapper_->SimulateGattCharacteristicReadError(
       target_characteristic, hr);
 
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicWrite(
-    BluetoothGattCharacteristic* characteristic) {
+    BluetoothRemoteGattCharacteristic* characteristic) {
   RunPendingTasksUntilCallback();
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicWriteError(
-    BluetoothGattCharacteristic* characteristic,
-    BluetoothGattService::GattErrorCode error_code) {
+    BluetoothRemoteGattCharacteristic* characteristic,
+    BluetoothRemoteGattService::GattErrorCode error_code) {
   win::GattCharacteristic* target_characteristic =
       GetSimulatedCharacteristic(characteristic);
   CHECK(target_characteristic);
   HRESULT hr = HRESULT_FROM_WIN32(ERROR_SEM_TIMEOUT);
-  if (error_code == BluetoothGattService::GATT_ERROR_INVALID_LENGTH)
+  if (error_code == BluetoothRemoteGattService::GATT_ERROR_INVALID_LENGTH)
     hr = E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH;
   fake_bt_le_wrapper_->SimulateGattCharacteristicWriteError(
       target_characteristic, hr);
 
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::DeleteDevice(BluetoothDevice* device) {
   CHECK(device);
   fake_bt_le_wrapper_->RemoveSimulatedBLEDevice(device->GetAddress());
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::SimulateGattDescriptor(
-    BluetoothGattCharacteristic* characteristic,
+    BluetoothRemoteGattCharacteristic* characteristic,
     const std::string& uuid) {
   win::GattCharacteristic* target_characteristic =
       GetSimulatedCharacteristic(characteristic);
   CHECK(target_characteristic);
   fake_bt_le_wrapper_->SimulateGattDescriptor(
       characteristic->GetService()->GetDevice()->GetAddress(),
       target_characteristic, CanonicalStringToBTH_LE_UUID(uuid));
   ForceRefreshDevice();
 }
 
 void BluetoothTestWin::SimulateGattNotifySessionStarted(
-    BluetoothGattCharacteristic* characteristic) {
+    BluetoothRemoteGattCharacteristic* characteristic) {
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::SimulateGattCharacteristicChanged(
-    BluetoothGattCharacteristic* characteristic,
+    BluetoothRemoteGattCharacteristic* characteristic,
     const std::vector<uint8_t>& value) {
   win::GattCharacteristic* target_simulated_characteristic = nullptr;
   if (characteristic) {
     target_simulated_characteristic =
         GetSimulatedCharacteristic(characteristic);
   }
 
   fake_bt_le_wrapper_->SimulateGattCharacteristicValue(
       target_simulated_characteristic, value);
   fake_bt_le_wrapper_->SimulateCharacteristicValueChangeNotification(
@@ skipping 19 matching lines @@
 }
 
 void BluetoothTestWin::OnWriteGattDescriptorValue(
     const std::vector<uint8_t>& value) {
   gatt_write_descriptor_attempts_++;
   last_write_value_.assign(value.begin(), value.end());
 }
 
 win::GattService* BluetoothTestWin::GetSimulatedService(
     win::BLEDevice* device,
-    BluetoothGattService* service) {
+    BluetoothRemoteGattService* service) {
   CHECK(device);
   CHECK(service);
 
   std::vector<std::string> chain_of_att_handles;
   BluetoothRemoteGattServiceWin* win_service =
       static_cast<BluetoothRemoteGattServiceWin*>(service);
   chain_of_att_handles.insert(
       chain_of_att_handles.begin(),
       std::to_string(win_service->GetAttributeHandle()));
   win::GattService* simulated_service =
       fake_bt_le_wrapper_->GetSimulatedGattService(device,
                                                    chain_of_att_handles);
   CHECK(simulated_service);
   return simulated_service;
 }
 
 win::GattCharacteristic* BluetoothTestWin::GetSimulatedCharacteristic(
-    BluetoothGattCharacteristic* characteristic) {
+    BluetoothRemoteGattCharacteristic* characteristic) {
   CHECK(characteristic);
   BluetoothRemoteGattCharacteristicWin* win_characteristic =
       static_cast<BluetoothRemoteGattCharacteristicWin*>(characteristic);
 
   std::string device_address =
       win_characteristic->GetService()->GetDevice()->GetAddress();
   win::BLEDevice* target_device =
       fake_bt_le_wrapper_->GetSimulatedBLEDevice(device_address);
   if (target_device == nullptr)
     return nullptr;
@@ skipping 33 matching lines @@
 void BluetoothTestWin::ForceRefreshDevice() {
   adapter_win_->force_update_device_for_test_ = true;
   FinishPendingTasks();
 }
 
 void BluetoothTestWin::FinishPendingTasks() {
   bluetooth_task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 }
 }