Reland "Add Linux support for the Bluetooth API"

device/bluetooth/bluetooth_adapter_bluez.h

 // Copyright 2013 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_CHROMEOS_H_
-#define DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_CHROMEOS_H_
+#ifndef DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_BLUEZ_H_
+#define DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_BLUEZ_H_
 
 #include <map>
 #include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_audio_sink.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_export.h"
 #include "device/bluetooth/dbus/bluetooth_adapter_client.h"
 #include "device/bluetooth/dbus/bluetooth_agent_service_provider.h"
 #include "device/bluetooth/dbus/bluetooth_device_client.h"
 #include "device/bluetooth/dbus/bluetooth_input_client.h"
 #include "device/bluetooth/dbus/bluetooth_profile_manager_client.h"
 #include "device/bluetooth/dbus/bluetooth_profile_service_provider.h"
 
 namespace base {
 class SequencedTaskRunner;
 }  // namespace base
 
 namespace device {
 class BluetoothSocketThread;
 }  // namespace device
 
-namespace chromeos {
+namespace bluez {
 
-class BluetoothChromeOSTest;
-class BluetoothAdapterProfileChromeOS;
-class BluetoothDeviceChromeOS;
-class BluetoothPairingChromeOS;
-class BluetoothRemoteGattCharacteristicChromeOS;
-class BluetoothRemoteGattDescriptorChromeOS;
-class BluetoothRemoteGattServiceChromeOS;
+class BluetoothBlueZTest;
+class BluetoothAdapterProfileBlueZ;
+class BluetoothDeviceBlueZ;
+class BluetoothPairingBlueZ;
+class BluetoothRemoteGattCharacteristicBlueZ;
+class BluetoothRemoteGattDescriptorBlueZ;
+class BluetoothRemoteGattServiceBlueZ;
 
-// The BluetoothAdapterChromeOS class implements BluetoothAdapter for the
+// The BluetoothAdapterBlueZ class implements BluetoothAdapter for the
 // Chrome OS platform.

[ortuno, 2015/11/06 18:15:41]

Leftover reference to Chrome OS.

[rkc, 2015/11/25 00:48:16]

Done.

 //
 // All methods are called from the dbus origin / UI thread and are generally
 // not assumed to be thread-safe.
 //
 // This class interacts with sockets using the BluetoothSocketThread to ensure
 // single-threaded calls, and posts tasks to the UI thread.
 //
-// Methods tolerate a shutdown scenario where BluetoothAdapterChromeOS::Shutdown
+// Methods tolerate a shutdown scenario where BluetoothAdapterBlueZ::Shutdown
 // causes IsPresent to return false just before the dbus system is shutdown but
-// while references to the BluetoothAdapterChromeOS object still exists.
+// while references to the BluetoothAdapterBlueZ object still exists.
 //
 // When adding methods to this class verify shutdown behavior in
-// BluetoothChromeOSTest, Shutdown.
-class DEVICE_BLUETOOTH_EXPORT BluetoothAdapterChromeOS
+// BluetoothBlueZTest, Shutdown.
+class DEVICE_BLUETOOTH_EXPORT BluetoothAdapterBlueZ
     : public device::BluetoothAdapter,
       public bluez::BluetoothAdapterClient::Observer,
       public bluez::BluetoothDeviceClient::Observer,
       public bluez::BluetoothInputClient::Observer,
       public bluez::BluetoothAgentServiceProvider::Delegate {
  public:
   typedef base::Callback<void(const std::string& error_message)>
       ErrorCompletionCallback;
-  typedef base::Callback<void(BluetoothAdapterProfileChromeOS* profile)>
+  typedef base::Callback<void(BluetoothAdapterProfileBlueZ* profile)>
       ProfileRegisteredCallback;
 
   static base::WeakPtr<BluetoothAdapter> CreateAdapter();
 
   // BluetoothAdapter:
   void Shutdown() override;
   std::string GetAddress() const override;
   std::string GetName() const override;
   void SetName(const std::string& name,
                const base::Closure& callback,
@@ skipping 24 matching lines @@
       const device::BluetoothAdapter::AcquiredCallback& callback,
       const device::BluetoothAudioSink::ErrorCallback& error_callback) override;
 
   void RegisterAdvertisement(
       scoped_ptr<device::BluetoothAdvertisement::Data> advertisement_data,
       const CreateAdvertisementCallback& callback,
       const CreateAdvertisementErrorCallback& error_callback) override;
 
   // Locates the device object by object path (the devices map and
   // BluetoothDevice methods are by address).
-  BluetoothDeviceChromeOS* GetDeviceWithPath(
-      const dbus::ObjectPath& object_path);
+  BluetoothDeviceBlueZ* GetDeviceWithPath(const dbus::ObjectPath& object_path);
 
   // Announces to observers a change in device state that is not reflected by
   // its D-Bus properties. |device| is owned by the caller and cannot be NULL.
-  void NotifyDeviceChanged(BluetoothDeviceChromeOS* device);
+  void NotifyDeviceChanged(BluetoothDeviceBlueZ* device);
 
   // Announce to observers a device address change.
-  void NotifyDeviceAddressChanged(BluetoothDeviceChromeOS* device,
+  void NotifyDeviceAddressChanged(BluetoothDeviceBlueZ* device,
                                   const std::string& old_address);
 
   // The following methods are used to send various GATT observer events to
   // observers.
-  void NotifyGattServiceAdded(BluetoothRemoteGattServiceChromeOS* service);
-  void NotifyGattServiceRemoved(BluetoothRemoteGattServiceChromeOS* service);
-  void NotifyGattServiceChanged(BluetoothRemoteGattServiceChromeOS* service);
-  void NotifyGattServicesDiscovered(BluetoothDeviceChromeOS* device);
-  void NotifyGattDiscoveryComplete(BluetoothRemoteGattServiceChromeOS* service);
+  void NotifyGattServiceAdded(BluetoothRemoteGattServiceBlueZ* service);
+  void NotifyGattServiceRemoved(BluetoothRemoteGattServiceBlueZ* service);
+  void NotifyGattServiceChanged(BluetoothRemoteGattServiceBlueZ* service);
+  void NotifyGattServicesDiscovered(BluetoothDeviceBlueZ* device);
+  void NotifyGattDiscoveryComplete(BluetoothRemoteGattServiceBlueZ* service);
   void NotifyGattCharacteristicAdded(
-      BluetoothRemoteGattCharacteristicChromeOS* characteristic);
+      BluetoothRemoteGattCharacteristicBlueZ* characteristic);
   void NotifyGattCharacteristicRemoved(
-      BluetoothRemoteGattCharacteristicChromeOS* characteristic);
+      BluetoothRemoteGattCharacteristicBlueZ* characteristic);
   void NotifyGattDescriptorAdded(
-      BluetoothRemoteGattDescriptorChromeOS* descriptor);
+      BluetoothRemoteGattDescriptorBlueZ* descriptor);
   void NotifyGattDescriptorRemoved(
-      BluetoothRemoteGattDescriptorChromeOS* descriptor);
+      BluetoothRemoteGattDescriptorBlueZ* descriptor);
   void NotifyGattCharacteristicValueChanged(
-      BluetoothRemoteGattCharacteristicChromeOS* characteristic,
+      BluetoothRemoteGattCharacteristicBlueZ* characteristic,
       const std::vector<uint8>& value);
   void NotifyGattDescriptorValueChanged(
-      BluetoothRemoteGattDescriptorChromeOS* descriptor,
+      BluetoothRemoteGattDescriptorBlueZ* descriptor,
       const std::vector<uint8>& value);
 
   // Returns the object path of the adapter.
   const dbus::ObjectPath& object_path() const { return object_path_; }
 
   // Request a profile on the adapter for a custom service with a
   // specific UUID for the device at |device_path| to be sent to |delegate|.
   // If |device_path| is the empty string, incoming connections will be
   // assigned to |delegate|.  When the profile is
   // successfully registered, |success_callback| will be called with a pointer
