Add support for creating bluetooth RFCOMM sockets.

chrome/browser/chromeos/bluetooth/bluetooth_device.cc

 // 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.
 
 #include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_service_record.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_socket.h"
 #include "chrome/browser/chromeos/dbus/introspect_util.h"
 #include "chromeos/dbus/bluetooth_adapter_client.h"
 #include "chromeos/dbus/bluetooth_agent_service_provider.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "chromeos/dbus/bluetooth_input_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/introspectable_client.h"
 #include "dbus/bus.h"
 #include "dbus/object_path.h"
 #include "grit/generated_resources.h"
@@ skipping 164 matching lines @@
     const dbus::ObjectPath& object_path,
     const BluetoothDeviceClient::ServiceMap& service_map,
     bool success) {
   if (!success) {
     callback.Run(false);
     return;
   }
 
   for (BluetoothDeviceClient::ServiceMap::const_iterator i =
       service_map.begin(); i != service_map.end(); ++i) {
-    BluetoothServiceRecord service_record(i->second);
+    BluetoothServiceRecord service_record(address(), i->second);
     if (service_record.name() == name) {
       callback.Run(true);
       return;
     }
   }
 
   callback.Run(false);
 }
 
 void BluetoothDevice::ProvidesServiceWithName(const std::string& name,
@@ skipping 232 matching lines @@
 
 void BluetoothDevice::Forget(ErrorCallback error_callback) {
   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
       RemoveDevice(adapter_->object_path_,
                    object_path_,
                    base::Bind(&BluetoothDevice::ForgetCallback,
                               weak_ptr_factory_.GetWeakPtr(),
                               error_callback));
 }
 
+
+void BluetoothDevice::ConnectToMatchingService(
+    const std::string& service_uuid,
+    SocketCallback callback,
+    const dbus::ObjectPath& object_path,
+    const BluetoothDeviceClient::ServiceMap& service_map,
+    bool success) {
+  if (success) {
+    // If multiple service records are found, use the first one that works.
+    for (BluetoothDeviceClient::ServiceMap::const_iterator i =
+        service_map.begin(); i != service_map.end(); ++i) {
+      BluetoothServiceRecord service_record(address(), i->second);
+      scoped_refptr<BluetoothSocket> socket(
+          BluetoothSocket::CreateBluetoothSocket(service_record));
+      if (socket.get() != NULL) {
+        callback.Run(socket);
+        break;
+      }
+    }
+  }
+  callback.Run(NULL);
+}
+
+void BluetoothDevice::ConnectToService(const std::string& service_uuid,
+                                       SocketCallback callback) {
+  // quick sanity check
+  if (!ProvidesServiceWithUUID(service_uuid)) {
+    callback.Run(NULL);
+    return;
+  }
+
+  DBusThreadManager::Get()->GetBluetoothDeviceClient()->
+      DiscoverServices(
+          object_path_,
+          service_uuid,
+          base::Bind(&BluetoothDevice::ConnectToMatchingService,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     service_uuid,
+                     callback));
+}
+
 void BluetoothDevice::ForgetCallback(ErrorCallback error_callback,
                                      const dbus::ObjectPath& adapter_path,
                                      bool success) {
   // It's quite normal that this path never gets called on success; we use a
   // weak pointer, and bluetoothd might send the DeviceRemoved signal before
   // the method reply, in which case this object is deleted and the
   // callback never takes place. Therefore don't do anything here for the
   // success case.
   if (!success) {
     LOG(WARNING) << "Forget failed: " << address_;
@@ skipping 118 matching lines @@
 // static
 BluetoothDevice* BluetoothDevice::CreateUnbound(
     BluetoothAdapter* adapter,
     const BluetoothDeviceClient::Properties* properties) {
   BluetoothDevice* device = new BluetoothDevice(adapter);
   device->Update(properties, false);
   return device;
 }
 
 }  // namespace chromeos