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

components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.cc

 // Copyright 2015 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 "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
 
 #include "components/proximity_auth/logging/logging.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
-#include "device/bluetooth/bluetooth_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
-using device::BluetoothGattCharacteristic;
-using device::BluetoothGattService;
+using device::BluetoothRemoteGattCharacteristic;
+using device::BluetoothRemoteGattService;
 using device::BluetoothUUID;
 
 namespace proximity_auth {
 
 BluetoothLowEnergyCharacteristicsFinder::
     BluetoothLowEnergyCharacteristicsFinder(
         scoped_refptr<BluetoothAdapter> adapter,
         BluetoothDevice* device,
         const RemoteAttribute& remote_service,
         const RemoteAttribute& to_peripheral_char,
@@ skipping 26 matching lines @@
     ~BluetoothLowEnergyCharacteristicsFinder() {
   ResetCallbacks();
   if (adapter_) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
 }
 
 void BluetoothLowEnergyCharacteristicsFinder::GattCharacteristicAdded(
     BluetoothAdapter* adapter,
-    BluetoothGattCharacteristic* characteristic) {
+    BluetoothRemoteGattCharacteristic* characteristic) {
   PA_LOG(INFO) << "New char found: "
                << characteristic->GetUUID().canonical_value();
   HandleCharacteristicUpdate(characteristic);
 }
 
 void BluetoothLowEnergyCharacteristicsFinder::GattDiscoveryCompleteForService(
     BluetoothAdapter* adapter,
-    BluetoothGattService* service) {
+    BluetoothRemoteGattService* service) {
   if (service && service->GetUUID() == remote_service_.uuid) {
     PA_LOG(INFO) << "All characteristics discovered for "
                  << remote_service_.uuid.canonical_value();
 
     if (to_peripheral_char_.id.empty() || from_peripheral_char_.id.empty()) {
       if (!error_callback_.is_null()) {
         error_callback_.Run(to_peripheral_char_, from_peripheral_char_);
         ResetCallbacks();
       }
     }
   }
 }
 
 void BluetoothLowEnergyCharacteristicsFinder::ScanRemoteCharacteristics(
     BluetoothDevice* device,
     const BluetoothUUID& service_uuid) {
   PA_LOG(INFO) << "Scanning remote characteristics.";
   if (device) {
-    std::vector<BluetoothGattService*> services = device->GetGattServices();
+    std::vector<BluetoothRemoteGattService*> services =
+        device->GetGattServices();
     PA_LOG(INFO) << device->GetAddress() << " has " << services.size()
                  << " services.";
     for (const auto& service : services) {
       if (service->GetUUID() == service_uuid) {
         // Right service found, now scaning its characteristics.
-        std::vector<device::BluetoothGattCharacteristic*> characteristics =
-            service->GetCharacteristics();
+        std::vector<device::BluetoothRemoteGattCharacteristic*>
+            characteristics = service->GetCharacteristics();
         PA_LOG(INFO) << "Service " << service_uuid.canonical_value() << " has "
                      << characteristics.size() << " characteristics.";
         for (const auto& characteristic : characteristics) {
           HandleCharacteristicUpdate(characteristic);
         }
         break;
       }
     }
   }
 }
 
 void BluetoothLowEnergyCharacteristicsFinder::HandleCharacteristicUpdate(
-    BluetoothGattCharacteristic* characteristic) {
+    BluetoothRemoteGattCharacteristic* characteristic) {
   UpdateCharacteristicsStatus(characteristic);
 
   if (!to_peripheral_char_.id.empty() && !from_peripheral_char_.id.empty() &&
       !success_callback_.is_null()) {
     PA_LOG(INFO) << "Found write and read characteristics on remote device.";
     success_callback_.Run(remote_service_, to_peripheral_char_,
                           from_peripheral_char_);
     ResetCallbacks();
   }
 }
 
 void BluetoothLowEnergyCharacteristicsFinder::UpdateCharacteristicsStatus(
-    BluetoothGattCharacteristic* characteristic) {
+    BluetoothRemoteGattCharacteristic* characteristic) {
   if (characteristic &&
       characteristic->GetService()->GetUUID() == remote_service_.uuid) {
     BluetoothUUID uuid = characteristic->GetUUID();
     if (to_peripheral_char_.uuid == uuid)
       to_peripheral_char_.id = characteristic->GetIdentifier();
     if (from_peripheral_char_.uuid == uuid)
       from_peripheral_char_.id = characteristic->GetIdentifier();
 
-    BluetoothGattService* service = characteristic->GetService();
+    BluetoothRemoteGattService* service = characteristic->GetService();
     remote_service_.id = service->GetIdentifier();
   }
 }
 
 void BluetoothLowEnergyCharacteristicsFinder::ResetCallbacks() {
   success_callback_.Reset();
   error_callback_.Reset();
 }
 
 }  // namespace proximity_auth