bluetooth: Add adapter to BluetoothDevice

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"
@@ skipping 107 matching lines @@
 
 }  // namespace
 
 namespace chromeos {
 
 BluetoothDeviceChromeOS::BluetoothDeviceChromeOS(
     BluetoothAdapterChromeOS* adapter,
     const dbus::ObjectPath& object_path,
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<device::BluetoothSocketThread> socket_thread)
-    : adapter_(adapter),
+    : 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);
 
   // Add all known GATT services.
   const std::vector<dbus::ObjectPath> gatt_services =
       DBusThreadManager::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);
 
   // 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(
+    adapter()->NotifyGattServiceRemoved(
         static_cast<BluetoothRemoteGattServiceChromeOS*>(iter->second));
     delete iter->second;
   }
 }
 
 uint32 BluetoothDeviceChromeOS::GetBluetoothClass() const {
   BluetoothDeviceClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothDeviceClient()->
           GetProperties(object_path_);
   DCHECK(properties);
@@ skipping 143 matching lines @@
                                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);
+    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);
@@ skipping 73 matching lines @@
           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(
-          adapter_->object_path(),
-          object_path_,
-          base::Bind(&base::DoNothing),
-          base::Bind(&BluetoothDeviceChromeOS::OnForgetError,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     error_callback));
+  DBusThreadManager::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: "
           << uuid.canonical_value();
   scoped_refptr<BluetoothSocketChromeOS> socket =
       BluetoothSocketChromeOS::CreateBluetoothSocket(
@@ skipping 44 matching lines @@
 }
 
 void BluetoothDeviceChromeOS::EndPairing() {
   pairing_.reset();
 }
 
 BluetoothPairingChromeOS* BluetoothDeviceChromeOS::GetPairing() const {
   return pairing_.get();
 }
 
+BluetoothAdapterChromeOS* BluetoothDeviceChromeOS::adapter() const {
+  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);
   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);
+      new BluetoothRemoteGattServiceChromeOS(adapter(), this, object_path);
 
   gatt_services_[service->GetIdentifier()] = service;
   DCHECK(service->object_path() == object_path);
   DCHECK(service->GetUUID().IsValid());
 
   DCHECK(adapter_);
-  adapter_->NotifyGattServiceAdded(service);
+  adapter()->NotifyGattServiceAdded(service);
 }
 
 void BluetoothDeviceChromeOS::GattServiceRemoved(
     const dbus::ObjectPath& object_path) {
   GattServiceMap::iterator iter = gatt_services_.find(object_path.value());
   if (iter == gatt_services_.end()) {
     VLOG(3) << "Unknown GATT service removed: " << object_path.value();
     return;
   }
 
   VLOG(1) << "Removing remote GATT service from device: " << GetAddress();
 
   BluetoothRemoteGattServiceChromeOS* service =
       static_cast<BluetoothRemoteGattServiceChromeOS*>(iter->second);
   DCHECK(service->object_path() == object_path);
   gatt_services_.erase(iter);
 
   DCHECK(adapter_);
-  adapter_->NotifyGattServiceRemoved(service);
+  adapter()->NotifyGattServiceRemoved(service);
 
   delete service;
 }
 
 void BluetoothDeviceChromeOS::OnGetConnInfo(
     const ConnectionInfoCallback& callback,
     int16 rssi,
     int16 transmit_power,
     int16 max_transmit_power) {
   callback.Run(ConnectionInfo(rssi, transmit_power, max_transmit_power));
@@ skipping 23 matching lines @@
                      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);
+    adapter()->NotifyDeviceChanged(this);
 
   DCHECK(num_connecting_calls_ >= 0);
   VLOG(1) << object_path_.value() << ": Connected, " << num_connecting_calls_
         << " still in progress";
 
   SetTrusted();
 
   if (after_pairing)
     UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingResult",
                               UMA_PAIRING_RESULT_SUCCESS,
                               UMA_PAIRING_RESULT_COUNT);
 
   callback.Run();
 }
 
 void BluetoothDeviceChromeOS::OnCreateGattConnection(
     const GattConnectionCallback& callback) {
   scoped_ptr<device::BluetoothGattConnection> conn(
       new BluetoothGattConnectionChromeOS(
           adapter_, GetAddress(), object_path_));
   callback.Run(conn.Pass());
 }
 
 void BluetoothDeviceChromeOS::OnConnectError(
     bool after_pairing,
     const ConnectErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   if (--num_connecting_calls_ == 0)
-    adapter_->NotifyDeviceChanged(this);
+    adapter()->NotifyDeviceChanged(this);
 
   DCHECK(num_connecting_calls_ >= 0);
   LOG(WARNING) << object_path_.value() << ": Failed to connect device: "
                << error_name << ": " << error_message;
   VLOG(1) << object_path_.value() << ": " << num_connecting_calls_
           << " still in progress";
 
   // Determine the error code from error_name.
   ConnectErrorCode error_code = ERROR_UNKNOWN;
   if (error_name == bluetooth_device::kErrorFailed) {
@@ skipping 17 matching lines @@
   EndPairing();
 
   ConnectInternal(true, callback, error_callback);
 }
 
 void BluetoothDeviceChromeOS::OnPairError(
     const ConnectErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   if (--num_connecting_calls_ == 0)
-    adapter_->NotifyDeviceChanged(this);
+    adapter()->NotifyDeviceChanged(this);
 
   DCHECK(num_connecting_calls_ >= 0);
   LOG(WARNING) << object_path_.value() << ": Failed to pair device: "
                << error_name << ": " << error_message;
   VLOG(1) << object_path_.value() << ": " << num_connecting_calls_
           << " still in progress";
 
   EndPairing();
 
   // Determine the error code from error_name.
@@ skipping 57 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