Refactor DBusThreadManager to split away BT clients.

device/bluetooth/dbus/fake_bluetooth_device_client.cc

 // Copyright (c) 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 "chromeos/dbus/fake_bluetooth_device_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_bluetooth_adapter_client.h"
-#include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
-#include "chromeos/dbus/fake_bluetooth_agent_service_provider.h"
-#include "chromeos/dbus/fake_bluetooth_gatt_service_client.h"
-#include "chromeos/dbus/fake_bluetooth_input_client.h"
-#include "chromeos/dbus/fake_bluetooth_profile_manager_client.h"
-#include "chromeos/dbus/fake_bluetooth_profile_service_provider.h"
 #include "dbus/file_descriptor.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
+#include "device/bluetooth/dbus/fake_bluetooth_adapter_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_agent_manager_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_agent_service_provider.h"
+#include "device/bluetooth/dbus/fake_bluetooth_gatt_service_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_input_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_profile_manager_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_profile_service_provider.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 // Default interval between simulated events.
 const int kSimulationIntervalMs = 750;
 
 // Minimum and maximum bounds for randomly generated RSSI values.
 const int kMinRSSI = -90;
 const int kMaxRSSI = -30;
@@ skipping 43 matching lines @@
   close(fd);
 }
 
 void SimpleErrorCallback(const std::string& error_name,
                          const std::string& error_message) {
   VLOG(1) << "Bluetooth Error: " << error_name << ": " << error_message;
 }
 
 }  // namespace
 
