Add support for creating bluetooth RFCOMM sockets.

chrome/browser/chromeos/bluetooth/bluetooth_device.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 CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_H_
 #define CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/string16.h"
 #include "chromeos/dbus/bluetooth_agent_service_provider.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "dbus/object_path.h"
 
 namespace chromeos {
 
 class BluetoothAdapter;
+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.
 //
 // 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.
 //
@@ skipping 209 matching lines @@
   // If the request fails, |error_callback| will be called.
   void Disconnect(ErrorCallback error_callback);
 
   // 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.
   void Forget(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.
+  // 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,
+      SocketCallback callback);
+
  private:
   friend class BluetoothAdapter;
 
   explicit BluetoothDevice(BluetoothAdapter* 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);
 
   // Updates device information from the properties in |properties|, device
@@ skipping 58 matching lines @@
   // called with true if a service with name matching |name| is discovered, or
   // with false otherwise.  The rest of the parameters are as documented for a
   // BluetoothDeviceClient::ServicesCallback.
   void SearchServicesForNameCallback(
       const std::string& name,
       ProvidesServiceCallback callback,
       const dbus::ObjectPath& object_path,
       const BluetoothDeviceClient::ServiceMap& service_map,
       bool success);
 
+  // Opens a socket to this device on the provided |channel|.
+  scoped_refptr<BluetoothSocket> OpenSocket(const std::string& service_uuid,
+      uint8_t channel);

[keybuk, 2012/04/19 23:30:11]

OpenSocket is gone now, right?

[bryeung, 2012/04/20 00:17:56]

Oops!  Good catch.

+
+  // Called by BluetoothDeviceClient when a call to DiscoverServices() that was
+  // initated from ConnectToService completes.  The |callback| is called with
+  // true iff a connection was successfully established.  The rest of the
+  // parameters are as documented for a BluetoothDeviceClient::ServicesCallback.
+  void ConnectToMatchingService(
+      const std::string& service_uuid,
+      SocketCallback callback,
+      const dbus::ObjectPath& object_path,
+      const BluetoothDeviceClient::ServiceMap& service_map,
+      bool success);
+
   // BluetoothDeviceClient::Observer override.
   //
   // Called when the device with object path |object_path| is about
   // to be disconnected, giving a chance for application layers to
   // shut down cleanly.
   virtual void DisconnectRequested(
       const dbus::ObjectPath& object_path) OVERRIDE;
 
   // BluetoothAgentServiceProvider::Delegate override.
   //
@@ skipping 160 matching lines @@
   PinCodeCallback pincode_callback_;
   PasskeyCallback passkey_callback_;
   ConfirmationCallback confirmation_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothDevice);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_H_