Refactor DBusThreadManager to split away BT clients.

device/bluetooth/bluetooth_socket_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_socket_chromeos.h"
 
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
-#include "chromeos/dbus/bluetooth_device_client.h"
-#include "chromeos/dbus/bluetooth_profile_manager_client.h"
-#include "chromeos/dbus/bluetooth_profile_service_provider.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
 #include "dbus/bus.h"
 #include "dbus/file_descriptor.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
 #include "device/bluetooth/bluetooth_adapter_profile_chromeos.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_chromeos.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "device/bluetooth/bluetooth_socket_net.h"
 #include "device/bluetooth/bluetooth_socket_thread.h"
+#include "device/bluetooth/dbus/bluetooth_device_client.h"
+#include "device/bluetooth/dbus/bluetooth_profile_manager_client.h"
+#include "device/bluetooth/dbus/bluetooth_profile_service_provider.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothSocketThread;
 using device::BluetoothUUID;
 
 namespace {
@@ skipping 52 matching lines @@
   DCHECK(!profile_);
 
   if (!uuid.IsValid()) {
     error_callback.Run(kInvalidUUID);
     return;
   }
 
   device_address_ = device->GetAddress();
   device_path_ = device->object_path();
   uuid_ = uuid;
-  options_.reset(new BluetoothProfileManagerClient::Options());
+  options_.reset(new bluez::BluetoothProfileManagerClient::Options());
   if (security_level == SECURITY_LEVEL_LOW)
     options_->require_authentication.reset(new bool(false));
 
   adapter_ = device->adapter();
 
   RegisterProfile(device->adapter(), success_callback, error_callback);
 }
 
 void BluetoothSocketChromeOS::Listen(
     scoped_refptr<BluetoothAdapter> adapter,
     SocketType socket_type,
     const BluetoothUUID& uuid,
     const BluetoothAdapter::ServiceOptions& service_options,
     const base::Closure& success_callback,
     const ErrorCompletionCallback& error_callback) {
   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
   DCHECK(!profile_);
 
   if (!uuid.IsValid()) {
     error_callback.Run(kInvalidUUID);
     return;
   }
 
   adapter_ = adapter;
   adapter_->AddObserver(this);
 
   uuid_ = uuid;
-  options_.reset(new BluetoothProfileManagerClient::Options());
+  options_.reset(new bluez::BluetoothProfileManagerClient::Options());
   if (service_options.name)
     options_->name.reset(new std::string(*service_options.name));
 
   switch (socket_type) {
     case kRfcomm:
       options_->channel.reset(
           new uint16(service_options.channel ? *service_options.channel : 0));
       break;
     case kL2cap:
       options_->psm.reset(
           new uint16(service_options.psm ? *service_options.psm : 0));
       break;
     default:
       NOTREACHED();
   }
 
   RegisterProfile(static_cast<BluetoothAdapterChromeOS*>(adapter.get()),
                   success_callback, error_callback);
 }
 
 void BluetoothSocketChromeOS::Close() {
   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 
   if (profile_)
     UnregisterProfile();
 
   // In the case below, where an asynchronous task gets posted on the socket
   // thread in BluetoothSocketNet::Close, a reference will be held to this
   // socket by the callback. This may cause the BluetoothAdapter to outlive
-  // DBusThreadManager during shutdown if that callback executes too late.
+  // BluezDBusManager during shutdown if that callback executes too late.
   if (adapter_.get()) {
     adapter_->RemoveObserver(this);
     adapter_ = nullptr;
   }
 
   if (!device_path_.value().empty()) {
     BluetoothSocketNet::Close();
   } else {
     DoCloseListening();
   }
@@ skipping 78 matching lines @@
 
   if (device_path_.value().empty()) {
     VLOG(1) << uuid_.canonical_value() << ": Profile registered.";
     success_callback.Run();
     return;
   }
 
   VLOG(1) << uuid_.canonical_value() << ": Got profile, connecting to "
           << device_path_.value();
 
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
+  bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
       device_path_, uuid_.canonical_value(),
       base::Bind(&BluetoothSocketChromeOS::OnConnectProfile, this,
                  success_callback),
       base::Bind(&BluetoothSocketChromeOS::OnConnectProfileError, this,
                  error_callback));
 }
 
 void BluetoothSocketChromeOS::OnRegisterProfileError(
     const ErrorCompletionCallback& error_callback,
     const std::string& error_message) {
@@ skipping 70 matching lines @@
 void BluetoothSocketChromeOS::Released() {
   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
   DCHECK(profile_);
 
   VLOG(1) << profile_->object_path().value() << ": Release";
 }
 
 void BluetoothSocketChromeOS::NewConnection(
     const dbus::ObjectPath& device_path,
     scoped_ptr<dbus::FileDescriptor> fd,
-    const BluetoothProfileServiceProvider::Delegate::Options& options,
+    const bluez::BluetoothProfileServiceProvider::Delegate::Options& options,
     const ConfirmationCallback& callback) {
   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 
   VLOG(1) << uuid_.canonical_value()
           << ": New connection from device: " << device_path.value();
 
   if (!device_path_.value().empty()) {
     DCHECK(device_path_ == device_path);
 
     socket_thread()->task_runner()->PostTask(
@@ skipping 84 matching lines @@
           request->options,
           base::Bind(&BluetoothSocketChromeOS::OnNewConnection,
                      this,
                      client_socket,
                      request->callback)));
 }
 
 void BluetoothSocketChromeOS::DoNewConnection(
     const dbus::ObjectPath& device_path,
     scoped_ptr<dbus::FileDescriptor> fd,
-    const BluetoothProfileServiceProvider::Delegate::Options& options,
+    const bluez::BluetoothProfileServiceProvider::Delegate::Options& options,
     const ConfirmationCallback& callback) {
   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
   base::ThreadRestrictions::AssertIOAllowed();
   fd->CheckValidity();
 
   VLOG(1) << uuid_.canonical_value() << ": Validity check complete.";
   if (!fd->is_valid()) {
     LOG(WARNING) << uuid_.canonical_value() << " :" << fd->value()
                  << ": Invalid file descriptor received from Bluetooth Daemon.";
     ui_task_runner()->PostTask(FROM_HERE,
@@ skipping 76 matching lines @@
   DCHECK(profile_);
 
   VLOG(1) << profile_->object_path().value() << ": Release profile";
 
   static_cast<BluetoothAdapterChromeOS*>(adapter_.get())
       ->ReleaseProfile(device_path_, profile_);
   profile_ = nullptr;
 }
 
 }  // namespace chromeos