Reland "Add Linux support for the Bluetooth API"

device/bluetooth/bluetooth_socket_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_SOCKET_CHROMEOS_H_
-#define DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_CHROMEOS_H_
+#ifndef DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_BLUEZ_H_
+#define DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_BLUEZ_H_
 
 #include <queue>
 #include <string>
 
+#include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_export.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "device/bluetooth/bluetooth_socket_net.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/dbus/bluetooth_profile_manager_client.h"
 #include "device/bluetooth/dbus/bluetooth_profile_service_provider.h"
 
 namespace dbus {
 class FileDescriptor;
 }  // namespace dbus
 
-namespace chromeos {
+namespace bluez {
 
-class BluetoothDeviceChromeOS;
-class BluetoothAdapterChromeOS;
-class BluetoothAdapterProfileChromeOS;
+class BluetoothDeviceBlueZ;
+class BluetoothAdapterBlueZ;
+class BluetoothAdapterProfileBlueZ;
 
-// The BluetoothSocketChromeOS class implements BluetoothSocket for the
+// The BluetoothSocketBlueZ class implements BluetoothSocket for the
 // Chrome OS platform.

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

Leftover "Chrome OS" reference.

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

Done.

 //
 // This class is not thread-safe, but is only called from the UI thread.
-class DEVICE_BLUETOOTH_EXPORT BluetoothSocketChromeOS
+class DEVICE_BLUETOOTH_EXPORT BluetoothSocketBlueZ
     : public device::BluetoothSocketNet,
       public device::BluetoothAdapter::Observer,
       public bluez::BluetoothProfileServiceProvider::Delegate {
  public:
-  enum SecurityLevel {
-    SECURITY_LEVEL_LOW,
-    SECURITY_LEVEL_MEDIUM
-  };
+  enum SecurityLevel { SECURITY_LEVEL_LOW, SECURITY_LEVEL_MEDIUM };
 
-  static scoped_refptr<BluetoothSocketChromeOS> CreateBluetoothSocket(
+  static scoped_refptr<BluetoothSocketBlueZ> CreateBluetoothSocket(
       scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
       scoped_refptr<device::BluetoothSocketThread> socket_thread);
 
   // Connects this socket to the service on |device| published as UUID |uuid|,
   // the underlying protocol and PSM or Channel is obtained through service
   // discovery. On a successful connection the socket properties will be updated
   // and |success_callback| called. On failure |error_callback| will be called
   // with a message explaining the cause of the failure.
-  virtual void Connect(const BluetoothDeviceChromeOS* device,
+  virtual void Connect(const BluetoothDeviceBlueZ* device,
                        const device::BluetoothUUID& uuid,
                        SecurityLevel security_level,
                        const base::Closure& success_callback,
                        const ErrorCompletionCallback& error_callback);
 
   // Listens using this socket using a service published on |adapter|. The
   // service is either RFCOMM or L2CAP depending on |socket_type| and published
   // as UUID |uuid|. The |service_options| argument is interpreted according to
   // |socket_type|. |success_callback| will be called if the service is
   // successfully registered, |error_callback| on failure with a message
   // explaining the cause.
   enum SocketType { kRfcomm, kL2cap };
   virtual void Listen(
       scoped_refptr<device::BluetoothAdapter> adapter,
       SocketType socket_type,
       const device::BluetoothUUID& uuid,
       const device::BluetoothAdapter::ServiceOptions& service_options,
       const base::Closure& success_callback,
       const ErrorCompletionCallback& error_callback);
 
   // BluetoothSocket:
   void Close() override;
   void Disconnect(const base::Closure& callback) override;
   void Accept(const AcceptCompletionCallback& success_callback,
               const ErrorCompletionCallback& error_callback) override;
 
  protected:
-  ~BluetoothSocketChromeOS() override;
+  ~BluetoothSocketBlueZ() override;
 
  private:
-  BluetoothSocketChromeOS(
+  BluetoothSocketBlueZ(
       scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
       scoped_refptr<device::BluetoothSocketThread> socket_thread);
 
   // Register the underlying profile client object with the Bluetooth Daemon.
-  void RegisterProfile(BluetoothAdapterChromeOS* adapter,
+  void RegisterProfile(BluetoothAdapterBlueZ* adapter,
                        const base::Closure& success_callback,
                        const ErrorCompletionCallback& error_callback);
   void OnRegisterProfile(const base::Closure& success_callback,
                          const ErrorCompletionCallback& error_callback,
-                         BluetoothAdapterProfileChromeOS* profile);
+                         BluetoothAdapterProfileBlueZ* profile);
   void OnRegisterProfileError(const ErrorCompletionCallback& error_callback,
                               const std::string& error_message);
 
   // Called by dbus:: on completion of the ConnectProfile() method.
   void OnConnectProfile(const base::Closure& success_callback);
   void OnConnectProfileError(const ErrorCompletionCallback& error_callback,
                              const std::string& error_name,
                              const std::string& error_message);
 
   // BluetoothAdapter::Observer:
   void AdapterPresentChanged(device::BluetoothAdapter* adapter,
                              bool present) override;
 
   // Called by dbus:: on completion of the RegisterProfile() method call
   // triggered as a result of the adapter becoming present again.
-  void OnInternalRegisterProfile(BluetoothAdapterProfileChromeOS* profile);
+  void OnInternalRegisterProfile(BluetoothAdapterProfileBlueZ* profile);
   void OnInternalRegisterProfileError(const std::string& error_message);
 
   // bluez::BluetoothProfileServiceProvider::Delegate:
   void Released() override;
   void NewConnection(
       const dbus::ObjectPath& device_path,
       scoped_ptr<dbus::FileDescriptor> fd,
       const bluez::BluetoothProfileServiceProvider::Delegate::Options& options,
       const ConfirmationCallback& callback) override;
   void RequestDisconnection(const dbus::ObjectPath& device_path,
@@ skipping 39 matching lines @@
   std::string device_address_;
   dbus::ObjectPath device_path_;
 
   // UUID of the profile being connected to, or listening on.
   device::BluetoothUUID uuid_;
 
   // Copy of the profile options used for registering the profile.
   scoped_ptr<bluez::BluetoothProfileManagerClient::Options> options_;
 
   // The profile registered with the adapter for this socket.
-  BluetoothAdapterProfileChromeOS* profile_;
+  BluetoothAdapterProfileBlueZ* profile_;
 
   // Pending request to an Accept() call.
   struct AcceptRequest {
     AcceptRequest();
     ~AcceptRequest();
 
     AcceptCompletionCallback success_callback;
     ErrorCompletionCallback error_callback;
   };
   scoped_ptr<AcceptRequest> accept_request_;
 
   // Queue of incoming connection requests.
   struct ConnectionRequest {
     ConnectionRequest();
     ~ConnectionRequest();
 
     dbus::ObjectPath device_path;
     scoped_ptr<dbus::FileDescriptor> fd;
     bluez::BluetoothProfileServiceProvider::Delegate::Options options;
     ConfirmationCallback callback;
     bool accepting;
     bool cancelled;
   };
-  std::queue<linked_ptr<ConnectionRequest> > connection_request_queue_;
+  std::queue<linked_ptr<ConnectionRequest>> connection_request_queue_;
 
-  DISALLOW_COPY_AND_ASSIGN(BluetoothSocketChromeOS);
+  DISALLOW_COPY_AND_ASSIGN(BluetoothSocketBlueZ);
 };
 
-}  // namespace chromeos
+}  // namespace bluez
 
-#endif  // DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_CHROMEOS_H_
+#endif  // DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_BLUEZ_H_