Refactoring bluetooth API code.

chrome/browser/chromeos/bluetooth/bluetooth_device_dbus.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

[keybuk, 2012/09/13 23:57:30]

rename to bluetooth_device_chromeos.h

[youngki, 2012/09/17 21:53:02]

Done.

 // 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_DEVICE_H_
-#define CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_H_
+#ifndef CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_DBUS_H_
+#define CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_DBUS_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
-#include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string16.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
 #include "chromeos/dbus/bluetooth_agent_service_provider.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "chromeos/dbus/bluetooth_out_of_band_client.h"
 #include "dbus/object_path.h"
 
 namespace chromeos {
 
-class BluetoothAdapter;
+class BluetoothAdapterDBus;
 class BluetoothServiceRecord;
-class BluetoothSocket;
 
-// The BluetoothDevice class 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.
+struct BluetoothOutOfBandPairingData;
+
+// The BluetoothDeviceDBus class is an implementation of BluetoothDevice using
+// DBus for Linux/ChromeOS platform.
 //
-// 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 address() method as a unique key for a device.
+// The class is instantiated and managed by the BluetoothAdapterDBus class
+// and pointers should only be obtained from the BluetoothAdapter and not
+// cached, instead use the address() method as a unique key for a device.
 //
-// Since the lifecycle of BluetoothDevice instances is managed by
-// BluetoothAdapter, that class rather than this provides observer methods
+// Since the lifecycle of BluetoothDeviceDBus instances is managed by
+// BluetoothAdapterDBus, that class rather than this provides observer methods
 // for devices coming and going, as well as properties being updated.
-class BluetoothDevice : public BluetoothDeviceClient::Observer,
-                        public BluetoothAgentServiceProvider::Delegate {
+class BluetoothDeviceDBus : public BluetoothDevice,

[keybuk, 2012/09/13 23:57:30]

BluetoothDeviceChromeOs

[youngki, 2012/09/17 21:53:02]

Done.

+                            public BluetoothDeviceClient::Observer,
+                            public BluetoothAgentServiceProvider::Delegate {
  public:
-  // Possible values that may be returned by GetDeviceType(), representing
-  // different types of bluetooth device that we support or are aware of
-  // decoded from the bluetooth class information.
-  enum DeviceType {
-    DEVICE_UNKNOWN,
-    DEVICE_COMPUTER,
-    DEVICE_PHONE,
-    DEVICE_MODEM,
-    DEVICE_PERIPHERAL,
-    DEVICE_JOYSTICK,
-    DEVICE_GAMEPAD,
-    DEVICE_KEYBOARD,
-    DEVICE_MOUSE,
-    DEVICE_TABLET,
-    DEVICE_KEYBOARD_MOUSE_COMBO
-  };
-
-  // Interface for observing changes from bluetooth devices.
-  class Observer {
-   public:
-    virtual ~Observer() {}
-
-    // TODO(keybuk): add observers for pairing and connection.
-  };
-
-  // Interface for negotiating pairing of bluetooth devices.
-  class PairingDelegate {
-   public:
-    virtual ~PairingDelegate() {}
-
-    // This method will be called when the Bluetooth daemon requires a
-    // PIN Code for authentication of the device |device|, the delegate should
-    // obtain the code from the user and call SetPinCode() on the device to
-    // provide it, or RejectPairing() or CancelPairing() to reject or cancel
-    // the request.
-    //
-    // PIN Codes are generally required for Bluetooth 2.0 and earlier devices
-    // for which there is no automatic pairing or special handling.
-    virtual void RequestPinCode(BluetoothDevice* device) = 0;
-
-    // This method will be called when the Bluetooth daemon requires a
-    // Passkey for authentication of the device |device|, the delegate should
-    // obtain the passkey from the user (a numeric in the range 0-999999) and
-    // call SetPasskey() on the device to provide it, or RejectPairing() or
-    // CancelPairing() to reject or cancel the request.
-    //
-    // Passkeys are generally required for Bluetooth 2.1 and later devices
-    // which cannot provide input or display on their own, and don't accept
-    // passkey-less pairing.
-    virtual void RequestPasskey(BluetoothDevice* device) = 0;
-
-    // This method will be called when the Bluetooth daemon requires that the
-    // user enter the PIN code |pincode| into the device |device| so that it
-    // may be authenticated. The DismissDisplayOrConfirm() method
-    // will be called to dismiss the display once pairing is complete or
-    // cancelled.
-    //
-    // This is used for Bluetooth 2.0 and earlier keyboard devices, the
-    // |pincode| will always be a six-digit numeric in the range 000000-999999
-    // for compatibilty with later specifications.
-    virtual void DisplayPinCode(BluetoothDevice* device,
-                                const std::string& pincode) = 0;
-
-    // This method will be called when the Bluetooth daemon requires that the
-    // user enter the Passkey |passkey| into the device |device| so that it
-    // may be authenticated. The DismissDisplayOrConfirm() method will be
-    // called to dismiss the display once pairing is complete or cancelled.
-    //
-    // This is used for Bluetooth 2.1 and later devices that support input
-    // but not display, such as keyboards. The Passkey is a numeric in the
-    // range 0-999999 and should be always presented zero-padded to six
-    // digits.
-    virtual void DisplayPasskey(BluetoothDevice* device,
-                                uint32 passkey) = 0;
-
-    // This method will be called when the Bluetooth daemon requires that the
-    // user confirm that the Passkey |passkey| is displayed on the screen
-    // of the device |device| so that it may be authenticated. The delegate
-    // should display to the user and ask for confirmation, then call
-    // ConfirmPairing() on the device to confirm, RejectPairing() on the device
-    // to reject or CancelPairing() on the device to cancel authentication
-    // for any other reason.
-    //
-    // This is used for Bluetooth 2.1 and later devices that support display,
-    // such as other computers or phones. The Passkey is a numeric in the
-    // range 0-999999 and should be always present zero-padded to six
-    // digits.
-    virtual void ConfirmPasskey(BluetoothDevice* device,
-                                uint32 passkey) = 0;
-
-    // This method will be called when any previous DisplayPinCode(),
-    // DisplayPasskey() or ConfirmPasskey() request should be concluded
-    // and removed from the user.
-    virtual void DismissDisplayOrConfirm() = 0;
-  };
-
-  virtual ~BluetoothDevice();
+  virtual ~BluetoothDeviceDBus();
 
   // Returns the Bluetooth of address the device. This should be used as
   // a unique key to identify the device and copied where needed.
-  virtual const std::string& address() const;
+  virtual const std::string& address() const OVERRIDE;
 
   // Returns the name of the device suitable for displaying, this may
   // be a synthesied string containing the address and localized type name
   // if the device has no obtained name.
-  virtual string16 GetName() const;
+  virtual string16 GetName() const OVERRIDE;
 
   // Returns the type of the device, limited to those we support or are
   // aware of, by decoding the bluetooth class information. The returned
   // values are unique, and do not overlap, so DEVICE_KEYBOARD is not also
   // DEVICE_PERIPHERAL.
-  DeviceType GetDeviceType() const;
+  virtual BluetoothDevice::DeviceType GetDeviceType() const OVERRIDE;
 
   // Returns a localized string containing the device's bluetooth address and
   // a device type for display when |name_| is empty.
   string16 GetAddressWithLocalizedDeviceTypeName() const;
 
   // Indicates whether the class of this device is supported by Chrome OS.
   bool IsSupported() const;
 
   // Indicates whether the device is paired to the adapter, whether or not
   // that pairing is permanent or temporary.
-  virtual bool IsPaired() const;
+  virtual bool IsPaired() const OVERRIDE;
 
   // Indicates whether the device is visible to the adapter, this is not
   // mutually exclusive to being paired.
   bool IsVisible() const { return visible_; }
 
   // Indicates whether the device is bonded to the adapter, bonding is
   // formed by pairing and exchanging high-security link keys so that
   // connections may be encrypted.
-  virtual bool IsBonded() const;
+  virtual bool IsBonded() const OVERRIDE;
 
   // Indicates whether the device is currently connected to the adapter
   // and at least one service available for use.
-  virtual bool IsConnected() const;
+  virtual bool IsConnected() const OVERRIDE;
 
   // Returns the services (as UUID strings) that this device provides.
   typedef std::vector<std::string> ServiceList;
   const ServiceList& GetServices() const { return service_uuids_; }
 
-  // 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;
-
   // Returns the services (as BluetoothServiceRecord objects) that this device
   // provides.
-  typedef ScopedVector<BluetoothServiceRecord> ServiceRecordList;
-  typedef base::Callback<void(const ServiceRecordList&)> ServiceRecordsCallback;
-  void GetServiceRecords(const ServiceRecordsCallback& callback,
-                         const ErrorCallback& error_callback);
+  virtual void GetServiceRecords(const ServiceRecordsCallback& callback,
+                                 const ErrorCallback& error_callback) OVERRIDE;
 
   // Indicates whether this device provides the given service.  |uuid| should
   // be in canonical form (see bluetooth_utils::CanonicalUuid).
-  virtual bool ProvidesServiceWithUUID(const std::string& uuid) const;
-
-  // The ProvidesServiceCallback is used by ProvidesServiceWithName to indicate
-  // whether or not a matching service was found.
-  typedef base::Callback<void(bool)> ProvidesServiceCallback;
+  virtual bool ProvidesServiceWithUUID(const std::string& uuid) const OVERRIDE;
 
   // Indicates whether this device provides the given service.
   virtual void ProvidesServiceWithName(const std::string& name,
-                                       const ProvidesServiceCallback& callback);
+                                       const ProvidesServiceCallback& callback)
+      OVERRIDE;
 
   // Indicates whether the device is currently pairing and expecting a
   // PIN Code to be returned.
   bool ExpectingPinCode() const { return !pincode_callback_.is_null(); }
 
   // Indicates whether the device is currently pairing and expecting a
   // Passkey to be returned.
   bool ExpectingPasskey() const { return !passkey_callback_.is_null(); }
 
   // Indicates whether the device is currently pairing and expecting
   // confirmation of a displayed passkey.
   bool ExpectingConfirmation() const {
     return !confirmation_callback_.is_null();
   }
 
   // Initiates a connection to the device, pairing first if necessary.
   //
   // Method calls will be made on the supplied object |pairing_delegate|
   // to indicate what display, and in response should make method calls
   // back to the device object. Not all devices require user responses
   // during pairing, so it is normal for |pairing_delegate| to receive no
   // calls. To explicitly force a low-security connection without bonding,
   // pass NULL, though this is ignored if the device is already paired.
   //
   // If the request fails, |error_callback| will be called; otherwise,
   // |callback| is called when the request is complete.
-  void Connect(PairingDelegate* pairing_delegate,
+  void Connect(BluetoothDevice::PairingDelegate* pairing_delegate,
                const base::Closure& callback,
                const ErrorCallback& error_callback);
 
   // Sends the PIN code |pincode| to the remote device during pairing.
   //
   // PIN Codes are generally required for Bluetooth 2.0 and earlier devices
   // for which there is no automatic pairing or special handling.
   void SetPinCode(const std::string& pincode);
 
   // Sends the Passkey |passkey| to the remote device during pairing.
@@ skipping 23 matching lines @@
 
   // Disconnects the device, terminating the low-level ACL connection
   // and any application connections using it, and then discards link keys
   // and other pairing information. The device object remainds valid until
   // returing from the calling function, after which it should be assumed to
   // have been deleted. If the request fails, |error_callback| will be called.
   // There is no callback for success beause this object is often deleted
   // before that callback would be called.
   void Forget(const ErrorCallback& error_callback);
 
-  // SocketCallback is used by ConnectToService to return a BluetoothSocket
-  // to the caller, or NULL if there was an error.  The socket will remain open
-  // until the last reference to the returned BluetoothSocket is released.
-  typedef base::Callback<void(scoped_refptr<BluetoothSocket>)> SocketCallback;
-
   // Attempts to open a socket to a service matching |uuid| on this device.  If
-  // the connection is successful, |callback| is called with a BluetoothSocket.
+  // the connection is successful, |callback| is called with a
+  // BluetoothSocket.
   // Otherwise |callback| is called with NULL.  The socket is closed as soon as
   // all references to the BluetoothSocket are released.  Note that the
-  // BluetoothSocket object can outlive both this BluetoothDevice and the
-  // BluetoothAdapter for this device.
-  void ConnectToService(const std::string& service_uuid,
-                        const SocketCallback& callback);
+  // BluetoothSocket object can outlive both this BluetoothDeviceDBus and
+  // the BluetoothAdapterDBus for this device.
+  virtual void ConnectToService(const std::string& service_uuid,
+                                const SocketCallback& callback) OVERRIDE;
 
   // Sets the Out Of Band pairing data for this device to |data|.  Exactly one
   // of |callback| or |error_callback| will be run.
   virtual void SetOutOfBandPairingData(
       const chromeos::BluetoothOutOfBandPairingData& data,
       const base::Closure& callback,
-      const ErrorCallback& error_callback);
+      const ErrorCallback& error_callback) OVERRIDE;
 
   // Clears the Out Of Band pairing data for this device.  Exactly one of
   // |callback| or |error_callback| will be run.
   virtual void ClearOutOfBandPairingData(
       const base::Closure& callback,
-      const ErrorCallback& error_callback);
+      const ErrorCallback& error_callback) OVERRIDE;
 
  private:
-  friend class BluetoothAdapter;
+  friend class BluetoothAdapterDBus;
   friend class MockBluetoothDevice;
 
-  explicit BluetoothDevice(BluetoothAdapter* adapter);
+  explicit BluetoothDeviceDBus(BluetoothAdapterDBus* adapter);
 
   // Sets the dbus object path for the device to |object_path|, indicating
   // that the device has gone from being discovered to paired or bonded.
   void SetObjectPath(const dbus::ObjectPath& object_path);
 
   // Removes the dbus object path from the device, indicating that the
   // device is no longer paired or bonded, but perhaps still visible.
   void RemoveObjectPath();
 
   // Sets whether the device is visible to the owning adapter to |visible|.
@@ skipping 77 matching lines @@
                       const std::string& error_message);
 
   // Called by BluetoothDeviceClient when a call to Disconnect() completes,
   // |success| indicates whether or not the request succeeded, |callback| and
   // |error_callback| are the callbacks provided to Disconnect() and
   // |device_path| is the device disconnected.
   void DisconnectCallback(const base::Closure& callback,
                           const ErrorCallback& error_callback,
                           const dbus::ObjectPath& device_path, bool success);
 