-namespace chromeos {
+namespace bluez {
 
 const char FakeBluetoothDeviceClient::kTestPinCode[] = "123456";
 const int FakeBluetoothDeviceClient::kTestPassKey = 123456;
 
 const char FakeBluetoothDeviceClient::kPairingMethodNone[] = "None";
 const char FakeBluetoothDeviceClient::kPairingMethodPinCode[] = "PIN Code";
 const char FakeBluetoothDeviceClient::kPairingMethodPassKey[] = "PassKey";
 
 const char FakeBluetoothDeviceClient::kPairingActionConfirmation[] =
     "Confirmation";
 const char FakeBluetoothDeviceClient::kPairingActionDisplay[] = "Display";
 const char FakeBluetoothDeviceClient::kPairingActionFail[] = "Fail";
 const char FakeBluetoothDeviceClient::kPairingActionRequest[] = "Request";
 
-const char FakeBluetoothDeviceClient::kPairedDevicePath[] =
-    "/fake/hci0/dev0";
+const char FakeBluetoothDeviceClient::kPairedDevicePath[] = "/fake/hci0/dev0";
 const char FakeBluetoothDeviceClient::kPairedDeviceAddress[] =
     "00:11:22:33:44:55";
-const char FakeBluetoothDeviceClient::kPairedDeviceName[] =
-    "Fake Device";
+const char FakeBluetoothDeviceClient::kPairedDeviceName[] = "Fake Device";
 const uint32 FakeBluetoothDeviceClient::kPairedDeviceClass = 0x000104;
 
-const char FakeBluetoothDeviceClient::kLegacyAutopairPath[] =
-    "/fake/hci0/dev1";
+const char FakeBluetoothDeviceClient::kLegacyAutopairPath[] = "/fake/hci0/dev1";
 const char FakeBluetoothDeviceClient::kLegacyAutopairAddress[] =
     "28:CF:DA:00:00:00";
 const char FakeBluetoothDeviceClient::kLegacyAutopairName[] =
     "Bluetooth 2.0 Mouse";
 const uint32 FakeBluetoothDeviceClient::kLegacyAutopairClass = 0x002580;
 
-const char FakeBluetoothDeviceClient::kDisplayPinCodePath[] =
-    "/fake/hci0/dev2";
+const char FakeBluetoothDeviceClient::kDisplayPinCodePath[] = "/fake/hci0/dev2";
 const char FakeBluetoothDeviceClient::kDisplayPinCodeAddress[] =
     "28:37:37:00:00:00";
 const char FakeBluetoothDeviceClient::kDisplayPinCodeName[] =
     "Bluetooth 2.0 Keyboard";
 const uint32 FakeBluetoothDeviceClient::kDisplayPinCodeClass = 0x002540;
 
 const char FakeBluetoothDeviceClient::kVanishingDevicePath[] =
     "/fake/hci0/dev3";
 const char FakeBluetoothDeviceClient::kVanishingDeviceAddress[] =
     "01:02:03:04:05:06";
 const char FakeBluetoothDeviceClient::kVanishingDeviceName[] =
     "Vanishing Device";
 const uint32 FakeBluetoothDeviceClient::kVanishingDeviceClass = 0x000104;
 
 const char FakeBluetoothDeviceClient::kConnectUnpairablePath[] =
     "/fake/hci0/dev4";
 const char FakeBluetoothDeviceClient::kConnectUnpairableAddress[] =
     "7C:ED:8D:00:00:00";
 const char FakeBluetoothDeviceClient::kConnectUnpairableName[] =
     "Unpairable Device";
 const uint32 FakeBluetoothDeviceClient::kConnectUnpairableClass = 0x002580;
 
-const char FakeBluetoothDeviceClient::kDisplayPasskeyPath[] =
-    "/fake/hci0/dev5";
+const char FakeBluetoothDeviceClient::kDisplayPasskeyPath[] = "/fake/hci0/dev5";
 const char FakeBluetoothDeviceClient::kDisplayPasskeyAddress[] =
     "00:0F:F6:00:00:00";
 const char FakeBluetoothDeviceClient::kDisplayPasskeyName[] =
     "Bluetooth 2.1+ Keyboard";
 const uint32 FakeBluetoothDeviceClient::kDisplayPasskeyClass = 0x002540;
 
-const char FakeBluetoothDeviceClient::kRequestPinCodePath[] =
-    "/fake/hci0/dev6";
+const char FakeBluetoothDeviceClient::kRequestPinCodePath[] = "/fake/hci0/dev6";
 const char FakeBluetoothDeviceClient::kRequestPinCodeAddress[] =
     "00:24:BE:00:00:00";
-const char FakeBluetoothDeviceClient::kRequestPinCodeName[] =
-    "PIN Device";
+const char FakeBluetoothDeviceClient::kRequestPinCodeName[] = "PIN Device";
 const uint32 FakeBluetoothDeviceClient::kRequestPinCodeClass = 0x240408;
 
-const char FakeBluetoothDeviceClient::kConfirmPasskeyPath[] =
-    "/fake/hci0/dev7";
+const char FakeBluetoothDeviceClient::kConfirmPasskeyPath[] = "/fake/hci0/dev7";
 const char FakeBluetoothDeviceClient::kConfirmPasskeyAddress[] =
     "20:7D:74:00:00:00";
-const char FakeBluetoothDeviceClient::kConfirmPasskeyName[] =
-    "Phone";
+const char FakeBluetoothDeviceClient::kConfirmPasskeyName[] = "Phone";
 const uint32 FakeBluetoothDeviceClient::kConfirmPasskeyClass = 0x7a020c;
 
-const char FakeBluetoothDeviceClient::kRequestPasskeyPath[] =
-    "/fake/hci0/dev8";
+const char FakeBluetoothDeviceClient::kRequestPasskeyPath[] = "/fake/hci0/dev8";
 const char FakeBluetoothDeviceClient::kRequestPasskeyAddress[] =
     "20:7D:74:00:00:01";
-const char FakeBluetoothDeviceClient::kRequestPasskeyName[] =
-    "Passkey Device";
+const char FakeBluetoothDeviceClient::kRequestPasskeyName[] = "Passkey Device";
 const uint32 FakeBluetoothDeviceClient::kRequestPasskeyClass = 0x7a020c;
 
 const char FakeBluetoothDeviceClient::kUnconnectableDevicePath[] =
     "/fake/hci0/dev9";
 const char FakeBluetoothDeviceClient::kUnconnectableDeviceAddress[] =
     "20:7D:74:00:00:02";
 const char FakeBluetoothDeviceClient::kUnconnectableDeviceName[] =
     "Unconnectable Device";
 const uint32 FakeBluetoothDeviceClient::kUnconnectableDeviceClass = 0x7a020c;
 
 const char FakeBluetoothDeviceClient::kUnpairableDevicePath[] =
     "/fake/hci0/devA";
 const char FakeBluetoothDeviceClient::kUnpairableDeviceAddress[] =
     "20:7D:74:00:00:03";
 const char FakeBluetoothDeviceClient::kUnpairableDeviceName[] =
     "Unpairable Device";
 const uint32 FakeBluetoothDeviceClient::kUnpairableDeviceClass = 0x002540;
 
-const char FakeBluetoothDeviceClient::kJustWorksPath[] =
-    "/fake/hci0/devB";
-const char FakeBluetoothDeviceClient::kJustWorksAddress[] =
-    "00:0C:8A:00:00:00";
-const char FakeBluetoothDeviceClient::kJustWorksName[] =
-    "Just-Works Device";
+const char FakeBluetoothDeviceClient::kJustWorksPath[] = "/fake/hci0/devB";
+const char FakeBluetoothDeviceClient::kJustWorksAddress[] = "00:0C:8A:00:00:00";
+const char FakeBluetoothDeviceClient::kJustWorksName[] = "Just-Works Device";
 const uint32 FakeBluetoothDeviceClient::kJustWorksClass = 0x240428;
 
-const char FakeBluetoothDeviceClient::kLowEnergyPath[] =
-    "/fake/hci0/devC";
-const char FakeBluetoothDeviceClient::kLowEnergyAddress[] =
-    "00:1A:11:00:15:30";
+const char FakeBluetoothDeviceClient::kLowEnergyPath[] = "/fake/hci0/devC";
+const char FakeBluetoothDeviceClient::kLowEnergyAddress[] = "00:1A:11:00:15:30";
 const char FakeBluetoothDeviceClient::kLowEnergyName[] =
     "Bluetooth 4.0 Heart Rate Monitor";
 const uint32 FakeBluetoothDeviceClient::kLowEnergyClass =
     0x000918;  // Major class "Health", Minor class "Heart/Pulse Rate Monitor."
 
 const char FakeBluetoothDeviceClient::kPairedUnconnectableDevicePath[] =
     "/fake/hci0/devD";
 const char FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress[] =
     "20:7D:74:00:00:04";
 const char FakeBluetoothDeviceClient::kPairedUnconnectableDeviceName[] =
     "Paired Unconnectable Device";
 const uint32 FakeBluetoothDeviceClient::kPairedUnconnectableDeviceClass =
     0x000104;
 
 FakeBluetoothDeviceClient::Properties::Properties(
     const PropertyChangedCallback& callback)
     : BluetoothDeviceClient::Properties(
           NULL,
           bluetooth_device::kBluetoothDeviceInterface,
-          callback) {
-}
+          callback) {}
 
-FakeBluetoothDeviceClient::Properties::~Properties() {
-}
+FakeBluetoothDeviceClient::Properties::~Properties() {}
 
 void FakeBluetoothDeviceClient::Properties::Get(
     dbus::PropertyBase* property,
     dbus::PropertySet::GetCallback callback) {
   VLOG(1) << "Get " << property->name();
   callback.Run(false);
 }
 
 void FakeBluetoothDeviceClient::Properties::GetAll() {
   VLOG(1) << "GetAll";
 }
 
 void FakeBluetoothDeviceClient::Properties::Set(
-    dbus::PropertyBase *property,
+    dbus::PropertyBase* property,
     dbus::PropertySet::SetCallback callback) {
   VLOG(1) << "Set " << property->name();
   if (property->name() == trusted.name()) {
     callback.Run(true);
     property->ReplaceValueWithSetValue();
   } else {
     callback.Run(false);
   }
 }
 
@@ skipping 53 matching lines @@
 
   properties->uuids.ReplaceValue(uuids);
 
   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
 
   properties_map_.insert(dbus::ObjectPath(kPairedUnconnectableDevicePath),
                          properties.Pass());
   device_list_.push_back(dbus::ObjectPath(kPairedUnconnectableDevicePath));
 }
 
