Refactoring bluetooth API code.

chrome/browser/chromeos/bluetooth/bluetooth_adapter_chromeos.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 CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_H_
-#define CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_H_
+#ifndef CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_CHROMEOS_H_
+#define CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_CHROMEOS_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
-#include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 #include "chromeos/dbus/bluetooth_adapter_client.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "chromeos/dbus/bluetooth_manager_client.h"
 #include "chromeos/dbus/bluetooth_out_of_band_client.h"

[keybuk, 2012/09/18 18:53:44]

as commented in previous patch set, with the explicit struct below, is this
#include still needed?

[youngki, 2012/09/19 01:13:55]

Removed.

 #include "dbus/object_path.h"
 
 namespace chromeos {
 
-class BluetoothDevice;
+class BluetoothDeviceChromeOs;
 
-// The BluetoothAdapter class 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 updates to device information.
-//
-// The class may be instantiated for either a specific adapter, or for the
-// generic "default adapter" which may change depending on availability.
-class BluetoothAdapter : public base::RefCounted<BluetoothAdapter>,
-                         public BluetoothManagerClient::Observer,
-                         public BluetoothAdapterClient::Observer,
-                         public BluetoothDeviceClient::Observer {
+struct BluetoothOutOfBandPairingData;
+
+// The BluetoothAdapterChromeOs class is an implementation of BluetoothAdapter
+// for Chrome OS platform.
+class BluetoothAdapterChromeOs : public BluetoothAdapter,
+                                 public BluetoothManagerClient::Observer,
+                                 public BluetoothAdapterClient::Observer,
+                                 public BluetoothDeviceClient::Observer {
  public:
-  // Interface for observing changes from bluetooth adapters.
-  class Observer {
-   public:
-    virtual ~Observer() {}
+  // BluetoothAdapter override
+  virtual void AddObserver(BluetoothAdapter::Observer* observer) OVERRIDE;
+  virtual void RemoveObserver(BluetoothAdapter::Observer* observer) OVERRIDE;
 
-    // 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) {}
+  // BluetoothAdapter override
+  virtual const std::string& address() const OVERRIDE;
 
-    // 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) {}
+  // BluetoothAdapter override
+  virtual const std::string& name() const OVERRIDE;
 
-    // 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. Note that device discovery involves both states when
-    // the adapter is seeking new devices and states when it is not because
-    // it is interrogating the devices it found.
-    virtual void AdapterDiscoveringChanged(BluetoothAdapter* adapter,
-                                           bool discovering) {}
+  // BluetoothAdapter override
+  virtual bool IsPresent() const OVERRIDE;
 
-    // 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) {}
+  // BluetoothAdapter override
+  virtual bool IsPowered() const OVERRIDE;
 
-    // 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) {}
+  // BluetoothAdapter override
+  virtual void SetPowered(bool powered,
+                          const base::Closure& callback,
+                          const ErrorCallback& error_callback) OVERRIDE;
 
-    // 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) {}
-  };
+  // BluetoothAdapter override
+  virtual bool IsDiscovering() const OVERRIDE;
 
-  // 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.
-  void AddObserver(Observer* observer);
-  void RemoveObserver(Observer* observer);
-
-  // 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::Callback<void()> ErrorCallback;
-
-  // The BluetoothOutOfBandPairingDataCallback is used to return
-  // BluetoothOutOfBandPairingData to the caller.
-  typedef base::Callback<void(const BluetoothOutOfBandPairingData& data)>
-      BluetoothOutOfBandPairingDataCallback;
-
-  // The address of this adapter.  The address format is "XX:XX:XX:XX:XX:XX",
-  // where each XX is a hexadecimal number.
-  const std::string& address() const { return address_; }
-
-  // The name of the adapter.
-  const std::string& name() const { return name_; }
-
-  // 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;
-
-  // Indicates whether the adapter radio is powered.
-  virtual bool IsPowered() const;
-
-  // 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.
-  void SetPowered(bool powered,
-                  const base::Closure& callback,
-                  const ErrorCallback& error_callback);
-
-  // Indicates whether the adapter is currently discovering new devices,
-  // note that a typical discovery process has phases of this being true
-  // followed by phases of being false when the adapter interrogates the
-  // devices found.
-  virtual bool IsDiscovering() const;
-
-  // Requests that the adapter either begin discovering new devices when
-  // |discovering| is true, or cease any discovery when false.  On success,
-  // callback will be called.  On failure, |error_callback| will be called.
+  // BluetoothAdapter override
   virtual void SetDiscovering(bool discovering,
                               const base::Closure& callback,
-                              const ErrorCallback& error_callback);
+                              const ErrorCallback& error_callback) OVERRIDE;
 
-  // 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;
+  // BluetoothAdapter override
+  virtual DeviceList GetDevices() OVERRIDE;
+  virtual ConstDeviceList GetDevices() const OVERRIDE;
 
-  // 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;
+  // BluetoothAdapter override
+  virtual BluetoothDevice* GetDevice(const std::string& address) OVERRIDE;
+  virtual const BluetoothDevice* GetDevice(
+      const std::string& address) const OVERRIDE;
 
-  // Requests the local Out Of Band pairing data.
+  // BluetoothAdapter override
   virtual void ReadLocalOutOfBandPairingData(
       const BluetoothOutOfBandPairingDataCallback& callback,
-      const ErrorCallback& error_callback);
-
-  // Returns the shared instance for the default adapter, whichever that may
-  // be at the time. Use IsPresent() and the AdapterPresentChanged() observer
-  // method to determine whether an adapter is actually available or not.
-  static scoped_refptr<BluetoothAdapter> DefaultAdapter();
-
-  // Creates an instance for a specific adapter named by |address|, which
-  // may be the bluetooth address of the adapter or a device name such as
-  // "hci0".
-  static BluetoothAdapter* Create(const std::string& address);
+      const ErrorCallback& error_callback) OVERRIDE;
 
  private:

[bryeung, 2012/09/18 19:18:39]

friends aren't inherited: you need

friend class base::RefCounted<BluetoothAdapterChromeOs>

[youngki, 2012/09/19 01:13:55]

As long as we only use ref_counted pointer for BluetoothAdapter and the
destructors are virtual, we don't need to friend
base::RefCounted<BluetoothAdapterChromeOs> because
BluetoothAdapterChromeOs::~BluetoothAdapterChromeOs() will be called first when
BluetoothAdapter::~BluetoothAdapter() is called by
base::RefCounted<BluetoothAdapter>().

Also the compiler complains that BluetoothAdapterChromeOs cannot inherit
base::RefCounted because its superclass BluetoothAdapter is already inheriting
it.

[bryeung, 2012/09/19 13:27:16]

Okay, makes sense.

-  friend class base::RefCounted<BluetoothAdapter>;
-  friend class BluetoothDevice;
+  friend class BluetoothAdapterFactory;
+  friend class BluetoothDeviceChromeOs;
   friend class MockBluetoothAdapter;
 
-  BluetoothAdapter();
-  virtual ~BluetoothAdapter();
+  BluetoothAdapterChromeOs();
+  virtual ~BluetoothAdapterChromeOs();
 
   // Obtains the default adapter object path from the Bluetooth Daemon
   // and tracks future changes to it.
   void TrackDefaultAdapter();
 
   // Obtains the object paht for the adapter named by |address| from the
   // Bluetooth Daemon.
   void FindAdapter(const std::string& address);
 
   // Called by dbus:: in response to the method call sent by both
@@ skipping 140 matching lines @@
   // Name of the adapter.
   std::string name_;
 
   // Tracked adapter state, cached locally so we only send change notifications
   // to observers on a genuine change.
   bool powered_;
   bool discovering_;
 
   // 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.
-  typedef std::map<const std::string, BluetoothDevice*> DevicesMap;
+  // is the BluetoothDeviceChromeOs object whose lifetime is managed by the
+  // adapter instance.
+  typedef std::map<const std::string, BluetoothDeviceChromeOs*> DevicesMap;
   DevicesMap devices_;
 
   // 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_;
+  base::WeakPtrFactory<BluetoothAdapterChromeOs> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(BluetoothAdapter);
+  DISALLOW_COPY_AND_ASSIGN(BluetoothAdapterChromeOs);
 };
 
 }  // namespace chromeos
 
-#endif  // CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_H_
+#endif  // CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_CHROMEOS_H_