-  // Called by BluetoothAdapterClient when a call to RemoveDevice() completes,
-  // |success| indicates whether or not the request succeeded, |error_callback|
-  // is the callback provided to Forget() and |adapter_path| is the d-bus
-  // object path of the adapter that performed the removal.
+  // Called by BluetoothAdapterClient when a call to RemoveDevice()
+  // completes, |success| indicates whether or not the request succeeded,
+  // |error_callback| is the callback provided to Forget() and |adapter_path| is
+  // the d-bus object path of the adapter that performed the removal.
   void ForgetCallback(const ErrorCallback& error_callback,
                       const dbus::ObjectPath& adapter_path, bool success);
 
   // Called if the call to GetServiceRecords from ProvidesServiceWithName fails.
   void SearchServicesForNameErrorCallback(
       const ProvidesServiceCallback& callback);
 
   // Called by GetServiceRecords with the list of BluetoothServiceRecords to
   // search for |name|.  |callback| is the callback from
   // ProvidesServiceWithName.
@@ skipping 128 matching lines @@
   // their response (success, rejected or cancelled).
   virtual void ConfirmModeChange(Mode mode,
                                  const ConfirmationCallback& callback) OVERRIDE;
 
   // BluetoothAgentServiceProvider::Delegate override.
   //
   // This method will be called by the Bluetooth daemon to indicate that
   // the request failed before a reply was returned from the device.
   virtual void Cancel() OVERRIDE;
 