-FakeBluetoothDeviceClient::~FakeBluetoothDeviceClient() {
-}
+FakeBluetoothDeviceClient::~FakeBluetoothDeviceClient() {}
 
-void FakeBluetoothDeviceClient::Init(dbus::Bus* bus) {
-}
+void FakeBluetoothDeviceClient::Init(dbus::Bus* bus) {}
 
 void FakeBluetoothDeviceClient::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeBluetoothDeviceClient::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 std::vector<dbus::ObjectPath> FakeBluetoothDeviceClient::GetDevicesForAdapter(
     const dbus::ObjectPath& adapter_path) {
   if (adapter_path ==
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath))
     return device_list_;
   else
     return std::vector<dbus::ObjectPath>();
 }
 
-FakeBluetoothDeviceClient::Properties*
-FakeBluetoothDeviceClient::GetProperties(const dbus::ObjectPath& object_path) {
+FakeBluetoothDeviceClient::Properties* FakeBluetoothDeviceClient::GetProperties(
+    const dbus::ObjectPath& object_path) {
   PropertiesMap::const_iterator iter = properties_map_.find(object_path);
   if (iter != properties_map_.end())
     return iter->second;
   return NULL;
 }
 
 FakeBluetoothDeviceClient::SimulatedPairingOptions*
 FakeBluetoothDeviceClient::GetPairingOptions(
     const dbus::ObjectPath& object_path) {
   PairingOptionsMap::const_iterator iter =
       pairing_options_map_.find(object_path);
   if (iter != pairing_options_map_.end())
     return iter->second;
   return iter != pairing_options_map_.end() ? iter->second : nullptr;
 }
 
-void FakeBluetoothDeviceClient::Connect(
-    const dbus::ObjectPath& object_path,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+void FakeBluetoothDeviceClient::Connect(const dbus::ObjectPath& object_path,
+                                        const base::Closure& callback,
+                                        const ErrorCallback& error_callback) {
   VLOG(1) << "Connect: " << object_path.value();
   Properties* properties = GetProperties(object_path);
 
   if (properties->connected.value() == true) {
     // Already connected.
     callback.Run();
     return;
   }
 
   if (properties->paired.value() != true &&
@@ skipping 13 matching lines @@
   }
 
   // The device can be connected.
   properties->connected.ReplaceValue(true);
   callback.Run();
 
   // Expose GATT services if connected to LE device.
   if (object_path == dbus::ObjectPath(kLowEnergyPath)) {
     FakeBluetoothGattServiceClient* gatt_service_client =
         static_cast<FakeBluetoothGattServiceClient*>(
-            DBusThreadManager::Get()->GetBluetoothGattServiceClient());
+            bluez::BluezDBusManager::Get()->GetBluetoothGattServiceClient());
     gatt_service_client->ExposeHeartRateService(
         dbus::ObjectPath(kLowEnergyPath));
   }
 
   AddInputDeviceIfNeeded(object_path, properties);
 }
 
 void FakeBluetoothDeviceClient::Disconnect(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "Disconnect: " << object_path.value();
   Properties* properties = GetProperties(object_path);
 
   if (!properties->connected.value()) {
     error_callback.Run("org.bluez.Error.NotConnected", "Not Connected");
     return;
   }
 
   // Hide the Heart Rate Service if disconnected from LE device.
   if (object_path == dbus::ObjectPath(kLowEnergyPath)) {
     FakeBluetoothGattServiceClient* gatt_service_client =
         static_cast<FakeBluetoothGattServiceClient*>(
-            DBusThreadManager::Get()->GetBluetoothGattServiceClient());
+            bluez::BluezDBusManager::Get()->GetBluetoothGattServiceClient());
     gatt_service_client->HideHeartRateService();
   }
 
   callback.Run();
   properties->connected.ReplaceValue(false);
 }
 
 void FakeBluetoothDeviceClient::ConnectProfile(
     const dbus::ObjectPath& object_path,
     const std::string& uuid,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "ConnectProfile: " << object_path.value() << " " << uuid;
 
   FakeBluetoothProfileManagerClient* fake_bluetooth_profile_manager_client =
       static_cast<FakeBluetoothProfileManagerClient*>(
-          DBusThreadManager::Get()->GetBluetoothProfileManagerClient());
+          bluez::BluezDBusManager::Get()->GetBluetoothProfileManagerClient());
   FakeBluetoothProfileServiceProvider* profile_service_provider =
       fake_bluetooth_profile_manager_client->GetProfileServiceProvider(uuid);
   if (profile_service_provider == NULL) {
     error_callback.Run(kNoResponseError, "Missing profile");
     return;
   }
 
   if (object_path == dbus::ObjectPath(kPairedUnconnectableDevicePath)) {
     error_callback.Run(bluetooth_device::kErrorFailed, "unconnectable");
     return;
@@ skipping 18 matching lines @@
     error_callback.Run(kNoResponseError, "failed to get socket flags");
     return;
   }
 
   args |= O_NONBLOCK;
   if (fcntl(fds[1], F_SETFL, args) < 0) {
     error_callback.Run(kNoResponseError, "failed to set socket non-blocking");
     return;
   }
 
