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

device/bluetooth/bluetooth_device.h

 // Copyright (c) 2012 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 DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 12 matching lines @@
 #include "net/log/net_log.h"
 
 namespace base {
 class BinaryValue;
 }
 
 namespace device {
 
 class BluetoothAdapter;
 class BluetoothGattConnection;
-class BluetoothGattService;
+class BluetoothRemoteGattService;
 class BluetoothSocket;
 class BluetoothUUID;
 
 // BluetoothDevice represents a remote Bluetooth device, both its properties and
 // capabilities as discovered by a local adapter and actions that may be
 // performed on the remove device such as pairing, connection and disconnection.
 //
 // The class is instantiated and managed by the BluetoothAdapter class
 // and pointers should only be obtained from that class and not cached,
 // instead use the GetAddress() method as a unique key for a device.
@@ skipping 399 matching lines @@
   virtual void CreateGattConnection(const GattConnectionCallback& callback,
                                     const ConnectErrorCallback& error_callback);
 
   // Set the gatt services discovery complete flag for this device.
   void SetGattServicesDiscoveryComplete(bool complete);
 
   // Indicates whether service discovery is complete for this device.
   bool IsGattServicesDiscoveryComplete() const;
 
   // Returns the list of discovered GATT services.
-  virtual std::vector<BluetoothGattService*> GetGattServices() const;
+  virtual std::vector<BluetoothRemoteGattService*> GetGattServices() const;
 
   // Returns the GATT service with device-specific identifier |identifier|.
   // Returns NULL, if no such service exists.
-  virtual BluetoothGattService* GetGattService(
+  virtual BluetoothRemoteGattService* GetGattService(
       const std::string& identifier) const;
 
   // Returns service data of a service given its UUID.
   virtual base::BinaryValue* GetServiceData(BluetoothUUID serviceUUID) const;
 
   // Returns the list UUIDs of services that have service data.
   virtual UUIDList GetServiceDataUUIDs() const;
 
   // Returns the |address| in the canonical format: XX:XX:XX:XX:XX:XX, where
   // each 'X' is a hex digit.  If the input |address| is invalid, returns an
@@ skipping 63 matching lines @@
   BluetoothAdapter* adapter_;
 
   // Callbacks for pending success and error result of CreateGattConnection.
   std::vector<GattConnectionCallback> create_gatt_connection_success_callbacks_;
   std::vector<ConnectErrorCallback> create_gatt_connection_error_callbacks_;
 
   // BluetoothGattConnection objects keeping the GATT connection alive.
   std::set<BluetoothGattConnection*> gatt_connections_;
 
   // Mapping from the platform-specific GATT service identifiers to
-  // BluetoothGattService objects.
+  // BluetoothRemoteGattService objects.
   typedef base::ScopedPtrHashMap<std::string,
-                                 std::unique_ptr<BluetoothGattService>>
+                                 std::unique_ptr<BluetoothRemoteGattService>>
       GattServiceMap;
   GattServiceMap gatt_services_;
   bool gatt_services_discovery_complete_;
 
   // Mapping from service UUID represented as a std::string of a bluetooth
   // service to
   // the specific data. The data is stored as BinaryValue.
   std::unique_ptr<base::DictionaryValue> services_data_;
 
  private:
   // Returns a localized string containing the device's bluetooth address and
   // a device type for display when |name_| is empty.
   base::string16 GetAddressWithLocalizedDeviceTypeName() const;
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_