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

components/proximity_auth/ble/bluetooth_low_energy_connection.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_connection.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
 #include "components/proximity_auth/ble/fake_wire_message.h"
 #include "components/proximity_auth/bluetooth_throttler.h"
 #include "components/proximity_auth/connection_finder.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/wire_message.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
-#include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session.h"
+#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothGattConnection;
-using device::BluetoothGattService;
-using device::BluetoothGattCharacteristic;
+using device::BluetoothRemoteGattService;
+using device::BluetoothRemoteGattCharacteristic;
 using device::BluetoothGattNotifySession;
 using device::BluetoothUUID;
 
 namespace proximity_auth {
 namespace {
 
 // The UUID of the characteristic used to send data to the peripheral.
 const char kToPeripheralCharUUID[] = "977c6674-1239-4e72-993b-502369b8bb5a";
 
 // The UUID of the characteristic used to receive data from the peripheral.
@@ skipping 196 matching lines @@
   if (sub_status_ == SubStatus::DISCONNECTED ||
       device->GetAddress() != GetDeviceAddress())
     return;
 
   PA_LOG(INFO) << "Device removed " << GetDeviceAddress();
   Disconnect();
 }
 
 void BluetoothLowEnergyConnection::GattCharacteristicValueChanged(
     BluetoothAdapter* adapter,
-    BluetoothGattCharacteristic* characteristic,
+    BluetoothRemoteGattCharacteristic* characteristic,
     const std::vector<uint8_t>& value) {
   DCHECK_EQ(adapter, adapter_.get());
   if (sub_status() != SubStatus::WAITING_RESPONSE_SIGNAL &&
       sub_status() != SubStatus::CONNECTED)
     return;
 
   PA_LOG(INFO) << "Characteristic value changed: "
                << characteristic->GetUUID().canonical_value();
 
   if (characteristic->GetIdentifier() == from_peripheral_char_.id) {
@@ skipping 134 matching lines @@
                           : "")
                   << (from_peripheral_char.id.empty()
                           ? ", " + from_peripheral_char.uuid.canonical_value()
                           : "") << " not found.";
 
   Disconnect();
 }
 
 void BluetoothLowEnergyConnection::StartNotifySession() {
   if (sub_status() == SubStatus::CHARACTERISTICS_FOUND) {
-    BluetoothGattCharacteristic* characteristic =
+    BluetoothRemoteGattCharacteristic* characteristic =
         GetGattCharacteristic(from_peripheral_char_.id);
     DCHECK(characteristic);
 
     // This is a workaround for crbug.com/507325. If |characteristic| is already
     // notifying |characteristic->StartNotifySession()| will fail with
     // GATT_ERROR_FAILED.
     if (characteristic->IsNotifying()) {
       PA_LOG(INFO) << characteristic->GetUUID().canonical_value()
                    << " already notifying.";
       SetSubStatus(SubStatus::NOTIFY_SESSION_READY);
       SendInviteToConnectSignal();
       return;
     }
 
     SetSubStatus(SubStatus::WAITING_NOTIFY_SESSION);
     characteristic->StartNotifySession(
         base::Bind(&BluetoothLowEnergyConnection::OnNotifySessionStarted,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothLowEnergyConnection::OnNotifySessionError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void BluetoothLowEnergyConnection::OnNotifySessionError(
-    BluetoothGattService::GattErrorCode error) {
+    BluetoothRemoteGattService::GattErrorCode error) {
   DCHECK(sub_status() == SubStatus::WAITING_NOTIFY_SESSION);
   PA_LOG(WARNING) << "Error starting notification session: " << error;
   Disconnect();
 }
 
 void BluetoothLowEnergyConnection::OnNotifySessionStarted(
     scoped_ptr<BluetoothGattNotifySession> notify_session) {
   DCHECK(sub_status() == SubStatus::WAITING_NOTIFY_SESSION);
   PA_LOG(INFO) << "Notification session started "
                << notify_session->GetCharacteristicIdentifier();
@@ skipping 26 matching lines @@
   }
 }
 
 void BluetoothLowEnergyConnection::WriteRemoteCharacteristic(
     WriteRequest request) {
   write_requests_queue_.push(request);
   ProcessNextWriteRequest();
 }
 
 void BluetoothLowEnergyConnection::ProcessNextWriteRequest() {
-  BluetoothGattCharacteristic* characteristic =
+  BluetoothRemoteGattCharacteristic* characteristic =
       GetGattCharacteristic(to_peripheral_char_.id);
   if (!write_requests_queue_.empty() && !write_remote_characteristic_pending_ &&
       characteristic) {
     write_remote_characteristic_pending_ = true;
     WriteRequest next_request = write_requests_queue_.front();
     PA_LOG(INFO) << "Writing characteristic...";
     characteristic->WriteRemoteCharacteristic(
         next_request.value,
         base::Bind(&BluetoothLowEnergyConnection::OnRemoteCharacteristicWritten,
                    weak_ptr_factory_.GetWeakPtr(),
@@ skipping 14 matching lines @@
     OnDidSendMessage(WireMessage(std::string(), std::string()), true);
 
   // Removes the top of queue (already processed) and process the next request.
   DCHECK(!write_requests_queue_.empty());
   write_requests_queue_.pop();
   ProcessNextWriteRequest();
 }
 
 void BluetoothLowEnergyConnection::OnWriteRemoteCharacteristicError(
     bool run_did_send_message_callback,
-    BluetoothGattService::GattErrorCode error) {
+    BluetoothRemoteGattService::GattErrorCode error) {
   PA_LOG(WARNING) << "Error " << error << " writing characteristic: "
                   << to_peripheral_char_.uuid.canonical_value();
   write_remote_characteristic_pending_ = false;
   // TODO(sacomoto): Actually pass the current message to the observer.
   if (run_did_send_message_callback)
     OnDidSendMessage(WireMessage(std::string(), std::string()), false);
 
   // Increases the number of failed attempts and retry.
   DCHECK(!write_requests_queue_.empty());
   if (++write_requests_queue_.front().number_of_failed_attempts >=
@@ skipping 37 matching lines @@
   // crbug.com/497841).
   std::vector<BluetoothDevice*> devices = adapter_->GetDevices();
   for (const auto& device : devices) {
     if (device->GetAddress() == GetDeviceAddress())
       return device;
   }
 
   return nullptr;
 }
 
-BluetoothGattService* BluetoothLowEnergyConnection::GetRemoteService() {
+BluetoothRemoteGattService* BluetoothLowEnergyConnection::GetRemoteService() {
   BluetoothDevice* remote_device = GetRemoteDevice();
   if (!remote_device) {
     PA_LOG(WARNING) << "Remote device not found.";
     return NULL;
   }
   if (remote_service_.id.empty()) {
-    std::vector<BluetoothGattService*> services =
+    std::vector<BluetoothRemoteGattService*> services =
         remote_device->GetGattServices();
     for (const auto& service : services)
       if (service->GetUUID() == remote_service_.uuid) {
         remote_service_.id = service->GetIdentifier();
         break;
       }
   }
   return remote_device->GetGattService(remote_service_.id);
 }
 
-BluetoothGattCharacteristic*
+BluetoothRemoteGattCharacteristic*
 BluetoothLowEnergyConnection::GetGattCharacteristic(
     const std::string& gatt_characteristic) {
-  BluetoothGattService* remote_service = GetRemoteService();
+  BluetoothRemoteGattService* remote_service = GetRemoteService();
   if (!remote_service) {
     PA_LOG(WARNING) << "Remote service not found.";
     return NULL;
   }
   return remote_service->GetCharacteristic(gatt_characteristic);
 }
 
 // TODO(sacomoto): make this robust to byte ordering in both sides of the
 // SmartLock BLE socket.
 uint32_t BluetoothLowEnergyConnection::ToUint32(
     const std::vector<uint8_t>& bytes) {
   return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
 }
 
 // TODO(sacomoto): make this robust to byte ordering in both sides of the
 // SmartLock BLE socket.
 const std::vector<uint8_t> BluetoothLowEnergyConnection::ToByteVector(
     const uint32_t value) {
   std::vector<uint8_t> bytes(4, 0);
   bytes[0] = static_cast<uint8_t>(value);
   bytes[1] = static_cast<uint8_t>(value >> 8);
   bytes[2] = static_cast<uint8_t>(value >> 16);
   bytes[3] = static_cast<uint8_t>(value >> 24);
   return bytes;
 }
 
 }  // namespace proximity_auth