-  base::WorkerPool::GetTaskRunner(false)->PostTask(
-      FROM_HERE,
-      base::Bind(&SimulatedProfileSocket,
-                 fds[0]));
+  base::WorkerPool::GetTaskRunner(false)
+      ->PostTask(FROM_HERE, base::Bind(&SimulatedProfileSocket, fds[0]));
 
   scoped_ptr<dbus::FileDescriptor> fd(new dbus::FileDescriptor(fds[1]));
 
   // Post the new connection to the service provider.
   BluetoothProfileServiceProvider::Delegate::Options options;
 
   profile_service_provider->NewConnection(
-      object_path,
-      fd.Pass(),
-      options,
+      object_path, fd.Pass(), options,
       base::Bind(&FakeBluetoothDeviceClient::ConnectionCallback,
-                 base::Unretained(this),
-                 object_path,
-                 callback,
+                 base::Unretained(this), object_path, callback,
                  error_callback));
 }
 
 void FakeBluetoothDeviceClient::DisconnectProfile(
     const dbus::ObjectPath& object_path,
     const std::string& uuid,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "DisconnectProfile: " << object_path.value() << " " << uuid;
 
   FakeBluetoothProfileManagerClient* fake_bluetooth_profile_manager_client =
       static_cast<FakeBluetoothProfileManagerClient*>(
-          DBusThreadManager::Get()->GetBluetoothProfileManagerClient());
+          bluez::BluezDBusManager::Get()->GetBluetoothProfileManagerClient());
   FakeBluetoothProfileServiceProvider* profile_service_provider =
       fake_bluetooth_profile_manager_client->GetProfileServiceProvider(uuid);
   if (profile_service_provider == NULL) {
     error_callback.Run(kNoResponseError, "Missing profile");
     return;
   }
 
   profile_service_provider->RequestDisconnection(
-      object_path,
-      base::Bind(&FakeBluetoothDeviceClient::DisconnectionCallback,
-                 base::Unretained(this),
-                 object_path,
-                 callback,
-                 error_callback));
+      object_path, base::Bind(&FakeBluetoothDeviceClient::DisconnectionCallback,
+                              base::Unretained(this), object_path, callback,
+                              error_callback));
 }
 