-  // Creates a new BluetoothDevice object bound to the adapter |adapter|.
-  static BluetoothDevice* Create(BluetoothAdapter* adapter);
+  // Creates a new BluetoothDeviceDBus object bound to the adapter |adapter|.
+  static BluetoothDeviceDBus* Create(BluetoothAdapterDBus* adapter);
 
   // The adapter that owns this device instance.
-  BluetoothAdapter* adapter_;
+  BluetoothAdapterDBus* adapter_;
 
   // The dbus object path of the device, will be empty if the device has only
   // been discovered and not yet paired with.
   dbus::ObjectPath object_path_;
 
   // The Bluetooth address of the device.
   std::string address_;
 
   // The name of the device, as supplied by the remote device.
   std::string name_;
 
   // The Bluetooth class of the device, a bitmask that may be decoded using
   // https://www.bluetooth.org/Technical/AssignedNumbers/baseband.htm
   uint32 bluetooth_class_;
 
   // Tracked device state, updated by the adapter managing the lifecyle of
   // the device.
   bool visible_;
   bool bonded_;
   bool connected_;
 
   // The services (identified by UUIDs) that this device provides.
   std::vector<std::string> service_uuids_;
 
   // During pairing this is set to an object that we don't own, but on which
   // we can make method calls to request, display or confirm PIN Codes and
   // Passkeys. Generally it is the object that owns this one.
-  PairingDelegate* pairing_delegate_;
+  BluetoothDevice::PairingDelegate* pairing_delegate_;
 
   // During pairing this is set to an instance of a D-Bus agent object
   // intialized with our own class as its delegate.
   scoped_ptr<BluetoothAgentServiceProvider> agent_;
 
   // During pairing these callbacks are set to those provided by method calls
   // made on us by |agent_| and are called by our own method calls such as
   // SetPinCode() and SetPasskey().
   PinCodeCallback pincode_callback_;
   PasskeyCallback passkey_callback_;
   ConfirmationCallback confirmation_callback_;
 
   // Used to keep track of pending application connection requests.
   int connecting_applications_counter_;
 
   // 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<BluetoothDevice> weak_ptr_factory_;
+  base::WeakPtrFactory<BluetoothDeviceDBus> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(BluetoothDevice);
+  DISALLOW_COPY_AND_ASSIGN(BluetoothDeviceDBus);
 };
 
 }  // namespace chromeos
 
-#endif  // CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_H_
+#endif  // CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_DBUS_H_