Add functionality to Bluetooth settings UI.

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 <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ skipping 27 matching lines @@
 // 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;
 
+const char kPairingMethodNone[] = "None";
+const char kPairingMethodPinCode[] = "PIN Code";
+const char kPairingMethodPassKey[] = "PassKey";
+const char kTestPinCode[] = "123456";
+
+const int kSimulatedPairTimeMultiplierFour = 4;
+const int kSimulatedPairTimeMultiplierFortyFive = 45;
+const int kSimulatedPairTimeMultiplierSeven = 7;
+const int kSimulatedPairTimeMultiplierThirty = 30;
+const int kSimulatedPairTimeMultiplierThree = 3;

[stevenjb, 2015/07/31 16:49:33]

Instead of using undescriptive names like Four, we should use names associated
with where these are used, e.g. kSimulatedPairVanishingTime.

We should also put a comment at the top like:

// These times are multiplied by kSimulationIntervalMs which can
// be changed to slow down or speed up the simulated behavior.

+const int kTestPassKey = 123456;
 
 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 161 matching lines @@
     dbus::PropertySet::SetCallback callback) {
   VLOG(1) << "Set " << property->name();
   if (property->name() == trusted.name()) {
     callback.Run(true);
     property->ReplaceValueWithSetValue();
   } else {
     callback.Run(false);
   }
 }
 
+FakeBluetoothDeviceClient::IncomingDeviceProperties::IncomingDeviceProperties()
+    : device_class(0), is_trusted(true) {}
+
+FakeBluetoothDeviceClient::IncomingDeviceProperties::
+    ~IncomingDeviceProperties() {}
+
 FakeBluetoothDeviceClient::FakeBluetoothDeviceClient()
     : simulation_interval_ms_(kSimulationIntervalMs),
       discovery_simulation_step_(0),
       incoming_pairing_simulation_step_(0),
       pairing_cancelled_(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)));
+  scoped_ptr<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);
   properties->adapter.ReplaceValue(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
   std::vector<std::string> uuids;
   uuids.push_back("00001800-0000-1000-8000-00805f9b34fb");
   uuids.push_back("00001801-0000-1000-8000-00805f9b34fb");
   properties->uuids.ReplaceValue(uuids);
 
   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
 
-  properties_map_[dbus::ObjectPath(kPairedDevicePath)] = properties;
+  properties_map_.insert(dbus::ObjectPath(kPairedDevicePath),
+                         properties.Pass());
   device_list_.push_back(dbus::ObjectPath(kPairedDevicePath));
 
-  properties = new Properties(base::Bind(
+  properties.reset(new Properties(base::Bind(
       &FakeBluetoothDeviceClient::OnPropertyChanged, base::Unretained(this),
-      dbus::ObjectPath(kPairedUnconnectableDevicePath)));
+      dbus::ObjectPath(kPairedUnconnectableDevicePath))));
   properties->address.ReplaceValue(kPairedUnconnectableDeviceAddress);
   properties->bluetooth_class.ReplaceValue(kPairedUnconnectableDeviceClass);
   properties->name.ReplaceValue("Fake Device 2 (Unconnectable)");
   properties->alias.ReplaceValue(kPairedUnconnectableDeviceName);
   properties->paired.ReplaceValue(true);
   properties->trusted.ReplaceValue(true);
   properties->adapter.ReplaceValue(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
   properties->uuids.ReplaceValue(uuids);
 
   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
 
-  properties_map_[dbus::ObjectPath(kPairedUnconnectableDevicePath)] =
-      properties;
+  properties_map_.insert(dbus::ObjectPath(kPairedUnconnectableDevicePath),
+                         properties.Pass());
   device_list_.push_back(dbus::ObjectPath(kPairedUnconnectableDevicePath));
 }
 
 FakeBluetoothDeviceClient::~FakeBluetoothDeviceClient() {
-  // Clean up Properties structures
-  STLDeleteValues(&properties_map_);
 }
 
 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) {
-  PropertiesMap::iterator iter = properties_map_.find(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) {
   VLOG(1) << "Connect: " << object_path.value();
   Properties* properties = GetProperties(object_path);
 
   if (properties->connected.value() == true) {
     // Already connected.
     callback.Run();
@@ skipping 211 matching lines @@
 void FakeBluetoothDeviceClient::BeginIncomingPairingSimulation(
     const dbus::ObjectPath& adapter_path) {
   VLOG(1) << "starting incoming pairing simulation";
 
   incoming_pairing_simulation_step_ = 1;
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeBluetoothDeviceClient::IncomingPairingSimulationTimer,
                  base::Unretained(this)),
-      base::TimeDelta::FromMilliseconds(30 * simulation_interval_ms_));
+      base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierThirty *
+                                        simulation_interval_ms_));
 }
 
 void FakeBluetoothDeviceClient::EndIncomingPairingSimulation(
     const dbus::ObjectPath& adapter_path) {
   VLOG(1) << "stopping incoming pairing simulation";
   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())
     return;
 
