Refactor DBusThreadManager to split away BT clients.

device/bluetooth/bluetooth_adapter_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_adapter_chromeos.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
-#include "chromeos/dbus/bluetooth_adapter_client.h"
-#include "chromeos/dbus/bluetooth_agent_manager_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/system/devicetype.h"
 #include "device/bluetooth/bluetooth_adapter_profile_chromeos.h"
 #include "device/bluetooth/bluetooth_advertisement_chromeos.h"
 #include "device/bluetooth/bluetooth_audio_sink_chromeos.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_chromeos.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_pairing_chromeos.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_chromeos.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor_chromeos.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_chromeos.h"
 #include "device/bluetooth/bluetooth_socket_chromeos.h"
 #include "device/bluetooth/bluetooth_socket_thread.h"
 #include "device/bluetooth/bluetooth_uuid.h"
+#include "device/bluetooth/dbus/bluetooth_adapter_client.h"
+#include "device/bluetooth/dbus/bluetooth_agent_manager_client.h"
+#include "device/bluetooth/dbus/bluetooth_agent_service_provider.h"
+#include "device/bluetooth/dbus/bluetooth_device_client.h"
+#include "device/bluetooth/dbus/bluetooth_input_client.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAudioSink;
 using device::BluetoothDevice;
 using device::BluetoothDiscoveryFilter;
 using device::BluetoothSocket;
 using device::BluetoothUUID;
 using device::UMABluetoothDiscoverySessionOutcome;
 
 namespace {
 
 // The agent path is relatively meaningless since BlueZ only permits one to
 // exist per D-Bus connection, it just has to be unique within Chromium.
 const char kAgentPath[] = "/org/chromium/bluetooth_agent";
 
 void OnUnregisterAgentError(const std::string& error_name,
                             const std::string& error_message) {
   // It's okay if the agent didn't exist, it means we never saw an adapter.
   if (error_name == bluetooth_agent_manager::kErrorDoesNotExist)
     return;
 
   LOG(WARNING) << "Failed to unregister pairing agent: "
                << error_name << ": " << error_message;
 }
 
 UMABluetoothDiscoverySessionOutcome TranslateDiscoveryErrorToUMA(
     const std::string& error_name) {
-  if (error_name == chromeos::BluetoothAdapterClient::kUnknownAdapterError) {
+  if (error_name == bluez::BluetoothAdapterClient::kUnknownAdapterError) {
     return UMABluetoothDiscoverySessionOutcome::CHROMEOS_DBUS_UNKNOWN_ADAPTER;
-  } else if (error_name == chromeos::BluetoothAdapterClient::kNoResponseError) {
+  } else if (error_name == bluez::BluetoothAdapterClient::kNoResponseError) {
     return UMABluetoothDiscoverySessionOutcome::CHROMEOS_DBUS_NO_RESPONSE;
   } else if (error_name == bluetooth_device::kErrorInProgress) {
     return UMABluetoothDiscoverySessionOutcome::CHROMEOS_DBUS_IN_PROGRESS;
   } else if (error_name == bluetooth_device::kErrorNotReady) {
     return UMABluetoothDiscoverySessionOutcome::CHROMEOS_DBUS_NOT_READY;
   } else if (error_name == bluetooth_device::kErrorFailed) {
     return UMABluetoothDiscoverySessionOutcome::FAILED;
   } else {
     LOG(WARNING) << "Can't histogram DBus error " << error_name;
     return UMABluetoothDiscoverySessionOutcome::UNKNOWN;
@@ skipping 16 matching lines @@
 
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapterChromeOS::CreateAdapter() {
   BluetoothAdapterChromeOS* adapter = new BluetoothAdapterChromeOS();
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 void BluetoothAdapterChromeOS::Shutdown() {
   if (dbus_is_shutdown_)
     return;
-  DCHECK(DBusThreadManager::IsInitialized())
+  DCHECK(bluez::BluezDBusManager::IsInitialized())
       << "Call BluetoothAdapterFactory::Shutdown() before "
-         "DBusThreadManager::Shutdown().";
+         "BluezDBusManager::Shutdown().";
 
   if (IsPresent())
     RemoveAdapter();  // Also deletes devices_.
   DCHECK(devices_.empty());
   // profiles_ is empty because all BluetoothSockets have been notified
   // that this adapter is disappearing.
   DCHECK(profiles_.empty());
 
   for (auto& it : profile_queues_)
     delete it.second;
   profile_queues_.clear();
 
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->RemoveObserver(this);
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->RemoveObserver(this);
-  DBusThreadManager::Get()->GetBluetoothInputClient()->RemoveObserver(this);
+  bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->RemoveObserver(
+      this);
+  bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->RemoveObserver(
+      this);
+  bluez::BluezDBusManager::Get()->GetBluetoothInputClient()->RemoveObserver(
+      this);
 
   VLOG(1) << "Unregistering pairing agent";
-  DBusThreadManager::Get()->GetBluetoothAgentManagerClient()->UnregisterAgent(
-      dbus::ObjectPath(kAgentPath), base::Bind(&base::DoNothing),
-      base::Bind(&OnUnregisterAgentError));
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothAgentManagerClient()
+      ->UnregisterAgent(dbus::ObjectPath(kAgentPath),
+                        base::Bind(&base::DoNothing),
+                        base::Bind(&OnUnregisterAgentError));
 
   agent_.reset();
   dbus_is_shutdown_ = true;
 }
 
 BluetoothAdapterChromeOS::BluetoothAdapterChromeOS()
     : dbus_is_shutdown_(false),
       num_discovery_sessions_(0),
       discovery_request_pending_(false),
       weak_ptr_factory_(this) {
   ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   socket_thread_ = device::BluetoothSocketThread::Get();
 
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->AddObserver(this);
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->AddObserver(this);
-  DBusThreadManager::Get()->GetBluetoothInputClient()->AddObserver(this);
+  bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->AddObserver(
+      this);
+  bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->AddObserver(this);
+  bluez::BluezDBusManager::Get()->GetBluetoothInputClient()->AddObserver(this);
 
   // Register the pairing agent.
-  dbus::Bus* system_bus = DBusThreadManager::Get()->GetSystemBus();
-  agent_.reset(BluetoothAgentServiceProvider::Create(
+  dbus::Bus* system_bus = bluez::BluezDBusManager::Get()->GetSystemBus();
+  agent_.reset(bluez::BluetoothAgentServiceProvider::Create(
       system_bus, dbus::ObjectPath(kAgentPath), this));
   DCHECK(agent_.get());
 
-  std::vector<dbus::ObjectPath> object_paths =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->GetAdapters();
+  std::vector<dbus::ObjectPath> object_paths = bluez::BluezDBusManager::Get()
+                                                   ->GetBluetoothAdapterClient()
+                                                   ->GetAdapters();
 
   if (!object_paths.empty()) {
     VLOG(1) << object_paths.size() << " Bluetooth adapter(s) available.";
     SetAdapter(object_paths[0]);
   }
 }
 
 BluetoothAdapterChromeOS::~BluetoothAdapterChromeOS() {
   Shutdown();
 }
 
 std::string BluetoothAdapterChromeOS::GetAddress() const {
   if (!IsPresent())
     return std::string();
 
-  BluetoothAdapterClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothAdapterClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothAdapterClient()
+          ->GetProperties(object_path_);
   DCHECK(properties);
 
   return BluetoothDevice::CanonicalizeAddress(properties->address.value());
 }
 
 std::string BluetoothAdapterChromeOS::GetName() const {
   if (!IsPresent())
     return std::string();
 
-  BluetoothAdapterClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothAdapterClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothAdapterClient()
+          ->GetProperties(object_path_);
   DCHECK(properties);
 
   return properties->alias.value();
 }
 
 void BluetoothAdapterChromeOS::SetName(const std::string& name,
                                        const base::Closure& callback,
                                        const ErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run();
     return;
   }
 
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-      GetProperties(object_path_)->alias.Set(
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothAdapterClient()
+      ->GetProperties(object_path_)
+      ->alias.Set(
           name,
           base::Bind(&BluetoothAdapterChromeOS::OnPropertyChangeCompleted,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback,
-                     error_callback));
+                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 bool BluetoothAdapterChromeOS::IsInitialized() const {
   return true;
 }
 
 bool BluetoothAdapterChromeOS::IsPresent() const {
   return !dbus_is_shutdown_ && !object_path_.value().empty();
 }
 
 bool BluetoothAdapterChromeOS::IsPowered() const {
   if (!IsPresent())
     return false;
 
-  BluetoothAdapterClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothAdapterClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothAdapterClient()
+          ->GetProperties(object_path_);
 
   return properties->powered.value();
 }
 
 void BluetoothAdapterChromeOS::SetPowered(
     bool powered,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run();
     return;
   }
 
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-      GetProperties(object_path_)->powered.Set(
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothAdapterClient()
+      ->GetProperties(object_path_)
+      ->powered.Set(
           powered,
           base::Bind(&BluetoothAdapterChromeOS::OnPropertyChangeCompleted,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback,
-                     error_callback));
+                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 bool BluetoothAdapterChromeOS::IsDiscoverable() const {
   if (!IsPresent())
     return false;
 
-  BluetoothAdapterClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothAdapterClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothAdapterClient()
+          ->GetProperties(object_path_);
 
   return properties->discoverable.value();
 }
 
 void BluetoothAdapterChromeOS::SetDiscoverable(
     bool discoverable,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run();
     return;
   }
 
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-      GetProperties(object_path_)->discoverable.Set(
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothAdapterClient()
+      ->GetProperties(object_path_)
+      ->discoverable.Set(
           discoverable,
           base::Bind(&BluetoothAdapterChromeOS::OnSetDiscoverable,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback,
-                     error_callback));
+                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 bool BluetoothAdapterChromeOS::IsDiscovering() const {
   if (!IsPresent())
     return false;
 
-  BluetoothAdapterClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothAdapterClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothAdapterClient()
+          ->GetProperties(object_path_);
 
   return properties->discovering.value();
 }
 
 void BluetoothAdapterChromeOS::CreateRfcommService(
     const BluetoothUUID& uuid,
     const ServiceOptions& options,
     const CreateServiceCallback& callback,
     const CreateServiceErrorCallback& error_callback) {
   DCHECK(!dbus_is_shutdown_);
@@ skipping 84 matching lines @@
     RemoveAdapter();
 }
 
 void BluetoothAdapterChromeOS::AdapterPropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   if (object_path != object_path_)
     return;
   DCHECK(IsPresent());
 
-  BluetoothAdapterClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothAdapterClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothAdapterClient()
+          ->GetProperties(object_path_);
 
   if (property_name == properties->powered.name()) {
     PoweredChanged(properties->powered.value());
   } else if (property_name == properties->discoverable.name()) {
     DiscoverableChanged(properties->discoverable.value());
   } else if (property_name == properties->discovering.name()) {
     DiscoveringChanged(properties->discovering.value());
   }
 }
 
 void BluetoothAdapterChromeOS::DeviceAdded(
   const dbus::ObjectPath& object_path) {
-  DCHECK(DBusThreadManager::Get());
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path);
+  DCHECK(bluez::BluezDBusManager::Get());
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path);
   if (!properties || properties->adapter.value() != object_path_)
     return;
   DCHECK(IsPresent());
 
   BluetoothDeviceChromeOS* device_chromeos =
       new BluetoothDeviceChromeOS(this,
                                   object_path,
                                   ui_task_runner_,
                                   socket_thread_);
   DCHECK(devices_.find(device_chromeos->GetAddress()) == devices_.end());
@@ skipping 21 matching lines @@
   }
 }
 
 void BluetoothAdapterChromeOS::DevicePropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   BluetoothDeviceChromeOS* device_chromeos = GetDeviceWithPath(object_path);
   if (!device_chromeos)
     return;
 
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path);
 
   if (property_name == properties->bluetooth_class.name() ||
       property_name == properties->address.name() ||
       property_name == properties->alias.name() ||
       property_name == properties->paired.name() ||
       property_name == properties->trusted.name() ||
       property_name == properties->connected.name() ||
       property_name == properties->uuids.name() ||
       property_name == properties->rssi.name() ||
       property_name == properties->tx_power.name()) {
@@ skipping 28 matching lines @@
   }
 }
 
 void BluetoothAdapterChromeOS::InputPropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   BluetoothDeviceChromeOS* device_chromeos = GetDeviceWithPath(object_path);
   if (!device_chromeos)
     return;
 
-  BluetoothInputClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothInputClient()->
-          GetProperties(object_path);
+  bluez::BluetoothInputClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothInputClient()->GetProperties(
+          object_path);
 
   // Properties structure can be removed, which triggers a change in the
   // BluetoothDevice::IsConnectable() property, as does a change in the
   // actual reconnect_mode property.
   if (!properties || property_name == properties->reconnect_mode.name()) {
     NotifyDeviceChanged(device_chromeos);
   }
 }
 
 void BluetoothAdapterChromeOS::Released() {
@@ skipping 136 matching lines @@
 
 void BluetoothAdapterChromeOS::Cancel() {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
   VLOG(1) << "Cancel";
 }
 
 void BluetoothAdapterChromeOS::OnRegisterAgent() {
   VLOG(1) << "Pairing agent registered, requesting to be made default";
 
-  DBusThreadManager::Get()->GetBluetoothAgentManagerClient()->
-      RequestDefaultAgent(
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothAgentManagerClient()
+      ->RequestDefaultAgent(
           dbus::ObjectPath(kAgentPath),
           base::Bind(&BluetoothAdapterChromeOS::OnRequestDefaultAgent,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&BluetoothAdapterChromeOS::OnRequestDefaultAgentError,
                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothAdapterChromeOS::OnRegisterAgentError(
     const std::string& error_name,
     const std::string& error_message) {
@@ skipping 70 matching lines @@
 }
 
 void BluetoothAdapterChromeOS::SetAdapter(const dbus::ObjectPath& object_path) {
   DCHECK(!IsPresent());
   DCHECK(!dbus_is_shutdown_);
   object_path_ = object_path;
 
   VLOG(1) << object_path_.value() << ": using adapter.";
 
   VLOG(1) << "Registering pairing agent";
-  DBusThreadManager::Get()->GetBluetoothAgentManagerClient()->
-      RegisterAgent(
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothAgentManagerClient()
+      ->RegisterAgent(
           dbus::ObjectPath(kAgentPath),
           bluetooth_agent_manager::kKeyboardDisplayCapability,
           base::Bind(&BluetoothAdapterChromeOS::OnRegisterAgent,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&BluetoothAdapterChromeOS::OnRegisterAgentError,
                      weak_ptr_factory_.GetWeakPtr()));
 
   SetDefaultAdapterName();
 
-  BluetoothAdapterClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothAdapterClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothAdapterClient()
+          ->GetProperties(object_path_);
 
   PresentChanged(true);
 
   if (properties->powered.value())
     PoweredChanged(true);
   if (properties->discoverable.value())
     DiscoverableChanged(true);
   if (properties->discovering.value())
     DiscoveringChanged(true);
 
   std::vector<dbus::ObjectPath> device_paths =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetDevicesForAdapter(object_path_);
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothDeviceClient()
+          ->GetDevicesForAdapter(object_path_);
 
   for (std::vector<dbus::ObjectPath>::iterator iter = device_paths.begin();
        iter != device_paths.end(); ++iter) {
     DeviceAdded(*iter);
   }
 }
 
 void BluetoothAdapterChromeOS::SetDefaultAdapterName() {
   DCHECK(IsPresent());
 
@@ skipping 16 matching lines @@
       break;
   }
 
   SetName(alias, base::Bind(&base::DoNothing), base::Bind(&base::DoNothing));
 }
 
 void BluetoothAdapterChromeOS::RemoveAdapter() {
   DCHECK(IsPresent());
   VLOG(1) << object_path_.value() << ": adapter removed.";
 
-  BluetoothAdapterClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothAdapterClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothAdapterClient()
+          ->GetProperties(object_path_);
 
   object_path_ = dbus::ObjectPath("");
 
   if (properties->powered.value())
     PoweredChanged(false);
   if (properties->discoverable.value())
     DiscoverableChanged(false);
   if (properties->discovering.value())
     DiscoveringChanged(false);
 
@@ skipping 158 matching lines @@
             this);
 
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
                     observers_,
                     GattDescriptorValueChanged(this, descriptor, value));
 }
 
 void BluetoothAdapterChromeOS::UseProfile(
     const BluetoothUUID& uuid,
     const dbus::ObjectPath& device_path,
-    const BluetoothProfileManagerClient::Options& options,
-    BluetoothProfileServiceProvider::Delegate* delegate,
+    const bluez::BluetoothProfileManagerClient::Options& options,
+    bluez::BluetoothProfileServiceProvider::Delegate* delegate,
     const ProfileRegisteredCallback& success_callback,
     const ErrorCompletionCallback& error_callback) {
   DCHECK(delegate);
 
   if (!IsPresent()) {
     VLOG(2) << "Adapter not present, erroring out";
     error_callback.Run("Adapter not present");
     return;
   }
 
@@ skipping 50 matching lines @@
 
   for (auto& it : *profile_queues_[uuid])
     it.first.Run();
   delete profile_queues_[uuid];
   profile_queues_.erase(uuid);
 }
 
 void BluetoothAdapterChromeOS::SetProfileDelegate(
     const BluetoothUUID& uuid,
     const dbus::ObjectPath& device_path,
-    BluetoothProfileServiceProvider::Delegate* delegate,
+    bluez::BluetoothProfileServiceProvider::Delegate* delegate,
     const ProfileRegisteredCallback& success_callback,
     const ErrorCompletionCallback& error_callback) {
   if (profiles_.find(uuid) == profiles_.end()) {
     error_callback.Run("Cannot find profile!");
     return;
   }
 
   if (profiles_[uuid]->SetDelegate(device_path, delegate)) {
     success_callback.Run(profiles_[uuid]);
     return;
@@ skipping 22 matching lines @@
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     bool success) {
   if (!IsPresent()) {
     error_callback.Run();
     return;
   }
 
   // Set the discoverable_timeout property to zero so the adapter remains
   // discoverable forever.
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-      GetProperties(object_path_)->discoverable_timeout.Set(
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothAdapterClient()
+      ->GetProperties(object_path_)
+      ->discoverable_timeout.Set(
           0,
           base::Bind(&BluetoothAdapterChromeOS::OnPropertyChangeCompleted,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback,
-                     error_callback));
+                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 void BluetoothAdapterChromeOS::OnPropertyChangeCompleted(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     bool success) {
   if (IsPresent() && success) {
     callback.Run();
   } else {
     error_callback.Run();
@@ skipping 47 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
         base::Bind(&BluetoothAdapterChromeOS::OnPreSetDiscoveryFilterError,
                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
     return;
   } else {
     current_filter_.reset();
   }
 
   // This is the first request to start device discovery.
   discovery_request_pending_ = true;
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->StartDiscovery(
+  bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->StartDiscovery(
       object_path_,
       base::Bind(&BluetoothAdapterChromeOS::OnStartDiscovery,
                  weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
       base::Bind(&BluetoothAdapterChromeOS::OnStartDiscoveryError,
                  weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 void BluetoothAdapterChromeOS::RemoveDiscoverySession(
     BluetoothDiscoveryFilter* discovery_filter,
     const base::Closure& callback,
@@ skipping 33 matching lines @@
     VLOG(1) << "No active discovery sessions. Returning error.";
     error_callback.Run(
         UMABluetoothDiscoverySessionOutcome::ACTIVE_SESSION_NOT_IN_ADAPTER);
     return;
   }
 
   // There is exactly one active discovery session. Request BlueZ to stop
   // discovery.
   DCHECK_EQ(num_discovery_sessions_, 1);
   discovery_request_pending_ = true;
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->
-      StopDiscovery(
-          object_path_,
-          base::Bind(&BluetoothAdapterChromeOS::OnStopDiscovery,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback),
-          base::Bind(&BluetoothAdapterChromeOS::OnStopDiscoveryError,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     error_callback));
+  bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->StopDiscovery(
+      object_path_, base::Bind(&BluetoothAdapterChromeOS::OnStopDiscovery,
+                               weak_ptr_factory_.GetWeakPtr(), callback),
+      base::Bind(&BluetoothAdapterChromeOS::OnStopDiscoveryError,
+                 weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothAdapterChromeOS::SetDiscoveryFilter(
     scoped_ptr<BluetoothDiscoveryFilter> discovery_filter,
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run(UMABluetoothDiscoverySessionOutcome::ADAPTER_REMOVED);
     return;
   }
 
   // If old and new filter are equal (null) then don't make request, just call
   // succes callback
   if (!current_filter_ && !discovery_filter.get()) {
     callback.Run();
     return;
   }
 
   // If old and new filter are not null and equal then don't make request, just
   // call succes callback
   if (current_filter_ && discovery_filter &&
       current_filter_->Equals(*discovery_filter)) {
     callback.Run();
     return;
   }
 
   current_filter_.reset(discovery_filter.release());
 
-  chromeos::BluetoothAdapterClient::DiscoveryFilter dbus_discovery_filter;
+  bluez::BluetoothAdapterClient::DiscoveryFilter dbus_discovery_filter;
 
   if (current_filter_.get()) {
     uint16_t pathloss;
     int16_t rssi;
     uint8_t transport;
     std::set<device::BluetoothUUID> uuids;
 
     if (current_filter_->GetPathloss(&pathloss))
       dbus_discovery_filter.pathloss.reset(new uint16_t(pathloss));
 
@@ skipping 14 matching lines @@
     current_filter_->GetUUIDs(uuids);
     if (uuids.size()) {
       dbus_discovery_filter.uuids =
           scoped_ptr<std::vector<std::string>>(new std::vector<std::string>);
 
       for (const auto& it : uuids)
         dbus_discovery_filter.uuids.get()->push_back(it.value());
     }
   }
 
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->SetDiscoveryFilter(
-      object_path_, dbus_discovery_filter,
-      base::Bind(&BluetoothAdapterChromeOS::OnSetDiscoveryFilter,
-                 weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
-      base::Bind(&BluetoothAdapterChromeOS::OnSetDiscoveryFilterError,
-                 weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothAdapterClient()
+      ->SetDiscoveryFilter(
+          object_path_, dbus_discovery_filter,
+          base::Bind(&BluetoothAdapterChromeOS::OnSetDiscoveryFilter,
+                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
+          base::Bind(&BluetoothAdapterChromeOS::OnSetDiscoveryFilterError,
+                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 void BluetoothAdapterChromeOS::OnStartDiscovery(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   // Report success on the original request and increment the count.
   VLOG(1) << __func__;
   DCHECK(discovery_request_pending_);
   DCHECK_EQ(num_discovery_sessions_, 0);
   discovery_request_pending_ = false;
@@ skipping 69 matching lines @@
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterChromeOS::OnPreSetDiscoveryFilter(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   // This is the first request to start device discovery.
   DCHECK(discovery_request_pending_);
   DCHECK_EQ(num_discovery_sessions_, 0);
 
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->StartDiscovery(
+  bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->StartDiscovery(
       object_path_,
       base::Bind(&BluetoothAdapterChromeOS::OnStartDiscovery,
                  weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
       base::Bind(&BluetoothAdapterChromeOS::OnStartDiscoveryError,
                  weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 void BluetoothAdapterChromeOS::OnPreSetDiscoveryFilterError(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback,
@@ skipping 58 matching lines @@
 
     // If the queued request resulted in a pending call, then let it
     // asynchonously process the remaining queued requests once the pending
     // call returns.
     if (discovery_request_pending_)
       return;
   }
 }
 
 }  // namespace chromeos