-void FakeBluetoothDeviceClient::Pair(
-    const dbus::ObjectPath& object_path,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
+void FakeBluetoothDeviceClient::Pair(const dbus::ObjectPath& object_path,
+                                     const base::Closure& callback,
+                                     const ErrorCallback& error_callback) {
   VLOG(1) << "Pair: " << object_path.value();
   Properties* properties = GetProperties(object_path);
 
   if (properties->paired.value() == true) {
     // Already paired.
     callback.Run();
     return;
   }
 
   SimulatePairing(object_path, false, callback, error_callback);
@@ skipping 61 matching lines @@
   incoming_pairing_simulation_step_ = 0;
 }
 
 void FakeBluetoothDeviceClient::SetSimulationIntervalMs(int interval_ms) {
   simulation_interval_ms_ = interval_ms;
 }
 
 void FakeBluetoothDeviceClient::CreateDevice(
     const dbus::ObjectPath& adapter_path,
     const dbus::ObjectPath& device_path) {
-  if (std::find(device_list_.begin(),
-                device_list_.end(), device_path) != device_list_.end())
+  if (std::find(device_list_.begin(), device_list_.end(), device_path) !=
+      device_list_.end())
     return;
 
   scoped_ptr<Properties> properties(
       new Properties(base::Bind(&FakeBluetoothDeviceClient::OnPropertyChanged,
                                 base::Unretained(this), device_path)));
   properties->adapter.ReplaceValue(adapter_path);
 
   if (device_path == dbus::ObjectPath(kLegacyAutopairPath)) {
     properties->address.ReplaceValue(kLegacyAutopairAddress);
     properties->bluetooth_class.ReplaceValue(kLegacyAutopairClass);
@@ skipping 81 matching lines @@
     properties->bluetooth_class.ReplaceValue(kLowEnergyClass);
     properties->name.ReplaceValue("Heart Rate Monitor");
     properties->alias.ReplaceValue(kLowEnergyName);
 
     std::vector<std::string> uuids;
     uuids.push_back(FakeBluetoothGattServiceClient::kHeartRateServiceUUID);
     properties->uuids.ReplaceValue(uuids);
 
   } else {
     NOTREACHED();
-
   }
 
   properties_map_.insert(device_path, properties.Pass());
   device_list_.push_back(device_path);
   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
                     DeviceAdded(device_path));
 }
 
 void FakeBluetoothDeviceClient::CreateDeviceWithProperties(
     const dbus::ObjectPath& adapter_path,
@@ skipping 260 matching lines @@
   Properties* properties = iter->second;
 
   VLOG(1) << "removing device: " << properties->alias.value();
   device_list_.erase(listiter);
 
   // Remove the Input interface if it exists. This should be called before the
   // BluetoothDeviceClient::Observer::DeviceRemoved because it deletes the
   // BluetoothDeviceChromeOS object, including the device_path referenced here.
   FakeBluetoothInputClient* fake_bluetooth_input_client =
       static_cast<FakeBluetoothInputClient*>(
-          DBusThreadManager::Get()->GetBluetoothInputClient());
+          bluez::BluezDBusManager::Get()->GetBluetoothInputClient());
   fake_bluetooth_input_client->RemoveInputDevice(device_path);
 
   if (device_path == dbus::ObjectPath(kLowEnergyPath)) {
     FakeBluetoothGattServiceClient* gatt_service_client =
         static_cast<FakeBluetoothGattServiceClient*>(
-            DBusThreadManager::Get()->GetBluetoothGattServiceClient());
+            bluez::BluezDBusManager::Get()->GetBluetoothGattServiceClient());
     gatt_service_client->HideHeartRateService();
   }
 
   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
                     DeviceRemoved(device_path));
 
   properties_map_.erase(iter);
   PairingOptionsMap::const_iterator options_iter =
       pairing_options_map_.find(device_path);
 