-  Properties* properties = new Properties(base::Bind(
-      &FakeBluetoothDeviceClient::OnPropertyChanged,
-      base::Unretained(this),
-      device_path));
+  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);
     properties->name.ReplaceValue("LegacyAutopair");
     properties->alias.ReplaceValue(kLegacyAutopairName);
 
     std::vector<std::string> uuids;
     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
@@ skipping 79 matching lines @@
 
     std::vector<std::string> uuids;
     uuids.push_back(FakeBluetoothGattServiceClient::kHeartRateServiceUUID);
     properties->uuids.ReplaceValue(uuids);
 
   } else {
     NOTREACHED();
 
   }
 
-  properties_map_[device_path] = properties;
+  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,
+    const IncomingDeviceProperties& props) {
+  dbus::ObjectPath device_path(props.device_path);
+  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);
+  properties->name.ReplaceValue(props.device_name);
+  properties->alias.ReplaceValue(props.device_alias);
+  properties->address.ReplaceValue(props.device_address);
+  properties->bluetooth_class.ReplaceValue(props.device_class);
+  properties->trusted.ReplaceValue(props.is_trusted);
+
+  if (props.is_trusted)
+    properties->paired.ReplaceValue(true);
+
+  scoped_ptr<SimulatedPairingOptions> options(new SimulatedPairingOptions);
+  options->pairing_method = props.pairing_method;
+  options->pairing_auth_token = props.pairing_auth_token;
+
+  properties_map_.insert(device_path, properties.Pass());
+  device_list_.push_back(device_path);
+  pairing_options_map_.insert(device_path, options.Pass());
+  FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
+                    DeviceAdded(device_path));
+}
 
 void FakeBluetoothDeviceClient::RemoveDevice(
     const dbus::ObjectPath& adapter_path,
     const dbus::ObjectPath& device_path) {
   std::vector<dbus::ObjectPath>::iterator listiter =
       std::find(device_list_.begin(), device_list_.end(), device_path);
   if (listiter == device_list_.end())
     return;
 
-  PropertiesMap::iterator iter = properties_map_.find(device_path);
+  PropertiesMap::const_iterator iter = properties_map_.find(device_path);
   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*>(
@@ skipping 144 matching lines @@
       break;
     default:
       return;
   }
 
   ++incoming_pairing_simulation_step_;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeBluetoothDeviceClient::IncomingPairingSimulationTimer,
                  base::Unretained(this)),
-      base::TimeDelta::FromMilliseconds(45 * simulation_interval_ms_));
+      base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierFortyFive *
+                                        simulation_interval_ms_));
 }
 
 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());
   FakeBluetoothAgentServiceProvider* agent_service_provider =
       fake_bluetooth_agent_manager_client->GetAgentServiceProvider();
   CHECK(agent_service_provider != NULL);
 
-  if (object_path == dbus::ObjectPath(kLegacyAutopairPath) ||
-      object_path == dbus::ObjectPath(kConnectUnpairablePath) ||
-      object_path == dbus::ObjectPath(kUnconnectableDevicePath) ||
-      object_path == dbus::ObjectPath(kLowEnergyPath)) {
-    // No need to call anything on the pairing delegate, just wait 3 times
-    // the interval before acting as if the other end accepted it.
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
-                   base::Unretained(this), object_path, callback,
-                   error_callback),
-        base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
+  // Grab the device's pairing properties.
+  PairingOptionsMap::const_iterator iter =
+      pairing_options_map_.find(object_path);
 
