Add GetConnectionInfo function for BluetoothDevice, replacing the existing

chromeos/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 <fcntl.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
@@ skipping 26 matching lines @@
 
 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;
 
+// The default value of connection info properties from GetConnInfo().
+const int kUnkownPower = 127;
+
 
 void SimulatedProfileSocket(int fd) {
   // Simulate a server-side socket of a profile; read data from the socket,
   // write it back, and then close.
   char buf[1024];
   ssize_t len;
   ssize_t count;
 
   len = read(fd, buf, sizeof buf);
   if (len < 0) {
@@ skipping 157 matching lines @@
   } else {
     callback.Run(false);
   }
 }
 
 FakeBluetoothDeviceClient::FakeBluetoothDeviceClient()
     : simulation_interval_ms_(kSimulationIntervalMs),
       discovery_simulation_step_(0),
       incoming_pairing_simulation_step_(0),
       pairing_cancelled_(false),
-      connection_monitor_started_(false) {
+      connection_rssi_(kUnkownPower),
+      transmit_power_(kUnkownPower),
+      max_transmit_power_(kUnkownPower) {
   Properties* properties = new Properties(base::Bind(
       &FakeBluetoothDeviceClient::OnPropertyChanged,
       base::Unretained(this),
       dbus::ObjectPath(kPairedDevicePath)));
   properties->address.ReplaceValue(kPairedDeviceAddress);
   properties->bluetooth_class.ReplaceValue(kPairedDeviceClass);
   properties->name.ReplaceValue("Fake Device (Name)");
   properties->alias.ReplaceValue(kPairedDeviceName);
   properties->paired.ReplaceValue(true);
   properties->trusted.ReplaceValue(true);
@@ skipping 219 matching lines @@
 
 void FakeBluetoothDeviceClient::CancelPairing(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "CancelPairing: " << object_path.value();
   pairing_cancelled_ = true;
   callback.Run();
 }
 
-void FakeBluetoothDeviceClient::StartConnectionMonitor(
+void FakeBluetoothDeviceClient::GetConnInfo(
     const dbus::ObjectPath& object_path,
-    const base::Closure& callback,
+    const ConnInfoCallback& callback,
     const ErrorCallback& error_callback) {
-  VLOG(1) << "StartConnectionMonitor: " << object_path.value();
-  connection_monitor_started_ = true;
-  callback.Run();
-}
+  Properties* properties = GetProperties(object_path);
+  if (!properties->connected.value()) {
+    error_callback.Run("org.bluez.Error.NotConnected", "Not Connected");
+    return;
+  }
 
-void FakeBluetoothDeviceClient::StopConnectionMonitor(
-    const dbus::ObjectPath& object_path,
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
-  connection_monitor_started_ = false;
-  callback.Run();
+  callback.Run(connection_rssi_, transmit_power_, max_transmit_power_);
 }
 
 void FakeBluetoothDeviceClient::BeginDiscoverySimulation(
     const dbus::ObjectPath& adapter_path) {
   VLOG(1) << "starting discovery simulation";
 
   discovery_simulation_step_ = 1;
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
@@ skipping 523 matching lines @@
   PropertiesMap::iterator iter = properties_map_.find(object_path);
   if (iter == properties_map_.end()) {
     VLOG(2) << "Fake device does not exist: " << object_path.value();
     return;
   }
   Properties* properties = iter->second;
   DCHECK(properties);
   properties->rssi.ReplaceValue(rssi);
 }
 
+void FakeBluetoothDeviceClient::UpdateConnectionInfo(
+    uint16 connection_rssi,
+    uint16 transmit_power,
+    uint16 max_transmit_power) {
+  connection_rssi_ = connection_rssi;
+  transmit_power_ = transmit_power;
+  max_transmit_power_ = max_transmit_power;
+}
+
 void FakeBluetoothDeviceClient::PinCodeCallback(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     BluetoothAgentServiceProvider::Delegate::Status status,
     const std::string& pincode) {
   VLOG(1) << "PinCodeCallback: " << object_path.value();
 
   if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) {
     base::MessageLoop::current()->PostDelayedTask(
@@ skipping 159 matching lines @@
     // 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