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

device/bluetooth/bluetooth_adapter.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_ADAPTER_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 11 matching lines @@
 #include "device/bluetooth/bluetooth_advertisement.h"
 #include "device/bluetooth/bluetooth_audio_sink.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_export.h"
 
 namespace device {
 
 class BluetoothAdvertisement;
 class BluetoothDiscoveryFilter;
 class BluetoothDiscoverySession;
-class BluetoothGattCharacteristic;
-class BluetoothGattDescriptor;
-class BluetoothGattService;
+class BluetoothRemoteGattCharacteristic;
+class BluetoothRemoteGattDescriptor;
+class BluetoothRemoteGattService;
 class BluetoothSocket;
 class BluetoothUUID;
 struct BluetoothAdapterDeleter;
 enum class UMABluetoothDiscoverySessionOutcome;
 
 // BluetoothAdapter represents a local Bluetooth adapter which may be used to
 // interact with remote Bluetooth devices. As well as providing support for
 // determining whether an adapter is present and whether the radio is powered,
 // this class also provides support for obtaining the list of remote devices
 // known to the adapter, discovering new devices, and providing notification of
@@ skipping 60 matching lines @@
 
     // Called when the device |device| is removed from the adapter |adapter|,
     // either as a result of a discovered device being lost between discovering
     // phases or pairing information deleted. |device| should not be
     // cached. Instead, copy its Bluetooth address.
     virtual void DeviceRemoved(BluetoothAdapter* adapter,
                                BluetoothDevice* device) {}
 
     // Called when a new GATT service |service| is added to the device |device|,
     // as the service is received from the device. Don't cache |service|. Store
-    // its identifier instead (i.e. BluetoothGattService::GetIdentifier).
+    // its identifier instead (i.e. BluetoothRemoteGattService::GetIdentifier).
     virtual void GattServiceAdded(BluetoothAdapter* adapter,
                                   BluetoothDevice* device,
-                                  BluetoothGattService* service) {}
+                                  BluetoothRemoteGattService* service) {}
 
     // Called when the GATT service |service| is removed from the device
     // |device|. This can happen if the attribute database of the remote device
     // changes or when |device| gets removed.
     virtual void GattServiceRemoved(BluetoothAdapter* adapter,
                                     BluetoothDevice* device,
-                                    BluetoothGattService* service) {}
+                                    BluetoothRemoteGattService* service) {}
 
     // Called when all the GATT Services in |device| have been discovered
     // and GattServiceAdded has been called for each service.
     virtual void GattServicesDiscovered(BluetoothAdapter* adapter,
                                         BluetoothDevice* device) {}
 
     // Called when all characteristic and descriptor discovery procedures are
     // known to be completed for the GATT service |service|. This method will be
     // called after the initial discovery of a GATT service and will usually be
     // preceded by calls to GattCharacteristicAdded and GattDescriptorAdded.
     virtual void GattDiscoveryCompleteForService(
         BluetoothAdapter* adapter,
-        BluetoothGattService* service) {}
+        BluetoothRemoteGattService* service) {}
 
     // Called when properties of the remote GATT service |service| have changed.
     // This will get called for properties such as UUID, as well as for changes
     // to the list of known characteristics and included services. Observers
     // should read all GATT characteristic and descriptors objects and do any
     // necessary set up required for a changed service.
     virtual void GattServiceChanged(BluetoothAdapter* adapter,
-                                    BluetoothGattService* service) {}
+                                    BluetoothRemoteGattService* service) {}
 
     // Called when the remote GATT characteristic |characteristic| has been
     // discovered. Use this to issue any initial read/write requests to the
     // characteristic but don't cache the pointer as it may become invalid.
     // Instead, use the specially assigned identifier to obtain a characteristic
     // and cache that identifier as necessary, as it can be used to retrieve the
     // characteristic from its GATT service. The number of characteristics with
     // the same UUID belonging to a service depends on the particular profile
     // the remote device implements, hence the client of a GATT based profile
     // will usually operate on the whole set of characteristics and not just
     // one.
     virtual void GattCharacteristicAdded(
         BluetoothAdapter* adapter,
-        BluetoothGattCharacteristic* characteristic) {}
+        BluetoothRemoteGattCharacteristic* characteristic) {}
 
     // Called when a GATT characteristic |characteristic| has been removed from
     // the system.
     virtual void GattCharacteristicRemoved(
         BluetoothAdapter* adapter,
-        BluetoothGattCharacteristic* characteristic) {}
+        BluetoothRemoteGattCharacteristic* characteristic) {}
 
     // Called when the remote GATT characteristic descriptor |descriptor| has
     // been discovered. Don't cache the arguments as the pointers may become
     // invalid. Instead, use the specially assigned identifier to obtain a
     // descriptor and cache that identifier as necessary.
