Bluetooth: clean up BluetoothDevice

device/bluetooth/bluetooth_device_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 DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 22 matching lines @@
 // The BluetoothDeviceChromeOS class is an implementation of BluetoothDevice
 // for Chrome OS platform.
 class BluetoothDeviceChromeOS
     : public device::BluetoothDevice,
       public BluetoothDeviceClient::Observer,
       public BluetoothAgentServiceProvider::Delegate {
  public:
   virtual ~BluetoothDeviceChromeOS();
 
   // BluetoothDevice override
+  virtual std::string GetAddress() const OVERRIDE;
   virtual bool IsPaired() const OVERRIDE;
-  virtual const ServiceList& GetServices() const OVERRIDE;
+  virtual bool IsConnected() const OVERRIDE;
+  virtual bool IsConnectable() const OVERRIDE;
+  virtual bool IsConnecting() const OVERRIDE;
+  virtual ServiceList GetServices() const OVERRIDE;
   virtual void GetServiceRecords(
       const ServiceRecordsCallback& callback,
       const ErrorCallback& error_callback) OVERRIDE;
   virtual void ProvidesServiceWithName(
       const std::string& name,
       const ProvidesServiceCallback& callback) OVERRIDE;
   virtual bool ExpectingPinCode() const OVERRIDE;
   virtual bool ExpectingPasskey() const OVERRIDE;
   virtual bool ExpectingConfirmation() const OVERRIDE;
   virtual void Connect(
@@ skipping 13 matching lines @@
       const std::string& service_uuid,
       const SocketCallback& callback) OVERRIDE;
   virtual void SetOutOfBandPairingData(
       const device::BluetoothOutOfBandPairingData& data,
       const base::Closure& callback,
       const ErrorCallback& error_callback) OVERRIDE;
   virtual void ClearOutOfBandPairingData(
       const base::Closure& callback,
       const ErrorCallback& error_callback) OVERRIDE;
 
+ protected:
+  // BluetoothDevice override
+  virtual uint32 GetBluetoothClass() const OVERRIDE;
+  virtual std::string GetDeviceName() const OVERRIDE;
+
  private:
   friend class BluetoothAdapterChromeOS;
   friend class device::MockBluetoothDevice;
 
   explicit BluetoothDeviceChromeOS(BluetoothAdapterChromeOS* adapter);
 
+  // Returns whether this device has an object path.
+  bool HasObjectPath() const { return !object_path_.value().empty(); }
+
   // Sets the dbus object path for the device to |object_path|, indicating
-  // that the device has gone from being discovered to paired or bonded.
+  // that the device has gone from being discovered to paired or connected.
   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.
+  // device is no longer paired or connected, but perhaps still visible.
   void RemoveObjectPath();
 
-  // Sets whether the device is visible to the owning adapter to |visible|.
-  void SetVisible(bool visible) { visible_ = visible; }
+  // Returns whether this was a discovered device.
+  bool WasDiscovered() const { return discovered_; }
+
+  // Sets whether the device was discovered.
+  void SetDiscovered(bool discovered) { discovered_ = discovered; }
 
   // Updates device information from the properties in |properties|, device
   // state properties such as |paired_| and |connected_| are ignored unless
   // |update_state| is true.
   void Update(const BluetoothDeviceClient::Properties* properties,
               bool update_state);
 
   // Called by BluetoothAdapterClient when a call to CreateDevice() or
   // CreatePairedDevice() succeeds, provides the new object path for the remote
   // device in |device_path|. |callback| and |error_callback| are the callbacks
@@ skipping 260 matching lines @@
   // |adapter|.
   static BluetoothDeviceChromeOS* Create(BluetoothAdapterChromeOS* adapter);
 
   // The adapter that owns this device instance.
   BluetoothAdapterChromeOS* 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 class of the device, a bitmask that may be decoded using
+  // https://www.bluetooth.org/Technical/AssignedNumbers/baseband.htm
+  uint32 bluetooth_class_;
+
+  // The name of the device, as supplied by the remote device.
+  std::string name_;
+
+  // The Bluetooth address of the device.
+  std::string address_;
+
+  // Tracked device state, updated by the adapter managing the lifecyle of
+  // the device.
+  bool paired_;
+  bool connected_;
+
+  // Indicates whether the device normally accepts connections initiated from
+  // the adapter once paired.
+  bool connectable_;
+
+  // Indicated whether the device is in a connecting status.
+  bool connecting_;
+
+  // Used by BluetoothAdapterChromeOS (a friend) to avoid removing discovered
+  // devices when they are unpaired.
+  bool discovered_;
+
   // The services (identified by UUIDs) that this device provides.
-  std::vector<std::string> service_uuids_;
+  ServiceList 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.
   device::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_;
 
@@ skipping 20 matching lines @@
   // 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<BluetoothDeviceChromeOS> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothDeviceChromeOS);
 };
 
 }  // namespace chromeos
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_