-  // to the profile which is managed by BluetoothAdapterChromeOS.  On failure,
+  // to the profile which is managed by BluetoothAdapterBlueZ.  On failure,
   // |error_callback| will be called.
   void UseProfile(const device::BluetoothUUID& uuid,
                   const dbus::ObjectPath& device_path,
                   const bluez::BluetoothProfileManagerClient::Options& options,
                   bluez::BluetoothProfileServiceProvider::Delegate* delegate,
                   const ProfileRegisteredCallback& success_callback,
                   const ErrorCompletionCallback& error_callback);
 
   // Release use of a profile by a device.
   void ReleaseProfile(const dbus::ObjectPath& device_path,
-                      BluetoothAdapterProfileChromeOS* profile);
+                      BluetoothAdapterProfileBlueZ* profile);
 
  protected:
   // BluetoothAdapter:
   void RemovePairingDelegateInternal(
       device::BluetoothDevice::PairingDelegate* pairing_delegate) override;
 
  private:
-  friend class BluetoothChromeOSTest;
-  friend class BluetoothChromeOSTest_Shutdown_Test;
-  friend class BluetoothChromeOSTest_Shutdown_OnStartDiscovery_Test;
-  friend class BluetoothChromeOSTest_Shutdown_OnStartDiscoveryError_Test;
-  friend class BluetoothChromeOSTest_Shutdown_OnStopDiscovery_Test;
-  friend class BluetoothChromeOSTest_Shutdown_OnStopDiscoveryError_Test;
+  friend class BluetoothBlueZTest;
+  friend class BluetoothBlueZTest_Shutdown_Test;
+  friend class BluetoothBlueZTest_Shutdown_OnStartDiscovery_Test;
+  friend class BluetoothBlueZTest_Shutdown_OnStartDiscoveryError_Test;
+  friend class BluetoothBlueZTest_Shutdown_OnStopDiscovery_Test;
+  friend class BluetoothBlueZTest_Shutdown_OnStopDiscoveryError_Test;
 
   // typedef for callback parameters that are passed to AddDiscoverySession
   // and RemoveDiscoverySession. This is used to queue incoming requests while
   // a call to BlueZ is pending.
   typedef std::tuple<device::BluetoothDiscoveryFilter*,
                      base::Closure,
                      DiscoverySessionErrorCallback> DiscoveryParamTuple;
   typedef std::queue<DiscoveryParamTuple> DiscoveryCallbackQueue;
 
   // Callback pair for the profile registration queue.
   typedef std::pair<base::Closure, ErrorCompletionCallback>
       RegisterProfileCompletionPair;
 
