Refactor DBusThreadManager to split away BT clients.

device/bluetooth/bluetooth_device_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_device_chromeos.h"
 
 #include <stdio.h>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "chromeos/dbus/bluetooth_adapter_client.h"
-#include "chromeos/dbus/bluetooth_device_client.h"
-#include "chromeos/dbus/bluetooth_gatt_service_client.h"
-#include "chromeos/dbus/bluetooth_input_client.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
 #include "dbus/bus.h"
 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
 #include "device/bluetooth/bluetooth_gatt_connection_chromeos.h"
 #include "device/bluetooth/bluetooth_pairing_chromeos.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_chromeos.h"
 #include "device/bluetooth/bluetooth_socket.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_device_client.h"
+#include "device/bluetooth/dbus/bluetooth_gatt_service_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::BluetoothDevice;
 using device::BluetoothSocket;
 using device::BluetoothUUID;
 
 namespace {
 
 // Histogram enumerations for pairing results.
 enum UMAPairingResult {
   UMA_PAIRING_RESULT_SUCCESS,
   UMA_PAIRING_RESULT_INPROGRESS,
   UMA_PAIRING_RESULT_FAILED,
   UMA_PAIRING_RESULT_AUTH_FAILED,
   UMA_PAIRING_RESULT_AUTH_CANCELED,
   UMA_PAIRING_RESULT_AUTH_REJECTED,
   UMA_PAIRING_RESULT_AUTH_TIMEOUT,
   UMA_PAIRING_RESULT_UNSUPPORTED_DEVICE,
   UMA_PAIRING_RESULT_UNKNOWN_ERROR,
   // NOTE: Add new pairing results immediately above this line. Make sure to
   // update the enum list in tools/histogram/histograms.xml accordinly.
   UMA_PAIRING_RESULT_COUNT
 };
 
 void ParseModalias(const dbus::ObjectPath& object_path,
                    BluetoothDevice::VendorIDSource* vendor_id_source,
                    uint16* vendor_id,
                    uint16* product_id,
                    uint16* device_id) {
-  chromeos::BluetoothDeviceClient::Properties* properties =
-      chromeos::DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path);
   DCHECK(properties);
 
   std::string modalias = properties->modalias.value();
   BluetoothDevice::VendorIDSource source_value;
   int vendor_value, product_value, device_value;
 
   if (sscanf(modalias.c_str(), "bluetooth:v%04xp%04xd%04x",
              &vendor_value, &product_value, &device_value) == 3) {
     source_value = BluetoothDevice::VENDOR_ID_BLUETOOTH;
   } else if (sscanf(modalias.c_str(), "usb:v%04xp%04xd%04x",
@@ skipping 55 matching lines @@
     const dbus::ObjectPath& object_path,
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<device::BluetoothSocketThread> socket_thread)
     : BluetoothDevice(adapter),
       object_path_(object_path),
       num_connecting_calls_(0),
       connection_monitor_started_(false),
       ui_task_runner_(ui_task_runner),
       socket_thread_(socket_thread),
       weak_ptr_factory_(this) {
-  DBusThreadManager::Get()->GetBluetoothGattServiceClient()->AddObserver(this);
+  bluez::BluezDBusManager::Get()->GetBluetoothGattServiceClient()->AddObserver(
+      this);
 
   // Add all known GATT services.
   const std::vector<dbus::ObjectPath> gatt_services =
-      DBusThreadManager::Get()->GetBluetoothGattServiceClient()->GetServices();
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothGattServiceClient()
+          ->GetServices();
   for (std::vector<dbus::ObjectPath>::const_iterator it = gatt_services.begin();
        it != gatt_services.end(); ++it) {
     GattServiceAdded(*it);
   }
 }
 
 BluetoothDeviceChromeOS::~BluetoothDeviceChromeOS() {
-  DBusThreadManager::Get()->GetBluetoothGattServiceClient()->
-      RemoveObserver(this);
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothGattServiceClient()
+      ->RemoveObserver(this);
 
   // Copy the GATT services list here and clear the original so that when we
   // send GattServiceRemoved(), GetGattServices() returns no services.
   GattServiceMap gatt_services = gatt_services_;
   gatt_services_.clear();
   for (GattServiceMap::iterator iter = gatt_services.begin();
        iter != gatt_services.end(); ++iter) {
     DCHECK(adapter_);
     adapter()->NotifyGattServiceRemoved(
         static_cast<BluetoothRemoteGattServiceChromeOS*>(iter->second));
     delete iter->second;
   }
 }
 
 uint32 BluetoothDeviceChromeOS::GetBluetoothClass() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
   DCHECK(properties);
 
   return properties->bluetooth_class.value();
 }
 
 std::string BluetoothDeviceChromeOS::GetDeviceName() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
   DCHECK(properties);
 
   return properties->alias.value();
 }
 
 std::string BluetoothDeviceChromeOS::GetAddress() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
   DCHECK(properties);
 
   return CanonicalizeAddress(properties->address.value());
 }
 
 BluetoothDevice::VendorIDSource
 BluetoothDeviceChromeOS::GetVendorIDSource() const {
   VendorIDSource vendor_id_source = VENDOR_ID_UNKNOWN;
   ParseModalias(object_path_, &vendor_id_source, NULL, NULL, NULL);
   return vendor_id_source;
@@ skipping 11 matching lines @@
   return product_id;
 }
 
 uint16 BluetoothDeviceChromeOS::GetDeviceID() const {
   uint16 device_id  = 0;
   ParseModalias(object_path_, NULL, NULL, NULL, &device_id);
   return device_id;
 }
 
 bool BluetoothDeviceChromeOS::IsPaired() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
   DCHECK(properties);
 
   // Trusted devices are devices that don't support pairing but that the
   // user has explicitly connected; it makes no sense for UI purposes to
   // treat them differently from each other.
   return properties->paired.value() || properties->trusted.value();
 }
 
 bool BluetoothDeviceChromeOS::IsConnected() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
   DCHECK(properties);
 
   return properties->connected.value();
 }
 
 bool BluetoothDeviceChromeOS::IsConnectable() const {
-  BluetoothInputClient::Properties* input_properties =
-      DBusThreadManager::Get()->GetBluetoothInputClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothInputClient::Properties* input_properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothInputClient()->GetProperties(
+          object_path_);
   // GetProperties returns NULL when the device does not implement the given
   // interface. Non HID devices are normally connectable.
   if (!input_properties)
     return true;
 
   return input_properties->reconnect_mode.value() != "device";
 }
 
 bool BluetoothDeviceChromeOS::IsConnecting() const {
   return num_connecting_calls_ > 0;
 }
 
 BluetoothDeviceChromeOS::UUIDList BluetoothDeviceChromeOS::GetUUIDs() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
   DCHECK(properties);
 
   std::vector<device::BluetoothUUID> uuids;
   const std::vector<std::string> &dbus_uuids = properties->uuids.value();
   for (std::vector<std::string>::const_iterator iter = dbus_uuids.begin();
        iter != dbus_uuids.end(); ++iter) {
     device::BluetoothUUID uuid(*iter);
     DCHECK(uuid.IsValid());
     uuids.push_back(uuid);
   }
   return uuids;
 }
 
 int16 BluetoothDeviceChromeOS::GetInquiryRSSI() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
   DCHECK(properties);
 
   if (!properties->rssi.is_valid())
     return kUnknownPower;
 
   return properties->rssi.value();
 }
 
 int16 BluetoothDeviceChromeOS::GetInquiryTxPower() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-          GetProperties(object_path_);
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
   DCHECK(properties);
 
   if (!properties->tx_power.is_valid())
     return kUnknownPower;
 
   return properties->tx_power.value();
 }
 
 bool BluetoothDeviceChromeOS::ExpectingPinCode() const {
   return pairing_.get() && pairing_->ExpectingPinCode();
 }
 
 bool BluetoothDeviceChromeOS::ExpectingPasskey() const {
   return pairing_.get() && pairing_->ExpectingPasskey();
 }
 
 bool BluetoothDeviceChromeOS::ExpectingConfirmation() const {
   return pairing_.get() && pairing_->ExpectingConfirmation();
 }
 
 void BluetoothDeviceChromeOS::GetConnectionInfo(
     const ConnectionInfoCallback& callback) {
   // DBus method call should gracefully return an error if the device is not
   // currently connected.
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->GetConnInfo(
+  bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetConnInfo(
       object_path_, base::Bind(&BluetoothDeviceChromeOS::OnGetConnInfo,
                                weak_ptr_factory_.GetWeakPtr(), callback),
       base::Bind(&BluetoothDeviceChromeOS::OnGetConnInfoError,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BluetoothDeviceChromeOS::Connect(
     BluetoothDevice::PairingDelegate* pairing_delegate,
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback) {
   if (num_connecting_calls_++ == 0)
     adapter()->NotifyDeviceChanged(this);
 
   VLOG(1) << object_path_.value() << ": Connecting, " << num_connecting_calls_
           << " in progress";
 
   if (IsPaired() || !pairing_delegate || !IsPairable()) {
     // No need to pair, or unable to, skip straight to connection.
     ConnectInternal(false, callback, error_callback);
   } else {
     // Initiate high-security connection with pairing.
     BeginPairing(pairing_delegate);
 
-    DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-        Pair(object_path_,
-             base::Bind(&BluetoothDeviceChromeOS::OnPair,
-                        weak_ptr_factory_.GetWeakPtr(),
-                        callback, error_callback),
-             base::Bind(&BluetoothDeviceChromeOS::OnPairError,
-                        weak_ptr_factory_.GetWeakPtr(),
-                        error_callback));
+    bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->Pair(
+        object_path_,
+        base::Bind(&BluetoothDeviceChromeOS::OnPair,
+                   weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
+        base::Bind(&BluetoothDeviceChromeOS::OnPairError,
+                   weak_ptr_factory_.GetWeakPtr(), error_callback));
   }
 }
 
 void BluetoothDeviceChromeOS::SetPinCode(const std::string& pincode) {
   if (!pairing_.get())
     return;
 
   pairing_->SetPinCode(pincode);
 }
 
@@ skipping 23 matching lines @@
 
   // If there is a callback in progress that we can reply to then use that
   // to cancel the current pairing request.
   if (pairing_.get() && pairing_->CancelPairing())
     canceled = true;
 
   // If not we have to send an explicit CancelPairing() to the device instead.
   if (!canceled) {
     VLOG(1) << object_path_.value() << ": No pairing context or callback. "
             << "Sending explicit cancel";
-    DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-        CancelPairing(
-            object_path_,
-            base::Bind(&base::DoNothing),
-            base::Bind(&BluetoothDeviceChromeOS::OnCancelPairingError,
-                       weak_ptr_factory_.GetWeakPtr()));
+    bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->CancelPairing(
+        object_path_, base::Bind(&base::DoNothing),
+        base::Bind(&BluetoothDeviceChromeOS::OnCancelPairingError,
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   // Since there is no callback to this method it's possible that the pairing
   // delegate is going to be freed before things complete (indeed it's
   // documented that this is the method you should call while freeing the
   // pairing delegate), so clear our the context holding on to it.
   EndPairing();
 }
 
 void BluetoothDeviceChromeOS::Disconnect(const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   VLOG(1) << object_path_.value() << ": Disconnecting";
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-      Disconnect(
-          object_path_,
-          base::Bind(&BluetoothDeviceChromeOS::OnDisconnect,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback),
-          base::Bind(&BluetoothDeviceChromeOS::OnDisconnectError,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     error_callback));
+  bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->Disconnect(
+      object_path_, base::Bind(&BluetoothDeviceChromeOS::OnDisconnect,
+                               weak_ptr_factory_.GetWeakPtr(), callback),
+      base::Bind(&BluetoothDeviceChromeOS::OnDisconnectError,
+                 weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothDeviceChromeOS::Forget(const ErrorCallback& error_callback) {
   VLOG(1) << object_path_.value() << ": Removing device";
-  DBusThreadManager::Get()->GetBluetoothAdapterClient()->RemoveDevice(
+  bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->RemoveDevice(
       adapter()->object_path(), object_path_, base::Bind(&base::DoNothing),
       base::Bind(&BluetoothDeviceChromeOS::OnForgetError,
                  weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothDeviceChromeOS::ConnectToService(
     const BluetoothUUID& uuid,
     const ConnectToServiceCallback& callback,
     const ConnectToServiceErrorCallback& error_callback) {
   VLOG(1) << object_path_.value() << ": Connecting to service: "
@@ skipping 58 matching lines @@
   return static_cast<BluetoothAdapterChromeOS*>(adapter_);
 }
 
 void BluetoothDeviceChromeOS::GattServiceAdded(
     const dbus::ObjectPath& object_path) {
   if (GetGattService(object_path.value())) {
     VLOG(1) << "Remote GATT service already exists: " << object_path.value();
     return;
   }
 
-  BluetoothGattServiceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothGattServiceClient()->
-          GetProperties(object_path);
+  bluez::BluetoothGattServiceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()
+          ->GetBluetoothGattServiceClient()
+          ->GetProperties(object_path);
   DCHECK(properties);
   if (properties->device.value() != object_path_) {
     VLOG(2) << "Remote GATT service does not belong to this device.";
     return;
   }
 
   VLOG(1) << "Adding new remote GATT service for device: " << GetAddress();
 
   BluetoothRemoteGattServiceChromeOS* service =
       new BluetoothRemoteGattServiceChromeOS(adapter(), this, object_path);
@@ skipping 43 matching lines @@
                << ": Failed to get connection info: " << error_name << ": "
                << error_message;
   callback.Run(ConnectionInfo());
 }
 
 void BluetoothDeviceChromeOS::ConnectInternal(
     bool after_pairing,
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback) {
   VLOG(1) << object_path_.value() << ": Connecting";
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-      Connect(
-          object_path_,
-          base::Bind(&BluetoothDeviceChromeOS::OnConnect,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     after_pairing,
-                     callback),
-          base::Bind(&BluetoothDeviceChromeOS::OnConnectError,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     after_pairing,
-                     error_callback));
+  bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->Connect(
+      object_path_,
+      base::Bind(&BluetoothDeviceChromeOS::OnConnect,
+                 weak_ptr_factory_.GetWeakPtr(), after_pairing, callback),
+      base::Bind(&BluetoothDeviceChromeOS::OnConnectError,
+                 weak_ptr_factory_.GetWeakPtr(), after_pairing,
+                 error_callback));
 }
 
 void BluetoothDeviceChromeOS::OnConnect(bool after_pairing,
                                         const base::Closure& callback) {
   if (--num_connecting_calls_ == 0)
     adapter()->NotifyDeviceChanged(this);
 
   DCHECK(num_connecting_calls_ >= 0);
   VLOG(1) << object_path_.value() << ": Connected, " << num_connecting_calls_
         << " still in progress";
@@ skipping 95 matching lines @@
     const std::string& error_message) {
   LOG(WARNING) << object_path_.value() << ": Failed to cancel pairing: "
                << error_name << ": " << error_message;
 }
 
 void BluetoothDeviceChromeOS::SetTrusted() {
   // Unconditionally send the property change, rather than checking the value
   // first; there's no harm in doing this and it solves any race conditions
   // with the property becoming true or false and this call happening before
   // we get the D-Bus signal about the earlier change.
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-      GetProperties(object_path_)->trusted.Set(
-          true,
-          base::Bind(&BluetoothDeviceChromeOS::OnSetTrusted,
-                     weak_ptr_factory_.GetWeakPtr()));
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothDeviceClient()
+      ->GetProperties(object_path_)
+      ->trusted.Set(true, base::Bind(&BluetoothDeviceChromeOS::OnSetTrusted,
+                                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothDeviceChromeOS::OnSetTrusted(bool success) {
   LOG_IF(WARNING, !success) << object_path_.value()
                             << ": Failed to set device as trusted";
 }
 
 void BluetoothDeviceChromeOS::OnDisconnect(const base::Closure& callback) {
   VLOG(1) << object_path_.value() << ": Disconnected";
   callback.Run();
@@ skipping 11 matching lines @@
 void BluetoothDeviceChromeOS::OnForgetError(
     const ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   LOG(WARNING) << object_path_.value() << ": Failed to remove device: "
                << error_name << ": " << error_message;
   error_callback.Run();
 }
 
 }  // namespace chromeos