-  } else if (object_path == dbus::ObjectPath(kDisplayPinCodePath)) {
-    // Display a Pincode, and wait 7 times the interval before acting as
-    // if the other end accepted it.
-    agent_service_provider->DisplayPinCode(object_path, "123456");
+  // If the device with path |object_path| has simulated pairing properties
+  // defined, then pair it based on its |pairing_method|.
+  if (iter != pairing_options_map_.end()) {
+    if (iter->second->pairing_method == kPairingMethodNone ||
+        iter->second->pairing_method == "") {

[stevenjb, 2015/07/31 16:49:33]

nit: iter->second->pairing_method.empty()

+      // Simply pair and connect the device.
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
+                     base::Unretained(this), object_path, callback,
+                     error_callback),
+          base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierThree *
+                                            simulation_interval_ms_));
+    } else if (iter->second->pairing_method == kPairingMethodPinCode) {
+      // Display a Pincode, and wait 7 times the interval before acting as

[stevenjb, 2015/07/31 16:49:33]

nit: We should remove any hard coded values from the comments too, e.g.
// Display a Pincode, and wait before acting...

+      // if the other end accepted it.
+      agent_service_provider->DisplayPinCode(object_path,
+                                             iter->second->pairing_auth_token);
 
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
-                   base::Unretained(this), object_path, callback,
-                   error_callback),
-        base::TimeDelta::FromMilliseconds(7 * simulation_interval_ms_));
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
+                     base::Unretained(this), object_path, callback,
+                     error_callback),
+          base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierSeven *
+                                            simulation_interval_ms_));
+    } else if (iter->second->pairing_method == kPairingMethodPassKey) {
+      // Display a passkey, and each interval act as if another key was entered
+      // for it.
+      agent_service_provider->DisplayPasskey(
+          object_path, std::stoi(iter->second->pairing_auth_token), 0);
 
-  } else if (object_path == dbus::ObjectPath(kVanishingDevicePath)) {
-    // The vanishing device simulates being too far away, and thus times out.
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&FakeBluetoothDeviceClient::TimeoutSimulatedPairing,
-                   base::Unretained(this), object_path, error_callback),
-        base::TimeDelta::FromMilliseconds(4 * simulation_interval_ms_));
-
-  } else if (object_path == dbus::ObjectPath(kDisplayPasskeyPath)) {
-    // Display a passkey, and each interval act as if another key was entered
-    // for it.
-    agent_service_provider->DisplayPasskey(object_path, 123456, 0);
-
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE, base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress,
-                              base::Unretained(this), 1, object_path, callback,
-                              error_callback),
-        base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
-
-  } else if (object_path == dbus::ObjectPath(kRequestPinCodePath)) {
-    // Request a Pincode.
-    agent_service_provider->RequestPinCode(
-        object_path,
-        base::Bind(&FakeBluetoothDeviceClient::PinCodeCallback,
-                   base::Unretained(this),
-                   object_path,
-                   callback,
-                   error_callback));
-
-  } else if (object_path == dbus::ObjectPath(kConfirmPasskeyPath)) {
-    // Request confirmation of a Passkey.
-    agent_service_provider->RequestConfirmation(
-        object_path, 123456,
-        base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback,
-                   base::Unretained(this),
-                   object_path,
-                   callback,
-                   error_callback));
-
-  } else if (object_path == dbus::ObjectPath(kRequestPasskeyPath)) {
-    // Request a Passkey from the user.
-    agent_service_provider->RequestPasskey(
-        object_path,
-        base::Bind(&FakeBluetoothDeviceClient::PasskeyCallback,
-                   base::Unretained(this),
-                   object_path,
-                   callback,
-                   error_callback));
-
-  } else if (object_path == dbus::ObjectPath(kUnpairableDevicePath)) {
-    // Fails the pairing with an org.bluez.Error.Failed error.
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&FakeBluetoothDeviceClient::FailSimulatedPairing,
-                   base::Unretained(this), object_path, error_callback),
-        base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
-
-  } else if (object_path == dbus::ObjectPath(kJustWorksPath)) {
-    if (incoming_request) {
-      agent_service_provider->RequestAuthorization(
-          object_path,
-          base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback,
-                     base::Unretained(this),
-                     object_path,
-                     callback,
-                     error_callback));
-
-    } else {
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE, base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress,
+                                base::Unretained(this), 1, object_path,
+                                callback, error_callback),
+          base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
+    }
+  } else {
+    if (object_path == dbus::ObjectPath(kLegacyAutopairPath) ||
+        object_path == dbus::ObjectPath(kConnectUnpairablePath) ||
+        object_path == dbus::ObjectPath(kUnconnectableDevicePath) ||
+        object_path == dbus::ObjectPath(kLowEnergyPath)) {
       // No need to call anything on the pairing delegate, just wait 3 times
       // the interval before acting as if the other end accepted it.
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                      base::Unretained(this), object_path, callback,
                      error_callback),
-          base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
+          base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierThree *
+                                            simulation_interval_ms_));
+
+    } else if (object_path == dbus::ObjectPath(kDisplayPinCodePath)) {
+      // Display a Pincode, and wait 7 times the interval before acting as
+      // if the other end accepted it.
+      agent_service_provider->DisplayPinCode(object_path, kTestPinCode);
+
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
+                     base::Unretained(this), object_path, callback,
+                     error_callback),
+          base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierSeven *
+                                            simulation_interval_ms_));
+
+    } else if (object_path == dbus::ObjectPath(kVanishingDevicePath)) {
+      // The vanishing device simulates being too far away, and thus times out.
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&FakeBluetoothDeviceClient::TimeoutSimulatedPairing,
+                     base::Unretained(this), object_path, error_callback),
+          base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierFour *
+                                            simulation_interval_ms_));
+
+    } else if (object_path == dbus::ObjectPath(kDisplayPasskeyPath)) {
+      // Display a passkey, and each interval act as if another key was entered
+      // for it.
+      agent_service_provider->DisplayPasskey(object_path, kTestPassKey, 0);
+
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE, base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress,
+                                base::Unretained(this), 1, object_path,
+                                callback, error_callback),
+          base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
+
+    } else if (object_path == dbus::ObjectPath(kRequestPinCodePath)) {
+      // Request a Pincode.
+      agent_service_provider->RequestPinCode(
+          object_path, base::Bind(&FakeBluetoothDeviceClient::PinCodeCallback,
+                                  base::Unretained(this), object_path, callback,
+                                  error_callback));
+
+    } else if (object_path == dbus::ObjectPath(kConfirmPasskeyPath)) {
+      // Request confirmation of a Passkey.
+      agent_service_provider->RequestConfirmation(
+          object_path, kTestPassKey,
+          base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback,
+                     base::Unretained(this), object_path, callback,
+                     error_callback));
+
+    } else if (object_path == dbus::ObjectPath(kRequestPasskeyPath)) {
+      // Request a Passkey from the user.
+      agent_service_provider->RequestPasskey(
+          object_path, base::Bind(&FakeBluetoothDeviceClient::PasskeyCallback,
+                                  base::Unretained(this), object_path, callback,
+                                  error_callback));
+
+    } else if (object_path == dbus::ObjectPath(kUnpairableDevicePath)) {
+      // Fails the pairing with an org.bluez.Error.Failed error.
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&FakeBluetoothDeviceClient::FailSimulatedPairing,
+                     base::Unretained(this), object_path, error_callback),
+          base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
+
+    } else if (object_path == dbus::ObjectPath(kJustWorksPath)) {
+      if (incoming_request) {
+        agent_service_provider->RequestAuthorization(
+            object_path,
+            base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback,
+                       base::Unretained(this), object_path, callback,
+                       error_callback));
+
+      } else {
+        // No need to call anything on the pairing delegate, just wait 3 times
+        // the interval before acting as if the other end accepted it.
+        base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+            FROM_HERE,
+            base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
+                       base::Unretained(this), object_path, callback,
+                       error_callback),
+            base::TimeDelta::FromMilliseconds(
+                kSimulatedPairTimeMultiplierThree * simulation_interval_ms_));
+      }
+
+    } else {
+      error_callback.Run(kNoResponseError, "No pairing fake");
     }
