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

components/proximity_auth/ble/bluetooth_low_energy_connection.h

 // 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.
 
 #ifndef COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_CONNECTION_H_
 #define COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_CONNECTION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.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/ble/remote_attribute.h"
 #include "components/proximity_auth/connection.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_notify_session.h"
+#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace base {
 class TaskRunner;
 }
 
 namespace proximity_auth {
 
 class BluetoothThrottler;
 
@@ skipping 82 matching lines @@
   // proximity_auth::Connection:
   void SendMessageImpl(scoped_ptr<WireMessage> message) override;
 
   // device::BluetoothAdapter::Observer:
   void DeviceChanged(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
   void DeviceRemoved(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
   void GattCharacteristicValueChanged(
       device::BluetoothAdapter* adapter,
-      device::BluetoothGattCharacteristic* characteristic,
+      device::BluetoothRemoteGattCharacteristic* characteristic,
       const std::vector<uint8_t>& value) override;
 
  private:
   // Represents a request to write |value| to a some characteristic.
   // |is_last_write_for_wire_messsage| indicates whether this request
   // corresponds to the last write request for some wire message.
   // A WireMessage corresponds to exactly two WriteRequest: the first containing
   // a kSendSignal + the size of the WireMessage, and the second containing a
   // SendStatusSignal + the serialized WireMessage.
   struct WriteRequest {
@@ skipping 60 matching lines @@
   // (OnRemoteCharacteristicWritten());
   // 4) |request| is not dequeued if it fails
   // (OnWriteRemoteCharacteristicError()), it remains on the queue and will be
   // retried. |request| will remain on the queue until it succeeds or it
   // triggers a Disconnect() call (after |max_number_of_tries_|).
   void WriteRemoteCharacteristic(WriteRequest request);
 
   // Processes the next request in |write_requests_queue_|.
   void ProcessNextWriteRequest();
 
-  // Called when the BluetoothGattCharacteristic::RemoteCharacteristicWrite() is
+  // Called when the
+  // BluetoothRemoteGattCharacteristic::RemoteCharacteristicWrite() is
   // successfully complete.
   void OnRemoteCharacteristicWritten(bool run_did_send_message_callback);
 
   // Called when there is an error writing to the remote characteristic
   // |to_peripheral_char_|.
   void OnWriteRemoteCharacteristicError(
       bool run_did_send_message_callback,
-      device::BluetoothGattService::GattErrorCode error);
+      device::BluetoothRemoteGattService::GattErrorCode error);
 
   // Builds the value to be written on |to_peripheral_char_|. The value
   // corresponds to |signal| concatenated with |payload|.
   WriteRequest BuildWriteRequest(const std::vector<uint8_t>& signal,
                                  const std::vector<uint8_t>& bytes,
                                  bool is_last_message_for_wire_message);
 
   // Prints the time elapsed since |Connect()| was called.
   void PrintTimeElapsed();
 
   // Returns the device corresponding to |remote_device_address_|.
   device::BluetoothDevice* GetRemoteDevice();
 
   // Returns the service corresponding to |remote_service_| in the current
   // device.
-  device::BluetoothGattService* GetRemoteService();
+  device::BluetoothRemoteGattService* GetRemoteService();
 
   // Returns the characteristic corresponding to |identifier| in the current
   // service.
-  device::BluetoothGattCharacteristic* GetGattCharacteristic(
+  device::BluetoothRemoteGattCharacteristic* GetGattCharacteristic(
       const std::string& identifier);
 
   // Convert the first 4 bytes from a byte vector to a uint32_t.
   uint32_t ToUint32(const std::vector<uint8_t>& bytes);
 
   // Convert an uint32_t to a byte vector.
   const std::vector<uint8_t> ToByteVector(uint32_t value);
 
   // The Bluetooth adapter over which the Bluetooth connection will be made.
   scoped_refptr<device::BluetoothAdapter> adapter_;
@@ skipping 28 matching lines @@
   // Indicates a receiving operation is in progress. This is set after a
   // ControlSignal::kSendSignal was received from the remote device.
   bool receiving_bytes_;
 
   // Total number of bytes expected for the current receive operation.
   std::size_t expected_number_of_incoming_bytes_;
 
   // Bytes already received for the current receive operation.
   std::string incoming_bytes_buffer_;
 
-  // Indicates there is a BluetoothGattCharacteristic::WriteRemoteCharacteristic
+  // Indicates there is a
+  // BluetoothRemoteGattCharacteristic::WriteRemoteCharacteristic
   // operation pending.
   bool write_remote_characteristic_pending_;
 
   std::queue<WriteRequest> write_requests_queue_;
 
   // Maximum number of tries to send any write request.
   int max_number_of_write_attempts_;
 
   // Maximum number of bytes that fit in a single chunk to be written in
   // |to_peripheral_char_|. Ideally, this should be the maximum value the
   // peripheral supports and it should be agreed when the GATT connection is
   // created. Currently, there is no API to find this value. The implementation
   // uses a hard-coded constant.
   int max_chunk_size_;
 
   // Stores when the instace was created.
   base::TimeTicks start_time_;
 
   base::WeakPtrFactory<BluetoothLowEnergyConnection> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothLowEnergyConnection);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_CONNECTION_H_