@@ skipping 62 matching lines @@
 
   } else if (discovery_simulation_step_ == 13) {
     UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath),
                      base::RandInt(kMinRSSI, kMaxRSSI));
     RemoveDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
                  dbus::ObjectPath(kVanishingDevicePath));
   } else if (discovery_simulation_step_ == 14) {
     UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath),
                      base::RandInt(kMinRSSI, kMaxRSSI));
     return;
-
   }
 
   ++discovery_simulation_step_;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeBluetoothDeviceClient::DiscoverySimulationTimer,
                  base::Unretained(this)),
       base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 }
 
@@ skipping 61 matching lines @@
 
 void FakeBluetoothDeviceClient::SimulatePairing(
     const dbus::ObjectPath& object_path,
     bool incoming_request,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   pairing_cancelled_ = false;
 
   FakeBluetoothAgentManagerClient* fake_bluetooth_agent_manager_client =
       static_cast<FakeBluetoothAgentManagerClient*>(
-          DBusThreadManager::Get()->GetBluetoothAgentManagerClient());
+          bluez::BluezDBusManager::Get()->GetBluetoothAgentManagerClient());
   FakeBluetoothAgentServiceProvider* agent_service_provider =
       fake_bluetooth_agent_manager_client->GetAgentServiceProvider();
   CHECK(agent_service_provider != NULL);
 
   // Grab the device's pairing properties.
   PairingOptionsMap::const_iterator iter =
       pairing_options_map_.find(object_path);
 
   // If the device with path |object_path| has simulated pairing properties
   // defined, then pair it based on its |pairing_method|.