-
-  } else {
-    error_callback.Run(kNoResponseError, "No pairing fake");
   }
 }
 
 void FakeBluetoothDeviceClient::CompleteSimulatedPairing(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "CompleteSimulatedPairing: " << object_path.value();
   if (pairing_cancelled_) {
     pairing_cancelled_ = false;
@@ skipping 54 matching lines @@
       static_cast<FakeBluetoothInputClient*>(
           DBusThreadManager::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::iterator iter = properties_map_.find(object_path);
+  PropertiesMap::const_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(
@@ skipping 12 matching lines @@
     BluetoothAgentServiceProvider::Delegate::Status status,
     const std::string& pincode) {
   VLOG(1) << "PinCodeCallback: " << object_path.value();
 
   if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this), object_path, callback,
                    error_callback),
-        base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
+        base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierThree *
+                                          simulation_interval_ms_));
 
   } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
                    base::Unretained(this), object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
@@ skipping 11 matching lines @@
     BluetoothAgentServiceProvider::Delegate::Status status,
     uint32 passkey) {
   VLOG(1) << "PasskeyCallback: " << object_path.value();
 
   if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this), object_path, callback,
                    error_callback),
-        base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
+        base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierThree *
+                                          simulation_interval_ms_));
 
   } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
                    base::Unretained(this), object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
@@ skipping 10 matching lines @@
     const ErrorCallback& error_callback,
     BluetoothAgentServiceProvider::Delegate::Status status) {
   VLOG(1) << "ConfirmationCallback: " << object_path.value();
 
   if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this), object_path, callback,
                    error_callback),
-        base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
+        base::TimeDelta::FromMilliseconds(kSimulatedPairTimeMultiplierThree *
+                                          simulation_interval_ms_));
 
   } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
                    base::Unretained(this), object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
@@ skipping 15 matching lines @@
       static_cast<FakeBluetoothAgentManagerClient*>(
           DBusThreadManager::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, 123456, entered);
+  agent_service_provider->DisplayPasskey(object_path, kTestPassKey, entered);
 
   if (entered < 7) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress,
                               base::Unretained(this), entered + 1, object_path,
                               callback, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
@@ skipping 34 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