-    virtual void GattDescriptorAdded(BluetoothAdapter* adapter,
-                                     BluetoothGattDescriptor* descriptor) {}
+    virtual void GattDescriptorAdded(
+        BluetoothAdapter* adapter,
+        BluetoothRemoteGattDescriptor* descriptor) {}
 
     // Called when a GATT characteristic descriptor |descriptor| has been
     // removed from the system.
-    virtual void GattDescriptorRemoved(BluetoothAdapter* adapter,
-                                       BluetoothGattDescriptor* descriptor) {}
+    virtual void GattDescriptorRemoved(
+        BluetoothAdapter* adapter,
+        BluetoothRemoteGattDescriptor* descriptor) {}
 
     // Called when the value of a characteristic has changed. This might be a
     // result of a read/write request to, or a notification/indication from, a
     // remote GATT characteristic.
     virtual void GattCharacteristicValueChanged(
         BluetoothAdapter* adapter,
-        BluetoothGattCharacteristic* characteristic,
+        BluetoothRemoteGattCharacteristic* characteristic,
         const std::vector<uint8_t>& value) {}
 
     // Called when the value of a characteristic descriptor has been updated.
-    virtual void GattDescriptorValueChanged(BluetoothAdapter* adapter,
-                                            BluetoothGattDescriptor* descriptor,
-                                            const std::vector<uint8_t>& value) {
-    }
+    virtual void GattDescriptorValueChanged(
+        BluetoothAdapter* adapter,
+        BluetoothRemoteGattDescriptor* descriptor,
+        const std::vector<uint8_t>& value) {}
   };
 
   // Used to configure a listening servie.
   struct DEVICE_BLUETOOTH_EXPORT ServiceOptions {
     ServiceOptions();
     ~ServiceOptions();
 
     std::unique_ptr<int> channel;
     std::unique_ptr<int> psm;
     std::unique_ptr<std::string> name;
@@ skipping 214 matching lines @@
       const CreateAdvertisementErrorCallback& error_callback) = 0;
 
   // The following methods are used to send various events to observers.
   void NotifyAdapterStateChanged(bool powered);
 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   // This function is implemented for ChromeOS only, and the support on
   // Android, MaxOS and Windows should be added on demand in the future.
   void NotifyDevicePairedChanged(BluetoothDevice* device,
                                  bool new_paired_status);
 #endif
-  void NotifyGattServiceAdded(BluetoothGattService* service);
-  void NotifyGattServiceRemoved(BluetoothGattService* service);
-  void NotifyGattServiceChanged(BluetoothGattService* service);
+  void NotifyGattServiceAdded(BluetoothRemoteGattService* service);
+  void NotifyGattServiceRemoved(BluetoothRemoteGattService* service);
+  void NotifyGattServiceChanged(BluetoothRemoteGattService* service);
   void NotifyGattServicesDiscovered(BluetoothDevice* device);
-  void NotifyGattDiscoveryComplete(BluetoothGattService* service);
+  void NotifyGattDiscoveryComplete(BluetoothRemoteGattService* service);
   void NotifyGattCharacteristicAdded(
-      BluetoothGattCharacteristic* characteristic);
+      BluetoothRemoteGattCharacteristic* characteristic);
   void NotifyGattCharacteristicRemoved(
-      BluetoothGattCharacteristic* characteristic);
-  void NotifyGattDescriptorAdded(BluetoothGattDescriptor* descriptor);
-  void NotifyGattDescriptorRemoved(BluetoothGattDescriptor* descriptor);
+      BluetoothRemoteGattCharacteristic* characteristic);
+  void NotifyGattDescriptorAdded(BluetoothRemoteGattDescriptor* descriptor);
+  void NotifyGattDescriptorRemoved(BluetoothRemoteGattDescriptor* descriptor);
   void NotifyGattCharacteristicValueChanged(
-      BluetoothGattCharacteristic* characteristic,
+      BluetoothRemoteGattCharacteristic* characteristic,
       const std::vector<uint8_t>& value);
-  void NotifyGattDescriptorValueChanged(BluetoothGattDescriptor* descriptor,
-                                        const std::vector<uint8_t>& value);
+  void NotifyGattDescriptorValueChanged(
+      BluetoothRemoteGattDescriptor* descriptor,
+      const std::vector<uint8_t>& value);
 
  protected:
   friend class base::RefCounted<BluetoothAdapter>;
   friend class BluetoothDiscoverySession;
   friend class BluetoothTestBase;
 
   typedef base::ScopedPtrHashMap<std::string, std::unique_ptr<BluetoothDevice>>
       DevicesMap;
   typedef std::pair<BluetoothDevice::PairingDelegate*, PairingDelegatePriority>
       PairingDelegatePair;
@@ skipping 119 matching lines @@
   std::set<BluetoothDiscoverySession*> discovery_sessions_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<BluetoothAdapter> weak_ptr_factory_;
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_H_