Reimplement BluetoothSocketChromeOS

device/bluetooth/bluetooth_profile_chromeos.cc

 // 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.
 
 #include "device/bluetooth/bluetooth_profile_chromeos.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #include "dbus/bus.h"
 #include "dbus/file_descriptor.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_chromeos.h"
 #include "device/bluetooth/bluetooth_profile.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "device/bluetooth/bluetooth_socket_chromeos.h"
+#include "device/bluetooth/bluetooth_socket_thread.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothDevice;
 using device::BluetoothProfile;
 using device::BluetoothSocket;
 
 namespace {
 
 // Check the validity of a file descriptor received from D-Bus. Must be run
 // on a thread where i/o is permitted.
 scoped_ptr<dbus::FileDescriptor> CheckValidity(
     scoped_ptr<dbus::FileDescriptor> fd) {
   base::ThreadRestrictions::AssertIOAllowed();
   fd->CheckValidity();
   return fd.Pass();
 }
 
 }  // namespace
 
 
 namespace chromeos {
 
-BluetoothProfileChromeOS::BluetoothProfileChromeOS()
-    : weak_ptr_factory_(this) {
+BluetoothProfileChromeOS::BluetoothProfileChromeOS(
+    scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+    scoped_refptr<device::BluetoothSocketThread> socket_thread)
+    : ui_task_runner_(ui_task_runner),
+      socket_thread_(socket_thread),
+      weak_ptr_factory_(this) {
 }
 
 BluetoothProfileChromeOS::~BluetoothProfileChromeOS() {
   DCHECK(object_path_.value().empty());
   DCHECK(profile_.get() == NULL);
 
   if (adapter_.get()) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
@@ skipping 205 matching lines @@
       const dbus::ObjectPath& device_path,
       const BluetoothProfileServiceProvider::Delegate::Options& options,
       const ConfirmationCallback& callback,
       scoped_ptr<dbus::FileDescriptor> fd) {
   VLOG(1) << object_path_.value() << ": Validity check complete";
   if (!fd->is_valid()) {
     callback.Run(REJECTED);
     return;
   }
 
-  callback.Run(SUCCESS);
+  scoped_refptr<BluetoothSocketChromeOS> socket =
+      BluetoothSocketChromeOS::CreateBluetoothSocket(
+          ui_task_runner_,
+          socket_thread_,
+          NULL,
+          net::NetLog::Source());
+  socket->Connect(fd.Pass(),
+                  base::Bind(&BluetoothProfileChromeOS::OnConnect,
+                             weak_ptr_factory_.GetWeakPtr(),
+                             device_path,
+                             socket,
+                             callback),
+                  base::Bind(&BluetoothProfileChromeOS::OnConnectError,
+                             weak_ptr_factory_.GetWeakPtr(),
+                             callback));
+}
+
+void BluetoothProfileChromeOS::OnConnect(
+    const dbus::ObjectPath& device_path,
+    scoped_refptr<BluetoothSocketChromeOS> socket,
+    const ConfirmationCallback& callback) {
+  VLOG(1) << object_path_.value() << ": Profile connection complete";
 
   BluetoothDeviceChromeOS* device =
       static_cast<BluetoothAdapterChromeOS*>(adapter_.get())->
           GetDeviceWithPath(device_path);
   DCHECK(device);
 
-  scoped_refptr<BluetoothSocket> socket((
-      BluetoothSocketChromeOS::Create(fd.get())));
   connection_callback_.Run(device, socket);
 }
 
+void BluetoothProfileChromeOS::OnConnectError(
+    const ConfirmationCallback& callback,
+    const std::string& error_message) {
+  VLOG(1) << object_path_.value() << ": Profile connection failed: "
+          << error_message;
+
+  callback.Run(REJECTED);
+}
+
 }  // namespace chromeos