@@ skipping 230 matching lines @@
   error_callback.Run(bluetooth_device::kErrorFailed, "Failed");
 }
 
 void FakeBluetoothDeviceClient::AddInputDeviceIfNeeded(
     const dbus::ObjectPath& object_path,
     Properties* properties) {
   // If the paired device is a HID device based on it's bluetooth class,
   // simulate the Input interface.
   FakeBluetoothInputClient* fake_bluetooth_input_client =
       static_cast<FakeBluetoothInputClient*>(
-          DBusThreadManager::Get()->GetBluetoothInputClient());
+          bluez::BluezDBusManager::Get()->GetBluetoothInputClient());
 
   if ((properties->bluetooth_class.value() & 0x001f03) == 0x000500)
     fake_bluetooth_input_client->AddInputDevice(object_path);
 }
 
 void FakeBluetoothDeviceClient::UpdateDeviceRSSI(
     const dbus::ObjectPath& object_path,
     int16 rssi) {
   PropertiesMap::const_iterator iter = properties_map_.find(object_path);
   if (iter == properties_map_.end()) {
@@ skipping 149 matching lines @@
 
 void FakeBluetoothDeviceClient::SimulateKeypress(
     uint16 entered,
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "SimulateKeypress " << entered << ": " << object_path.value();
 
   FakeBluetoothAgentManagerClient* fake_bluetooth_agent_manager_client =
       static_cast<FakeBluetoothAgentManagerClient*>(
-          DBusThreadManager::Get()->GetBluetoothAgentManagerClient());
+          bluez::BluezDBusManager::Get()->GetBluetoothAgentManagerClient());
   FakeBluetoothAgentServiceProvider* agent_service_provider =
       fake_bluetooth_agent_manager_client->GetAgentServiceProvider();
 
   // The agent service provider object could have been destroyed after the
   // pairing is canceled.
   if (!agent_service_provider)
     return;
 
   agent_service_provider->DisplayPasskey(object_path, kTestPassKey, entered);
 
@@ skipping 42 matching lines @@
   if (status == BluetoothProfileServiceProvider::Delegate::SUCCESS) {
     // TODO(keybuk): tear down this side of the connection
     callback.Run();
   } else if (status == BluetoothProfileServiceProvider::Delegate::CANCELLED) {
     error_callback.Run(bluetooth_device::kErrorFailed, "Canceled");
   } else if (status == BluetoothProfileServiceProvider::Delegate::REJECTED) {
     error_callback.Run(bluetooth_device::kErrorFailed, "Rejected");
   }
 }
 
-}  // namespace chromeos
+}  // namespace bluez