Manage profiles in BluetoothAdapter on ChromeOS

device/bluetooth/bluetooth_socket_chromeos.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_
 
 #include <queue>
 #include <string>
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "chromeos/chromeos_export.h"
 #include "chromeos/dbus/bluetooth_profile_manager_client.h"
 #include "chromeos/dbus/bluetooth_profile_service_provider.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "device/bluetooth/bluetooth_socket_net.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace dbus {
 class FileDescriptor;
 }  // namespace dbus
 
 namespace chromeos {
 
 class BluetoothDeviceChromeOS;
+class BluetoothAdapterChromeOS;
+class BluetoothAdapterProfileChromeOS;
 
 // The BluetoothSocketChromeOS class implements BluetoothSocket for the
 // Chrome OS platform.
 class CHROMEOS_EXPORT BluetoothSocketChromeOS
     : public device::BluetoothSocketNet,
       public device::BluetoothAdapter::Observer,
       public BluetoothProfileServiceProvider::Delegate {
  public:
   enum SecurityLevel {
     SECURITY_LEVEL_LOW,
@@ skipping 29 matching lines @@
       const device::BluetoothAdapter::ServiceOptions& service_options,
       const base::Closure& success_callback,
       const ErrorCompletionCallback& error_callback);
 
   // BluetoothSocket:
   virtual void Close() override;
   virtual void Disconnect(const base::Closure& callback) override;
   virtual void Accept(const AcceptCompletionCallback& success_callback,
                       const ErrorCompletionCallback& error_callback) override;
 
-  // Returns the object path of the socket.
-  const dbus::ObjectPath& object_path() const { return object_path_; }
-
  protected:
   virtual ~BluetoothSocketChromeOS();
 
  private:
   BluetoothSocketChromeOS(
       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(const base::Closure& success_callback,
+  void RegisterProfile(BluetoothAdapterChromeOS* adapter,
+                       const base::Closure& success_callback,
                        const ErrorCompletionCallback& error_callback);
   void OnRegisterProfile(const base::Closure& success_callback,
-                         const ErrorCompletionCallback& error_callback);
+                         const ErrorCompletionCallback& error_callback,
+                         BluetoothAdapterProfileChromeOS* profile);
   void OnRegisterProfileError(const ErrorCompletionCallback& error_callback,
-                              const std::string& error_name,
                               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:
   virtual 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();
-  void OnInternalRegisterProfileError(const std::string& error_name,
-                                      const std::string& error_message);
+  void OnInternalRegisterProfile(BluetoothAdapterProfileChromeOS* profile);
+  void OnInternalRegisterProfileError(const std::string& error_message);
 
   // BluetoothProfileServiceProvider::Delegate:
   virtual void Released() override;
   virtual void NewConnection(
       const dbus::ObjectPath& device_path,
       scoped_ptr<dbus::FileDescriptor> fd,
       const BluetoothProfileServiceProvider::Delegate::Options& options,
       const ConfirmationCallback& callback) override;
   virtual void RequestDisconnection(
       const dbus::ObjectPath& device_path,
@@ skipping 22 matching lines @@
   // complete calls |callback| on the UI thread with an appropriate argument
   // indicating success or failure.
   void DoConnect(scoped_ptr<dbus::FileDescriptor> fd,
                  const ConfirmationCallback& callback);
 
   // Method run to clean-up a listening socket.
   void DoCloseListening();
 
   // Unregister the underlying profile client object from the Bluetooth Daemon.
   void UnregisterProfile();
-  void OnUnregisterProfile(const dbus::ObjectPath& object_path);
-  void OnUnregisterProfileError(const dbus::ObjectPath& object_path,
-                                const std::string& error_name,
-                                const std::string& error_message);
 
-  // Adapter the profile is registered against; this is only present when the
-  // socket is listening.
+  // Releases the profile after the delegate is gone.
+  void ReleaseProfile();
+
+  // Adapter the profile is registered against
   scoped_refptr<device::BluetoothAdapter> adapter_;
 
   // Address and D-Bus object path of the device being connected to, empty and
   // ignored if the socket is listening.
   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<BluetoothProfileManagerClient::Options> options_;
 
-  // Object path of the local profile D-Bus object.
-  dbus::ObjectPath object_path_;
-
-  // Local profile D-Bus object used for receiving profile delegate methods
-  // from BlueZ.
-  scoped_ptr<BluetoothProfileServiceProvider> profile_;
+  // The profile registered with the adapter for this socket.
+  BluetoothAdapterProfileChromeOS* profile_;
 
   // Pending request to an Accept() call.
   struct AcceptRequest {
     AcceptRequest();
     ~AcceptRequest();
 
     AcceptCompletionCallback success_callback;
     ErrorCompletionCallback error_callback;
   };
   scoped_ptr<AcceptRequest> accept_request_;
@@ skipping 11 matching lines @@
     bool cancelled;
   };
   std::queue<linked_ptr<ConnectionRequest> > connection_request_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothSocketChromeOS);
 };
 
 }  // namespace chromeos
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_CHROMEOS_H_