chrome.bluetooth API improvements.

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 <list>
 #include <map>
 #include <set>
@@ skipping 17 matching lines @@
 // this class also provides support for obtaining the list of remote devices
 // known to the adapter, discovering new devices, and providing notification of
 // updates to device information.
 class BluetoothAdapter : public base::RefCounted<BluetoothAdapter> {
  public:
   // Interface for observing changes from bluetooth adapters.
   class Observer {
    public:
     virtual ~Observer() {}
 
-    // Called when the presence of the adapter |adapter| changes, when
-    // |present| is true the adapter is now present, false means the adapter
-    // has been removed from the system.
+    // Called when the presence of the adapter |adapter| changes, when |present|
+    // is true the adapter is now present, false means the adapter has been
+    // removed from the system.
     virtual void AdapterPresentChanged(BluetoothAdapter* adapter,
                                        bool present) {}
 
-    // Called when the radio power state of the adapter |adapter| changes,
-    // when |powered| is true the adapter radio is powered, false means the
-    // adapter radio is off.
+    // Called when the radio power state of the adapter |adapter| changes, when
+    // |powered| is true the adapter radio is powered, false means the adapter
+    // radio is off.
     virtual void AdapterPoweredChanged(BluetoothAdapter* adapter,
                                        bool powered) {}
 
     // Called when the discoverability state of the  adapter |adapter| changes,
     // when |discoverable| is true the adapter is discoverable by other devices,
     // false means the adapter is not discoverable.
     virtual void AdapterDiscoverableChanged(BluetoothAdapter* adapter,
                                            bool discoverable) {}
 
-    // Called when the discovering state of the adapter |adapter| changes,
-    // when |discovering| is true the adapter is seeking new devices, false
-    // means it is not.
+    // Called when the discovering state of the adapter |adapter| changes, when
+    // |discovering| is true the adapter is seeking new devices, false means it
+    // is not.
     virtual void AdapterDiscoveringChanged(BluetoothAdapter* adapter,
                                            bool discovering) {}
 
     // Called when a new device |device| is added to the adapter |adapter|,
     // either because it has been discovered or a connection made. |device|
     // should not be cached, instead copy its address.
     virtual void DeviceAdded(BluetoothAdapter* adapter,
                              BluetoothDevice* device) {}
 
     // Called when properties of the device |device| known to the adapter
     // |adapter| change. |device| should not be cached, instead copy its
     // address.
     virtual void DeviceChanged(BluetoothAdapter* adapter,
                                BluetoothDevice* device) {}
 
     // 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.
     virtual void DeviceRemoved(BluetoothAdapter* adapter,
                                BluetoothDevice* device) {}
   };
 
-  // The ErrorCallback is used for methods that can fail in which case it
-  // is called, in the success case the callback is simply not called.
+  // The ErrorCallback is used for methods that can fail in which case it is
+  // called, in the success case the callback is simply not called.
   typedef base::Closure ErrorCallback;
 
   // The BluetoothOutOfBandPairingDataCallback is used to return
   // BluetoothOutOfBandPairingData to the caller.
   typedef base::Callback<void(const BluetoothOutOfBandPairingData& data)>
       BluetoothOutOfBandPairingDataCallback;
 
-  // Adds and removes observers for events on this bluetooth adapter,
-  // if monitoring multiple adapters check the |adapter| parameter of
-  // observer methods to determine which adapter is issuing the event.
+  // Adds and removes observers for events on this bluetooth adapter, if
+  // monitoring multiple adapters check the |adapter| parameter of observer
+  // methods to determine which adapter is issuing the event.
   virtual void AddObserver(BluetoothAdapter::Observer* observer) = 0;
   virtual void RemoveObserver(
       BluetoothAdapter::Observer* observer) = 0;
 
   // The address of this adapter.  The address format is "XX:XX:XX:XX:XX:XX",
   // where each XX is a hexadecimal number.
   virtual std::string GetAddress() const = 0;
 
   // The name of the adapter.
   virtual std::string GetName() const = 0;
 
   // Set the human-readable name of the adapter to |name|. On success,
   // |callback| will be called. On failure, |error_callback| will be called.
   virtual void SetName(const std::string& name,
                        const base::Closure& callback,
                        const ErrorCallback& error_callback) = 0;
 
   // Indicates whether the adapter is initialized and ready to use.
   virtual bool IsInitialized() const = 0;
 
-  // Indicates whether the adapter is actually present on the system, for
-  // the default adapter this indicates whether any adapter is present. An
-  // adapter is only considered present if the address has been obtained.
+  // Indicates whether the adapter is actually present on the system, for the
+  // default adapter this indicates whether any adapter is present. An adapter
+  // is only considered present if the address has been obtained.
   virtual bool IsPresent() const = 0;
 
   // Indicates whether the adapter radio is powered.
   virtual bool IsPowered() const = 0;
 
   // Requests a change to the adapter radio power, setting |powered| to true
   // will turn on the radio and false will turn it off.  On success, callback
   // will be called.  On failure, |error_callback| will be called.
   virtual void SetPowered(bool powered,
                           const base::Closure& callback,
@@ skipping 28 matching lines @@
   // device discovery may actually be in progress. Clients can call GetDevices()
   // and check for those with IsPaired() as false to obtain the list of devices
   // that have been discovered so far. Otherwise, clients can be notified of all
   // new and lost devices can by implementing the Observer methods "DeviceAdded"
   // and "DeviceRemoved".
   typedef base::Callback<void(scoped_ptr<BluetoothDiscoverySession>)>
       DiscoverySessionCallback;
   virtual void StartDiscoverySession(const DiscoverySessionCallback& callback,
                                      const ErrorCallback& error_callback);
 
-  // Requests the list of devices from the adapter, all are returned
-  // including those currently connected and those paired. Use the
-  // returned device pointers to determine which they are.
+  // Requests the list of devices from the adapter, all are returned including
+  // those currently connected and those paired. Use the returned device
+  // pointers to determine which they are.
   typedef std::vector<BluetoothDevice*> DeviceList;
   virtual DeviceList GetDevices();
   typedef std::vector<const BluetoothDevice*> ConstDeviceList;
   virtual ConstDeviceList GetDevices() const;
 
-  // Returns a pointer to the device with the given address |address| or
-  // NULL if no such device is known.
+  // Returns a pointer to the device with the given address |address| or NULL if
+  // no such device is known.
   virtual BluetoothDevice* GetDevice(const std::string& address);
   virtual const BluetoothDevice* GetDevice(
       const std::string& address) const;
 
   // Requests the local Out Of Band pairing data.
   virtual void ReadLocalOutOfBandPairingData(
       const BluetoothOutOfBandPairingDataCallback& callback,
       const ErrorCallback& error_callback) = 0;
 
   // Possible priorities for AddPairingDelegate(), low is intended for
@@ skipping 78 matching lines @@
   // discovering. This should be called by all platform implementations.
   void MarkDiscoverySessionsAsInactive();
 
   // Removes |discovery_session| from |discovery_sessions_|, if its in there.
   // Called by DiscoverySession when an instance is destroyed or becomes
   // inactive.
   void DiscoverySessionBecameInactive(
       BluetoothDiscoverySession* discovery_session);
 
   // Devices paired with, connected to, discovered by, or visible to the
-  // adapter. The key is the Bluetooth address of the device and the value
-  // is the BluetoothDevice object whose lifetime is managed by the
-  // adapter instance.
+  // adapter. The key is the Bluetooth address of the device and the value is
+  // the BluetoothDevice object whose lifetime is managed by the adapter
+  // instance.
   typedef std::map<const std::string, BluetoothDevice*> DevicesMap;
   DevicesMap devices_;
 
   // Default pairing delegates registered with the adapter.
   typedef std::pair<BluetoothDevice::PairingDelegate*,
                     PairingDelegatePriority> PairingDelegatePair;
   std::list<PairingDelegatePair> pairing_delegates_;
 
  private:
   // List of active DiscoverySession objects. This is used to notify sessions to
   // become inactive in case of an unexpected change to the adapter discovery
   // state. We keep raw pointers, with the invariant that a DiscoverySession
   // will remove itself from this list when it gets destroyed or becomes
   // inactive by calling DiscoverySessionBecameInactive(), hence no pointers to
   // deallocated sessions are kept.
   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_