-  BluetoothAdapterChromeOS();
-  ~BluetoothAdapterChromeOS() override;
+  BluetoothAdapterBlueZ();
+  ~BluetoothAdapterBlueZ() override;
 
   // bluez::BluetoothAdapterClient::Observer override.
   void AdapterAdded(const dbus::ObjectPath& object_path) override;
   void AdapterRemoved(const dbus::ObjectPath& object_path) override;
   void AdapterPropertyChanged(const dbus::ObjectPath& object_path,
                               const std::string& property_name) override;
 
   // bluez::BluetoothDeviceClient::Observer override.
   void DeviceAdded(const dbus::ObjectPath& object_path) override;
   void DeviceRemoved(const dbus::ObjectPath& object_path) override;
@@ skipping 30 matching lines @@
   void OnRegisterAgent();
   void OnRegisterAgentError(const std::string& error_name,
                             const std::string& error_message);
 
   // Called by dbus:: on completion of the D-Bus method call to request that
   // the pairing agent be made the default.
   void OnRequestDefaultAgent();
   void OnRequestDefaultAgentError(const std::string& error_name,
                                   const std::string& error_message);
 
-  // Called by BluetoothAudioSinkChromeOS on completion of registering an audio
+  // Called by BluetoothAudioSinkBlueZ on completion of registering an audio
   // sink.
   void OnRegisterAudioSink(
       const device::BluetoothAdapter::AcquiredCallback& callback,
       const device::BluetoothAudioSink::ErrorCallback& error_callback,
       scoped_refptr<device::BluetoothAudioSink> audio_sink);
 
