Add GetConnectionInfo function for BluetoothDevice, replacing the existing

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 194 matching lines @@
   ParseModalias(object_path_, NULL, NULL, &product_id, NULL);
   return product_id;
 }
 
 uint16 BluetoothDeviceChromeOS::GetDeviceID() const {
   uint16 device_id  = 0;
   ParseModalias(object_path_, NULL, NULL, NULL, &device_id);
   return device_id;
 }
 
-int BluetoothDeviceChromeOS::GetRSSI() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->GetProperties(
-          object_path_);
-  DCHECK(properties);
-
-  if (!IsConnected()) {
-    NOTIMPLEMENTED();
-    return kUnknownPower;
-  }
-
-  return connection_monitor_started_ ? properties->connection_rssi.value()
-                                     : kUnknownPower;
-}
-
-int BluetoothDeviceChromeOS::GetCurrentHostTransmitPower() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->GetProperties(
-          object_path_);
-  DCHECK(properties);
-
-  return IsConnected() && connection_monitor_started_
-             ? properties->connection_tx_power.value()
-             : kUnknownPower;
-}
-
-int BluetoothDeviceChromeOS::GetMaximumHostTransmitPower() const {
-  BluetoothDeviceClient::Properties* properties =
-      DBusThreadManager::Get()->GetBluetoothDeviceClient()->GetProperties(
-          object_path_);
-  DCHECK(properties);
-
-  return IsConnected() ? properties->connection_tx_power_max.value()
-                       : kUnknownPower;
-}
-
 bool BluetoothDeviceChromeOS::IsPaired() const {
   BluetoothDeviceClient::Properties* properties =
       DBusThreadManager::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();
@@ skipping 46 matching lines @@
 }
 
 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(
+      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";
 
@@ skipping 127 matching lines @@
       const ConnectErrorCallback& error_callback) {
   // TODO(armansito): Until there is a way to create a reference counted GATT
   // connection in bluetoothd, simply do a regular connect.
   Connect(NULL,
           base::Bind(&BluetoothDeviceChromeOS::OnCreateGattConnection,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback),
           error_callback);
 }
 
-void BluetoothDeviceChromeOS::StartConnectionMonitor(
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->StartConnectionMonitor(
-      object_path_,
-      base::Bind(&BluetoothDeviceChromeOS::OnStartConnectionMonitor,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback),
-      base::Bind(&BluetoothDeviceChromeOS::OnStartConnectionMonitorError,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 error_callback));
-}
-
 BluetoothPairingChromeOS* BluetoothDeviceChromeOS::BeginPairing(
     BluetoothDevice::PairingDelegate* pairing_delegate) {
   pairing_.reset(new BluetoothPairingChromeOS(this, pairing_delegate));
   return pairing_.get();
 }
 
 void BluetoothDeviceChromeOS::EndPairing() {
   pairing_.reset();
 }
 
@@ skipping 44 matching lines @@
       static_cast<BluetoothRemoteGattServiceChromeOS*>(iter->second);
   DCHECK(service->object_path() == object_path);
   gatt_services_.erase(iter);
 
   DCHECK(adapter_);
   adapter_->NotifyGattServiceRemoved(service);
 
   delete service;
 }
 
+void BluetoothDeviceChromeOS::OnGetConnInfo(

[Ilya Sherman, 2014/11/19 22:18:07]

nit: "Conn" -> "Connection"; ditto below (though I guess you've chosen this name
to match the DBUS API name; I'd prefer to rename that too, but if that's not
feasible, then maybe consistency with that name is more important).

[Tim Song, 2014/12/06 00:51:37]

The kernel mgmt API was called GetConnInfo, which I copied for the plugin. We
should keep the DBus API name consistent everywhere, and at this point, it would
be too much of a hassle to change the name.

+    const ConnectionInfoCallback& callback,
+    int16 rssi,
+    int16 transmit_power,
+    int16 max_transmit_power) {
+  callback.Run(ConnectionInfo(rssi, transmit_power, max_transmit_power));
+}
+
+void BluetoothDeviceChromeOS::OnGetConnInfoError(
+    const ConnectionInfoCallback& callback,
+    const std::string& error_name,
+    const std::string& error_message) {
+  LOG(WARNING) << object_path_.value()
+               << ": 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(),
@@ skipping 123 matching lines @@
           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::OnStartConnectionMonitor(
-    const base::Closure& callback) {
-  connection_monitor_started_ = true;
-  callback.Run();
-}
-
-void BluetoothDeviceChromeOS::OnStartConnectionMonitorError(
-    const ErrorCallback& error_callback,
-    const std::string& error_name,
-    const std::string& error_message) {
-  LOG(WARNING) << object_path_.value()
-               << ": Failed to start connection monitor: " << error_name << ": "
-               << error_message;
-  error_callback.Run();
-}
-
 void BluetoothDeviceChromeOS::OnDisconnect(const base::Closure& callback) {
   VLOG(1) << object_path_.value() << ": Disconnected";
   callback.Run();
 }
 
 void BluetoothDeviceChromeOS::OnDisconnectError(
     const ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   LOG(WARNING) << object_path_.value() << ": Failed to disconnect device: "
                << error_name << ": " << error_message;
   error_callback.Run();
 }
 
 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