-  // Internal method to obtain a BluetoothPairingChromeOS object for the device
+  // Internal method to obtain a BluetoothPairingBlueZ object for the device
   // with path |object_path|. Returns the existing pairing object if the device
   // already has one (usually an outgoing connection in progress) or a new
   // pairing object with the default pairing delegate if not. If no default
   // pairing object exists, NULL will be returned.
-  BluetoothPairingChromeOS* GetPairing(const dbus::ObjectPath& object_path);
+  BluetoothPairingBlueZ* GetPairing(const dbus::ObjectPath& object_path);
 
   // Set the tracked adapter to the one in |object_path|, this object will
   // subsequently operate on that adapter until it is removed.
   void SetAdapter(const dbus::ObjectPath& object_path);
 
   // Set the adapter name to one chosen from the system information.
   void SetDefaultAdapterName();
 
   // Remove the currently tracked adapter. IsPresent() will return false after
   // this is called.
@@ skipping 55 matching lines @@
       const base::Closure& callback,
       const DiscoverySessionErrorCallback& error_callback);
   void OnSetDiscoveryFilterError(
       const base::Closure& callback,
       const DiscoverySessionErrorCallback& error_callback,
       const std::string& error_name,
       const std::string& error_message);
 
   // Called by dbus:: on completion of the D-Bus method to register a profile.
   void OnRegisterProfile(const device::BluetoothUUID& uuid,
-                         scoped_ptr<BluetoothAdapterProfileChromeOS> profile);
+                         scoped_ptr<BluetoothAdapterProfileBlueZ> profile);
 
   void SetProfileDelegate(
       const device::BluetoothUUID& uuid,
       const dbus::ObjectPath& device_path,
       bluez::BluetoothProfileServiceProvider::Delegate* delegate,
       const ProfileRegisteredCallback& success_callback,
       const ErrorCompletionCallback& error_callback);
   void OnRegisterProfileError(const device::BluetoothUUID& uuid,
                               const std::string& error_name,
                               const std::string& error_message);
 
-  // Called by BluetoothAdapterProfileChromeOS when no users of a profile
+  // Called by BluetoothAdapterProfileBlueZ when no users of a profile
   // remain.
   void RemoveProfile(const device::BluetoothUUID& uuid);
 
   // Processes the queued discovery requests. For each DiscoveryParamTuple in
   // the queue, this method will try to add a new discovery session. This method
   // is called whenever a pending D-Bus call to start or stop discovery has
   // ended (with either success or failure).
   void ProcessQueuedDiscoveryRequests();
 
   // Set in |Shutdown()|, makes IsPresent()| return false.
@@ skipping 21 matching lines @@
 
   // Instance of the D-Bus agent object used for pairing, initialized with
   // our own class as its delegate.
   scoped_ptr<bluez::BluetoothAgentServiceProvider> agent_;
 
   // UI thread task runner and socket thread object used to create sockets.
   scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
   scoped_refptr<device::BluetoothSocketThread> socket_thread_;
 
   // The profiles we have registered with the bluetooth daemon.
-  std::map<device::BluetoothUUID, BluetoothAdapterProfileChromeOS*> profiles_;
+  std::map<device::BluetoothUUID, BluetoothAdapterProfileBlueZ*> profiles_;
 
   // Queue of delegates waiting for a profile to register.
   std::map<device::BluetoothUUID, std::vector<RegisterProfileCompletionPair>*>
       profile_queues_;
 
   scoped_ptr<device::BluetoothDiscoveryFilter> current_filter_;
 
   // 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<BluetoothAdapterChromeOS> weak_ptr_factory_;
+  base::WeakPtrFactory<BluetoothAdapterBlueZ> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(BluetoothAdapterChromeOS);
+  DISALLOW_COPY_AND_ASSIGN(BluetoothAdapterBlueZ);
 };
 
-}  // namespace chromeos
+}  // namespace bluez
 
-#endif  // DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_CHROMEOS_H_
+#endif  // DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_BLUEZ_H_