Home | History | Annotate | Download | only in dbus 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chromeos/dbus/fake_bluetooth_device_client.h"
      6 
      7 #include <fcntl.h>
      8 #include <unistd.h>
      9 #include <sys/types.h>
     10 #include <sys/socket.h>
     11 
     12 #include <algorithm>
     13 #include <map>
     14 #include <string>
     15 #include <utility>
     16 #include <vector>
     17 
     18 #include "base/bind.h"
     19 #include "base/logging.h"
     20 #include "base/memory/scoped_ptr.h"
     21 #include "base/message_loop/message_loop.h"
     22 #include "base/rand_util.h"
     23 #include "base/stl_util.h"
     24 #include "base/threading/worker_pool.h"
     25 #include "base/time/time.h"
     26 #include "chromeos/dbus/dbus_thread_manager.h"
     27 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
     28 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
     29 #include "chromeos/dbus/fake_bluetooth_agent_service_provider.h"
     30 #include "chromeos/dbus/fake_bluetooth_gatt_service_client.h"
     31 #include "chromeos/dbus/fake_bluetooth_input_client.h"
     32 #include "chromeos/dbus/fake_bluetooth_profile_manager_client.h"
     33 #include "chromeos/dbus/fake_bluetooth_profile_service_provider.h"
     34 #include "dbus/file_descriptor.h"
     35 #include "dbus/object_path.h"
     36 #include "third_party/cros_system_api/dbus/service_constants.h"
     37 
     38 namespace {
     39 
     40 // Default interval between simulated events.
     41 const int kSimulationIntervalMs = 750;
     42 
     43 // Minimum and maximum bounds for randomly generated RSSI values.
     44 const int kMinRSSI = -90;
     45 const int kMaxRSSI = -30;
     46 
     47 
     48 void SimulatedProfileSocket(int fd) {
     49   // Simulate a server-side socket of a profile; read data from the socket,
     50   // write it back, and then close.
     51   char buf[1024];
     52   ssize_t len;
     53   ssize_t count;
     54 
     55   len = read(fd, buf, sizeof buf);
     56   if (len < 0) {
     57     close(fd);
     58     return;
     59   }
     60 
     61   count = len;
     62   len = write(fd, buf, count);
     63   if (len < 0) {
     64     close(fd);
     65     return;
     66   }
     67 
     68   close(fd);
     69 }
     70 
     71 void SimpleErrorCallback(const std::string& error_name,
     72                          const std::string& error_message) {
     73   VLOG(1) << "Bluetooth Error: " << error_name << ": " << error_message;
     74 }
     75 
     76 }  // namespace
     77 
     78 namespace chromeos {
     79 
     80 const char FakeBluetoothDeviceClient::kPairedDevicePath[] =
     81     "/fake/hci0/dev0";
     82 const char FakeBluetoothDeviceClient::kPairedDeviceAddress[] =
     83     "00:11:22:33:44:55";
     84 const char FakeBluetoothDeviceClient::kPairedDeviceName[] =
     85     "Fake Device";
     86 const uint32 FakeBluetoothDeviceClient::kPairedDeviceClass = 0x000104;
     87 
     88 const char FakeBluetoothDeviceClient::kLegacyAutopairPath[] =
     89     "/fake/hci0/dev1";
     90 const char FakeBluetoothDeviceClient::kLegacyAutopairAddress[] =
     91     "28:CF:DA:00:00:00";
     92 const char FakeBluetoothDeviceClient::kLegacyAutopairName[] =
     93     "Bluetooth 2.0 Mouse";
     94 const uint32 FakeBluetoothDeviceClient::kLegacyAutopairClass = 0x002580;
     95 
     96 const char FakeBluetoothDeviceClient::kDisplayPinCodePath[] =
     97     "/fake/hci0/dev2";
     98 const char FakeBluetoothDeviceClient::kDisplayPinCodeAddress[] =
     99     "28:37:37:00:00:00";
    100 const char FakeBluetoothDeviceClient::kDisplayPinCodeName[] =
    101     "Bluetooth 2.0 Keyboard";
    102 const uint32 FakeBluetoothDeviceClient::kDisplayPinCodeClass = 0x002540;
    103 
    104 const char FakeBluetoothDeviceClient::kVanishingDevicePath[] =
    105     "/fake/hci0/dev3";
    106 const char FakeBluetoothDeviceClient::kVanishingDeviceAddress[] =
    107     "01:02:03:04:05:06";
    108 const char FakeBluetoothDeviceClient::kVanishingDeviceName[] =
    109     "Vanishing Device";
    110 const uint32 FakeBluetoothDeviceClient::kVanishingDeviceClass = 0x000104;
    111 
    112 const char FakeBluetoothDeviceClient::kConnectUnpairablePath[] =
    113     "/fake/hci0/dev4";
    114 const char FakeBluetoothDeviceClient::kConnectUnpairableAddress[] =
    115     "7C:ED:8D:00:00:00";
    116 const char FakeBluetoothDeviceClient::kConnectUnpairableName[] =
    117     "Unpairable Device";
    118 const uint32 FakeBluetoothDeviceClient::kConnectUnpairableClass = 0x002580;
    119 
    120 const char FakeBluetoothDeviceClient::kDisplayPasskeyPath[] =
    121     "/fake/hci0/dev5";
    122 const char FakeBluetoothDeviceClient::kDisplayPasskeyAddress[] =
    123     "00:0F:F6:00:00:00";
    124 const char FakeBluetoothDeviceClient::kDisplayPasskeyName[] =
    125     "Bluetooth 2.1+ Keyboard";
    126 const uint32 FakeBluetoothDeviceClient::kDisplayPasskeyClass = 0x002540;
    127 
    128 const char FakeBluetoothDeviceClient::kRequestPinCodePath[] =
    129     "/fake/hci0/dev6";
    130 const char FakeBluetoothDeviceClient::kRequestPinCodeAddress[] =
    131     "00:24:BE:00:00:00";
    132 const char FakeBluetoothDeviceClient::kRequestPinCodeName[] =
    133     "PIN Device";
    134 const uint32 FakeBluetoothDeviceClient::kRequestPinCodeClass = 0x240408;
    135 
    136 const char FakeBluetoothDeviceClient::kConfirmPasskeyPath[] =
    137     "/fake/hci0/dev7";
    138 const char FakeBluetoothDeviceClient::kConfirmPasskeyAddress[] =
    139     "20:7D:74:00:00:00";
    140 const char FakeBluetoothDeviceClient::kConfirmPasskeyName[] =
    141     "Phone";
    142 const uint32 FakeBluetoothDeviceClient::kConfirmPasskeyClass = 0x7a020c;
    143 
    144 const char FakeBluetoothDeviceClient::kRequestPasskeyPath[] =
    145     "/fake/hci0/dev8";
    146 const char FakeBluetoothDeviceClient::kRequestPasskeyAddress[] =
    147     "20:7D:74:00:00:01";
    148 const char FakeBluetoothDeviceClient::kRequestPasskeyName[] =
    149     "Passkey Device";
    150 const uint32 FakeBluetoothDeviceClient::kRequestPasskeyClass = 0x7a020c;
    151 
    152 const char FakeBluetoothDeviceClient::kUnconnectableDevicePath[] =
    153     "/fake/hci0/dev9";
    154 const char FakeBluetoothDeviceClient::kUnconnectableDeviceAddress[] =
    155     "20:7D:74:00:00:02";
    156 const char FakeBluetoothDeviceClient::kUnconnectableDeviceName[] =
    157     "Unconnectable Device";
    158 const uint32 FakeBluetoothDeviceClient::kUnconnectableDeviceClass = 0x7a020c;
    159 
    160 const char FakeBluetoothDeviceClient::kUnpairableDevicePath[] =
    161     "/fake/hci0/devA";
    162 const char FakeBluetoothDeviceClient::kUnpairableDeviceAddress[] =
    163     "20:7D:74:00:00:03";
    164 const char FakeBluetoothDeviceClient::kUnpairableDeviceName[] =
    165     "Unpairable Device";
    166 const uint32 FakeBluetoothDeviceClient::kUnpairableDeviceClass = 0x002540;
    167 
    168 const char FakeBluetoothDeviceClient::kJustWorksPath[] =
    169     "/fake/hci0/devB";
    170 const char FakeBluetoothDeviceClient::kJustWorksAddress[] =
    171     "00:0C:8A:00:00:00";
    172 const char FakeBluetoothDeviceClient::kJustWorksName[] =
    173     "Just-Works Device";
    174 const uint32 FakeBluetoothDeviceClient::kJustWorksClass = 0x240428;
    175 
    176 const char FakeBluetoothDeviceClient::kLowEnergyPath[] =
    177     "/fake/hci0/devC";
    178 const char FakeBluetoothDeviceClient::kLowEnergyAddress[] =
    179     "00:1A:11:00:15:30";
    180 const char FakeBluetoothDeviceClient::kLowEnergyName[] =
    181     "Bluetooth 4.0 Heart Rate Monitor";
    182 const uint32 FakeBluetoothDeviceClient::kLowEnergyClass =
    183     0x000918;  // Major class "Health", Minor class "Heart/Pulse Rate Monitor."
    184 
    185 FakeBluetoothDeviceClient::Properties::Properties(
    186     const PropertyChangedCallback& callback)
    187     : BluetoothDeviceClient::Properties(
    188           NULL,
    189           bluetooth_device::kBluetoothDeviceInterface,
    190           callback) {
    191 }
    192 
    193 FakeBluetoothDeviceClient::Properties::~Properties() {
    194 }
    195 
    196 void FakeBluetoothDeviceClient::Properties::Get(
    197     dbus::PropertyBase* property,
    198     dbus::PropertySet::GetCallback callback) {
    199   VLOG(1) << "Get " << property->name();
    200   callback.Run(false);
    201 }
    202 
    203 void FakeBluetoothDeviceClient::Properties::GetAll() {
    204   VLOG(1) << "GetAll";
    205 }
    206 
    207 void FakeBluetoothDeviceClient::Properties::Set(
    208     dbus::PropertyBase *property,
    209     dbus::PropertySet::SetCallback callback) {
    210   VLOG(1) << "Set " << property->name();
    211   if (property->name() == trusted.name()) {
    212     callback.Run(true);
    213     property->ReplaceValueWithSetValue();
    214   } else {
    215     callback.Run(false);
    216   }
    217 }
    218 
    219 FakeBluetoothDeviceClient::FakeBluetoothDeviceClient()
    220     : simulation_interval_ms_(kSimulationIntervalMs),
    221       discovery_simulation_step_(0),
    222       incoming_pairing_simulation_step_(0),
    223       pairing_cancelled_(false),
    224       connection_monitor_started_(false) {
    225   Properties* properties = new Properties(base::Bind(
    226       &FakeBluetoothDeviceClient::OnPropertyChanged,
    227       base::Unretained(this),
    228       dbus::ObjectPath(kPairedDevicePath)));
    229   properties->address.ReplaceValue(kPairedDeviceAddress);
    230   properties->bluetooth_class.ReplaceValue(kPairedDeviceClass);
    231   properties->name.ReplaceValue("Fake Device (Name)");
    232   properties->alias.ReplaceValue(kPairedDeviceName);
    233   properties->paired.ReplaceValue(true);
    234   properties->trusted.ReplaceValue(true);
    235   properties->adapter.ReplaceValue(
    236       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
    237 
    238   std::vector<std::string> uuids;
    239   uuids.push_back("00001800-0000-1000-8000-00805f9b34fb");
    240   uuids.push_back("00001801-0000-1000-8000-00805f9b34fb");
    241   properties->uuids.ReplaceValue(uuids);
    242 
    243   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
    244 
    245   properties_map_[dbus::ObjectPath(kPairedDevicePath)] = properties;
    246   device_list_.push_back(dbus::ObjectPath(kPairedDevicePath));
    247 }
    248 
    249 FakeBluetoothDeviceClient::~FakeBluetoothDeviceClient() {
    250   // Clean up Properties structures
    251   STLDeleteValues(&properties_map_);
    252 }
    253 
    254 void FakeBluetoothDeviceClient::Init(dbus::Bus* bus) {
    255 }
    256 
    257 void FakeBluetoothDeviceClient::AddObserver(Observer* observer) {
    258   observers_.AddObserver(observer);
    259 }
    260 
    261 void FakeBluetoothDeviceClient::RemoveObserver(Observer* observer) {
    262   observers_.RemoveObserver(observer);
    263 }
    264 
    265 std::vector<dbus::ObjectPath> FakeBluetoothDeviceClient::GetDevicesForAdapter(
    266     const dbus::ObjectPath& adapter_path) {
    267   if (adapter_path ==
    268       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath))
    269     return device_list_;
    270   else
    271     return std::vector<dbus::ObjectPath>();
    272 }
    273 
    274 FakeBluetoothDeviceClient::Properties*
    275 FakeBluetoothDeviceClient::GetProperties(const dbus::ObjectPath& object_path) {
    276   PropertiesMap::iterator iter = properties_map_.find(object_path);
    277   if (iter != properties_map_.end())
    278     return iter->second;
    279   return NULL;
    280 }
    281 
    282 void FakeBluetoothDeviceClient::Connect(
    283     const dbus::ObjectPath& object_path,
    284     const base::Closure& callback,
    285     const ErrorCallback& error_callback) {
    286   VLOG(1) << "Connect: " << object_path.value();
    287   Properties* properties = GetProperties(object_path);
    288 
    289   if (properties->connected.value() == true) {
    290     // Already connected.
    291     callback.Run();
    292     return;
    293   }
    294 
    295   if (properties->paired.value() != true &&
    296       object_path != dbus::ObjectPath(kConnectUnpairablePath) &&
    297       object_path != dbus::ObjectPath(kLowEnergyPath)) {
    298     // Must be paired.
    299     error_callback.Run(bluetooth_device::kErrorFailed, "Not paired");
    300     return;
    301   } else if (properties->paired.value() == true &&
    302              object_path == dbus::ObjectPath(kUnconnectableDevicePath)) {
    303     // Must not be paired
    304     error_callback.Run(bluetooth_device::kErrorFailed,
    305                        "Connection fails while paired");
    306     return;
    307   }
    308 
    309   // The device can be connected.
    310   properties->connected.ReplaceValue(true);
    311   callback.Run();
    312 
    313   // Expose GATT services if connected to LE device.
    314   if (object_path == dbus::ObjectPath(kLowEnergyPath)) {
    315     FakeBluetoothGattServiceClient* gatt_service_client =
    316         static_cast<FakeBluetoothGattServiceClient*>(
    317             DBusThreadManager::Get()->GetBluetoothGattServiceClient());
    318     gatt_service_client->ExposeHeartRateService(
    319         dbus::ObjectPath(kLowEnergyPath));
    320   }
    321 
    322   AddInputDeviceIfNeeded(object_path, properties);
    323 }
    324 
    325 void FakeBluetoothDeviceClient::Disconnect(
    326     const dbus::ObjectPath& object_path,
    327     const base::Closure& callback,
    328     const ErrorCallback& error_callback) {
    329   VLOG(1) << "Disconnect: " << object_path.value();
    330   Properties* properties = GetProperties(object_path);
    331 
    332   if (!properties->connected.value()) {
    333     error_callback.Run("org.bluez.Error.NotConnected", "Not Connected");
    334     return;
    335   }
    336 
    337   // Hide the Heart Rate Service if disconnected from LE device.
    338   if (object_path == dbus::ObjectPath(kLowEnergyPath)) {
    339     FakeBluetoothGattServiceClient* gatt_service_client =
    340         static_cast<FakeBluetoothGattServiceClient*>(
    341             DBusThreadManager::Get()->GetBluetoothGattServiceClient());
    342     gatt_service_client->HideHeartRateService();
    343   }
    344 
    345   callback.Run();
    346   properties->connected.ReplaceValue(false);
    347 }
    348 
    349 void FakeBluetoothDeviceClient::ConnectProfile(
    350     const dbus::ObjectPath& object_path,
    351     const std::string& uuid,
    352     const base::Closure& callback,
    353     const ErrorCallback& error_callback) {
    354   VLOG(1) << "ConnectProfile: " << object_path.value() << " " << uuid;
    355 
    356   FakeBluetoothProfileManagerClient* fake_bluetooth_profile_manager_client =
    357       static_cast<FakeBluetoothProfileManagerClient*>(
    358           DBusThreadManager::Get()->GetBluetoothProfileManagerClient());
    359   FakeBluetoothProfileServiceProvider* profile_service_provider =
    360       fake_bluetooth_profile_manager_client->GetProfileServiceProvider(uuid);
    361   if (profile_service_provider == NULL) {
    362     error_callback.Run(kNoResponseError, "Missing profile");
    363     return;
    364   }
    365 
    366   // Make a socket pair of a compatible type with the type used by Bluetooth;
    367   // spin up a thread to simulate the server side and wrap the client side in
    368   // a D-Bus file descriptor object.
    369   int socket_type = SOCK_STREAM;
    370   if (uuid == FakeBluetoothProfileManagerClient::kL2capUuid)
    371     socket_type = SOCK_SEQPACKET;
    372 
    373   int fds[2];
    374   if (socketpair(AF_UNIX, socket_type, 0, fds) < 0) {
    375     error_callback.Run(kNoResponseError, "socketpair call failed");
    376     return;
    377   }
    378 
    379   int args;
    380   args = fcntl(fds[1], F_GETFL, NULL);
    381   if (args < 0) {
    382     error_callback.Run(kNoResponseError, "failed to get socket flags");
    383     return;
    384   }
    385 
    386   args |= O_NONBLOCK;
    387   if (fcntl(fds[1], F_SETFL, args) < 0) {
    388     error_callback.Run(kNoResponseError, "failed to set socket non-blocking");
    389     return;
    390   }
    391 
    392   base::WorkerPool::GetTaskRunner(false)->PostTask(
    393       FROM_HERE,
    394       base::Bind(&SimulatedProfileSocket,
    395                  fds[0]));
    396 
    397   scoped_ptr<dbus::FileDescriptor> fd(new dbus::FileDescriptor(fds[1]));
    398 
    399   // Post the new connection to the service provider.
    400   BluetoothProfileServiceProvider::Delegate::Options options;
    401 
    402   profile_service_provider->NewConnection(
    403       object_path,
    404       fd.Pass(),
    405       options,
    406       base::Bind(&FakeBluetoothDeviceClient::ConnectionCallback,
    407                  base::Unretained(this),
    408                  object_path,
    409                  callback,
    410                  error_callback));
    411 }
    412 
    413 void FakeBluetoothDeviceClient::DisconnectProfile(
    414     const dbus::ObjectPath& object_path,
    415     const std::string& uuid,
    416     const base::Closure& callback,
    417     const ErrorCallback& error_callback) {
    418   VLOG(1) << "DisconnectProfile: " << object_path.value() << " " << uuid;
    419 
    420   FakeBluetoothProfileManagerClient* fake_bluetooth_profile_manager_client =
    421       static_cast<FakeBluetoothProfileManagerClient*>(
    422           DBusThreadManager::Get()->GetBluetoothProfileManagerClient());
    423   FakeBluetoothProfileServiceProvider* profile_service_provider =
    424       fake_bluetooth_profile_manager_client->GetProfileServiceProvider(uuid);
    425   if (profile_service_provider == NULL) {
    426     error_callback.Run(kNoResponseError, "Missing profile");
    427     return;
    428   }
    429 
    430   profile_service_provider->RequestDisconnection(
    431       object_path,
    432       base::Bind(&FakeBluetoothDeviceClient::DisconnectionCallback,
    433                  base::Unretained(this),
    434                  object_path,
    435                  callback,
    436                  error_callback));
    437 }
    438 
    439 void FakeBluetoothDeviceClient::Pair(
    440     const dbus::ObjectPath& object_path,
    441     const base::Closure& callback,
    442     const ErrorCallback& error_callback) {
    443   VLOG(1) << "Pair: " << object_path.value();
    444   Properties* properties = GetProperties(object_path);
    445 
    446   if (properties->paired.value() == true) {
    447     // Already paired.
    448     callback.Run();
    449     return;
    450   }
    451 
    452   SimulatePairing(object_path, false, callback, error_callback);
    453 }
    454 
    455 void FakeBluetoothDeviceClient::CancelPairing(
    456     const dbus::ObjectPath& object_path,
    457     const base::Closure& callback,
    458     const ErrorCallback& error_callback) {
    459   VLOG(1) << "CancelPairing: " << object_path.value();
    460   pairing_cancelled_ = true;
    461   callback.Run();
    462 }
    463 
    464 void FakeBluetoothDeviceClient::StartConnectionMonitor(
    465     const dbus::ObjectPath& object_path,
    466     const base::Closure& callback,
    467     const ErrorCallback& error_callback) {
    468   VLOG(1) << "StartConnectionMonitor: " << object_path.value();
    469   connection_monitor_started_ = true;
    470   callback.Run();
    471 }
    472 
    473 void FakeBluetoothDeviceClient::StopConnectionMonitor(
    474     const dbus::ObjectPath& object_path,
    475     const base::Closure& callback,
    476     const ErrorCallback& error_callback) {
    477   connection_monitor_started_ = false;
    478   callback.Run();
    479 }
    480 
    481 void FakeBluetoothDeviceClient::BeginDiscoverySimulation(
    482     const dbus::ObjectPath& adapter_path) {
    483   VLOG(1) << "starting discovery simulation";
    484 
    485   discovery_simulation_step_ = 1;
    486 
    487   base::MessageLoop::current()->PostDelayedTask(
    488       FROM_HERE,
    489       base::Bind(&FakeBluetoothDeviceClient::DiscoverySimulationTimer,
    490                  base::Unretained(this)),
    491       base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
    492 }
    493 
    494 void FakeBluetoothDeviceClient::EndDiscoverySimulation(
    495     const dbus::ObjectPath& adapter_path) {
    496   VLOG(1) << "stopping discovery simulation";
    497   discovery_simulation_step_ = 0;
    498 }
    499 
    500 void FakeBluetoothDeviceClient::BeginIncomingPairingSimulation(
    501     const dbus::ObjectPath& adapter_path) {
    502   VLOG(1) << "starting incoming pairing simulation";
    503 
    504   incoming_pairing_simulation_step_ = 1;
    505 
    506   base::MessageLoop::current()->PostDelayedTask(
    507       FROM_HERE,
    508       base::Bind(&FakeBluetoothDeviceClient::IncomingPairingSimulationTimer,
    509                  base::Unretained(this)),
    510       base::TimeDelta::FromMilliseconds(30 * simulation_interval_ms_));
    511 }
    512 
    513 void FakeBluetoothDeviceClient::EndIncomingPairingSimulation(
    514     const dbus::ObjectPath& adapter_path) {
    515   VLOG(1) << "stopping incoming pairing simulation";
    516   incoming_pairing_simulation_step_ = 0;
    517 }
    518 
    519 void FakeBluetoothDeviceClient::SetSimulationIntervalMs(int interval_ms) {
    520   simulation_interval_ms_ = interval_ms;
    521 }
    522 
    523 void FakeBluetoothDeviceClient::CreateDevice(
    524     const dbus::ObjectPath& adapter_path,
    525     const dbus::ObjectPath& device_path) {
    526   if (std::find(device_list_.begin(),
    527                 device_list_.end(), device_path) != device_list_.end())
    528     return;
    529 
    530   Properties* properties = new Properties(base::Bind(
    531       &FakeBluetoothDeviceClient::OnPropertyChanged,
    532       base::Unretained(this),
    533       device_path));
    534   properties->adapter.ReplaceValue(adapter_path);
    535 
    536   if (device_path == dbus::ObjectPath(kLegacyAutopairPath)) {
    537     properties->address.ReplaceValue(kLegacyAutopairAddress);
    538     properties->bluetooth_class.ReplaceValue(kLegacyAutopairClass);
    539     properties->name.ReplaceValue("LegacyAutopair");
    540     properties->alias.ReplaceValue(kLegacyAutopairName);
    541 
    542     std::vector<std::string> uuids;
    543     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
    544     properties->uuids.ReplaceValue(uuids);
    545 
    546   } else if (device_path == dbus::ObjectPath(kDisplayPinCodePath)) {
    547     properties->address.ReplaceValue(kDisplayPinCodeAddress);
    548     properties->bluetooth_class.ReplaceValue(kDisplayPinCodeClass);
    549     properties->name.ReplaceValue("DisplayPinCode");
    550     properties->alias.ReplaceValue(kDisplayPinCodeName);
    551 
    552     std::vector<std::string> uuids;
    553     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
    554     properties->uuids.ReplaceValue(uuids);
    555 
    556   } else if (device_path == dbus::ObjectPath(kVanishingDevicePath)) {
    557     properties->address.ReplaceValue(kVanishingDeviceAddress);
    558     properties->bluetooth_class.ReplaceValue(kVanishingDeviceClass);
    559     properties->name.ReplaceValue("VanishingDevice");
    560     properties->alias.ReplaceValue(kVanishingDeviceName);
    561 
    562   } else if (device_path == dbus::ObjectPath(kConnectUnpairablePath)) {
    563     properties->address.ReplaceValue(kConnectUnpairableAddress);
    564     properties->bluetooth_class.ReplaceValue(kConnectUnpairableClass);
    565     properties->name.ReplaceValue("ConnectUnpairable");
    566     properties->alias.ReplaceValue(kConnectUnpairableName);
    567 
    568     std::vector<std::string> uuids;
    569     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
    570     properties->uuids.ReplaceValue(uuids);
    571 
    572   } else if (device_path == dbus::ObjectPath(kDisplayPasskeyPath)) {
    573     properties->address.ReplaceValue(kDisplayPasskeyAddress);
    574     properties->bluetooth_class.ReplaceValue(kDisplayPasskeyClass);
    575     properties->name.ReplaceValue("DisplayPasskey");
    576     properties->alias.ReplaceValue(kDisplayPasskeyName);
    577 
    578     std::vector<std::string> uuids;
    579     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
    580     properties->uuids.ReplaceValue(uuids);
    581 
    582   } else if (device_path == dbus::ObjectPath(kRequestPinCodePath)) {
    583     properties->address.ReplaceValue(kRequestPinCodeAddress);
    584     properties->bluetooth_class.ReplaceValue(kRequestPinCodeClass);
    585     properties->name.ReplaceValue("RequestPinCode");
    586     properties->alias.ReplaceValue(kRequestPinCodeName);
    587 
    588   } else if (device_path == dbus::ObjectPath(kConfirmPasskeyPath)) {
    589     properties->address.ReplaceValue(kConfirmPasskeyAddress);
    590     properties->bluetooth_class.ReplaceValue(kConfirmPasskeyClass);
    591     properties->name.ReplaceValue("ConfirmPasskey");
    592     properties->alias.ReplaceValue(kConfirmPasskeyName);
    593 
    594   } else if (device_path == dbus::ObjectPath(kRequestPasskeyPath)) {
    595     properties->address.ReplaceValue(kRequestPasskeyAddress);
    596     properties->bluetooth_class.ReplaceValue(kRequestPasskeyClass);
    597     properties->name.ReplaceValue("RequestPasskey");
    598     properties->alias.ReplaceValue(kRequestPasskeyName);
    599 
    600   } else if (device_path == dbus::ObjectPath(kUnconnectableDevicePath)) {
    601     properties->address.ReplaceValue(kUnconnectableDeviceAddress);
    602     properties->bluetooth_class.ReplaceValue(kUnconnectableDeviceClass);
    603     properties->name.ReplaceValue("UnconnectableDevice");
    604     properties->alias.ReplaceValue(kUnconnectableDeviceName);
    605 
    606   } else if (device_path == dbus::ObjectPath(kUnpairableDevicePath)) {
    607     properties->address.ReplaceValue(kUnpairableDeviceAddress);
    608     properties->bluetooth_class.ReplaceValue(kUnpairableDeviceClass);
    609     properties->name.ReplaceValue("Fake Unpairable Device");
    610     properties->alias.ReplaceValue(kUnpairableDeviceName);
    611 
    612   } else if (device_path == dbus::ObjectPath(kJustWorksPath)) {
    613     properties->address.ReplaceValue(kJustWorksAddress);
    614     properties->bluetooth_class.ReplaceValue(kJustWorksClass);
    615     properties->name.ReplaceValue("JustWorks");
    616     properties->alias.ReplaceValue(kJustWorksName);
    617 
    618   } else if (device_path == dbus::ObjectPath(kLowEnergyPath)) {
    619     properties->address.ReplaceValue(kLowEnergyAddress);
    620     properties->bluetooth_class.ReplaceValue(kLowEnergyClass);
    621     properties->name.ReplaceValue("Heart Rate Monitor");
    622     properties->alias.ReplaceValue(kLowEnergyName);
    623 
    624     std::vector<std::string> uuids;
    625     uuids.push_back(FakeBluetoothGattServiceClient::kHeartRateServiceUUID);
    626     properties->uuids.ReplaceValue(uuids);
    627 
    628   } else {
    629     NOTREACHED();
    630 
    631   }
    632 
    633   properties_map_[device_path] = properties;
    634   device_list_.push_back(device_path);
    635   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
    636                     DeviceAdded(device_path));
    637 }
    638 
    639 void FakeBluetoothDeviceClient::RemoveDevice(
    640     const dbus::ObjectPath& adapter_path,
    641     const dbus::ObjectPath& device_path) {
    642   std::vector<dbus::ObjectPath>::iterator listiter =
    643       std::find(device_list_.begin(), device_list_.end(), device_path);
    644   if (listiter == device_list_.end())
    645     return;
    646 
    647   PropertiesMap::iterator iter = properties_map_.find(device_path);
    648   Properties* properties = iter->second;
    649 
    650   VLOG(1) << "removing device: " << properties->alias.value();
    651   device_list_.erase(listiter);
    652 
    653   // Remove the Input interface if it exists. This should be called before the
    654   // BluetoothDeviceClient::Observer::DeviceRemoved because it deletes the
    655   // BluetoothDeviceChromeOS object, including the device_path referenced here.
    656   FakeBluetoothInputClient* fake_bluetooth_input_client =
    657       static_cast<FakeBluetoothInputClient*>(
    658           DBusThreadManager::Get()->GetBluetoothInputClient());
    659   fake_bluetooth_input_client->RemoveInputDevice(device_path);
    660 
    661   if (device_path == dbus::ObjectPath(kLowEnergyPath)) {
    662     FakeBluetoothGattServiceClient* gatt_service_client =
    663         static_cast<FakeBluetoothGattServiceClient*>(
    664             DBusThreadManager::Get()->GetBluetoothGattServiceClient());
    665     gatt_service_client->HideHeartRateService();
    666   }
    667 
    668   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
    669                     DeviceRemoved(device_path));
    670 
    671   delete properties;
    672   properties_map_.erase(iter);
    673 }
    674 
    675 void FakeBluetoothDeviceClient::OnPropertyChanged(
    676     const dbus::ObjectPath& object_path,
    677     const std::string& property_name) {
    678   VLOG(2) << "Fake Bluetooth device property changed: " << object_path.value()
    679           << ": " << property_name;
    680   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
    681                     DevicePropertyChanged(object_path, property_name));
    682 }
    683 
    684 void FakeBluetoothDeviceClient::DiscoverySimulationTimer() {
    685   if (!discovery_simulation_step_)
    686     return;
    687 
    688   // Timer fires every .75s, the numbers below are arbitrary to give a feel
    689   // for a discovery process.
    690   VLOG(1) << "discovery simulation, step " << discovery_simulation_step_;
    691   if (discovery_simulation_step_ == 2) {
    692     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    693                  dbus::ObjectPath(kLegacyAutopairPath));
    694     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    695                  dbus::ObjectPath(kLowEnergyPath));
    696 
    697   } else if (discovery_simulation_step_ == 4) {
    698     UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath),
    699                      base::RandInt(kMinRSSI, kMaxRSSI));
    700     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    701                  dbus::ObjectPath(kDisplayPinCodePath));
    702     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    703                  dbus::ObjectPath(kVanishingDevicePath));
    704 
    705   } else if (discovery_simulation_step_ == 7) {
    706     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    707                  dbus::ObjectPath(kConnectUnpairablePath));
    708     UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath),
    709                      base::RandInt(kMinRSSI, kMaxRSSI));
    710 
    711   } else if (discovery_simulation_step_ == 8) {
    712     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    713                  dbus::ObjectPath(kDisplayPasskeyPath));
    714     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    715                  dbus::ObjectPath(kRequestPinCodePath));
    716     UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath),
    717                      base::RandInt(kMinRSSI, kMaxRSSI));
    718 
    719   } else if (discovery_simulation_step_ == 10) {
    720     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    721                  dbus::ObjectPath(kConfirmPasskeyPath));
    722     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    723                  dbus::ObjectPath(kRequestPasskeyPath));
    724     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    725                  dbus::ObjectPath(kUnconnectableDevicePath));
    726     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    727                  dbus::ObjectPath(kUnpairableDevicePath));
    728     CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    729                  dbus::ObjectPath(kJustWorksPath));
    730     UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath),
    731                      base::RandInt(kMinRSSI, kMaxRSSI));
    732 
    733   } else if (discovery_simulation_step_ == 13) {
    734     UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath),
    735                      base::RandInt(kMinRSSI, kMaxRSSI));
    736     RemoveDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    737                  dbus::ObjectPath(kVanishingDevicePath));
    738 
    739   } else if (discovery_simulation_step_ == 14) {
    740     UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath),
    741                      base::RandInt(kMinRSSI, kMaxRSSI));
    742     return;
    743 
    744   }
    745 
    746   ++discovery_simulation_step_;
    747   base::MessageLoop::current()->PostDelayedTask(
    748       FROM_HERE,
    749       base::Bind(&FakeBluetoothDeviceClient::DiscoverySimulationTimer,
    750                  base::Unretained(this)),
    751       base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
    752 }
    753 
    754 void FakeBluetoothDeviceClient::IncomingPairingSimulationTimer() {
    755   if (!incoming_pairing_simulation_step_)
    756     return;
    757 
    758   VLOG(1) << "incoming pairing simulation, step "
    759           << incoming_pairing_simulation_step_;
    760   switch (incoming_pairing_simulation_step_) {
    761     case 1:
    762       CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    763                    dbus::ObjectPath(kConfirmPasskeyPath));
    764       SimulatePairing(dbus::ObjectPath(kConfirmPasskeyPath), true,
    765                       base::Bind(&base::DoNothing),
    766                       base::Bind(&SimpleErrorCallback));
    767       break;
    768     case 2:
    769       CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    770                    dbus::ObjectPath(kJustWorksPath));
    771       SimulatePairing(dbus::ObjectPath(kJustWorksPath), true,
    772                       base::Bind(&base::DoNothing),
    773                       base::Bind(&SimpleErrorCallback));
    774       break;
    775     case 3:
    776       CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    777                    dbus::ObjectPath(kDisplayPinCodePath));
    778       SimulatePairing(dbus::ObjectPath(kDisplayPinCodePath), true,
    779                       base::Bind(&base::DoNothing),
    780                       base::Bind(&SimpleErrorCallback));
    781       break;
    782     case 4:
    783       CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    784                    dbus::ObjectPath(kDisplayPasskeyPath));
    785       SimulatePairing(dbus::ObjectPath(kDisplayPasskeyPath), true,
    786                       base::Bind(&base::DoNothing),
    787                       base::Bind(&SimpleErrorCallback));
    788       break;
    789     case 5:
    790       CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    791                    dbus::ObjectPath(kRequestPinCodePath));
    792       SimulatePairing(dbus::ObjectPath(kRequestPinCodePath), true,
    793                       base::Bind(&base::DoNothing),
    794                       base::Bind(&SimpleErrorCallback));
    795       break;
    796     case 6:
    797       CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
    798                    dbus::ObjectPath(kRequestPasskeyPath));
    799       SimulatePairing(dbus::ObjectPath(kRequestPasskeyPath), true,
    800                       base::Bind(&base::DoNothing),
    801                       base::Bind(&SimpleErrorCallback));
    802       break;
    803     default:
    804       return;
    805   }
    806 
    807   ++incoming_pairing_simulation_step_;
    808   base::MessageLoop::current()->PostDelayedTask(
    809       FROM_HERE,
    810       base::Bind(&FakeBluetoothDeviceClient::IncomingPairingSimulationTimer,
    811                  base::Unretained(this)),
    812       base::TimeDelta::FromMilliseconds(45 * simulation_interval_ms_));
    813 }
    814 
    815 void FakeBluetoothDeviceClient::SimulatePairing(
    816     const dbus::ObjectPath& object_path,
    817     bool incoming_request,
    818     const base::Closure& callback,
    819     const ErrorCallback& error_callback) {
    820   pairing_cancelled_ = false;
    821 
    822   FakeBluetoothAgentManagerClient* fake_bluetooth_agent_manager_client =
    823       static_cast<FakeBluetoothAgentManagerClient*>(
    824           DBusThreadManager::Get()->GetBluetoothAgentManagerClient());
    825   FakeBluetoothAgentServiceProvider* agent_service_provider =
    826       fake_bluetooth_agent_manager_client->GetAgentServiceProvider();
    827   CHECK(agent_service_provider != NULL);
    828 
    829   if (object_path == dbus::ObjectPath(kLegacyAutopairPath) ||
    830       object_path == dbus::ObjectPath(kConnectUnpairablePath) ||
    831       object_path == dbus::ObjectPath(kUnconnectableDevicePath) ||
    832       object_path == dbus::ObjectPath(kLowEnergyPath)) {
    833     // No need to call anything on the pairing delegate, just wait 3 times
    834     // the interval before acting as if the other end accepted it.
    835     base::MessageLoop::current()->PostDelayedTask(
    836         FROM_HERE,
    837         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
    838                    base::Unretained(this),
    839                    object_path, callback, error_callback),
    840         base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
    841 
    842   } else if (object_path == dbus::ObjectPath(kDisplayPinCodePath)) {
    843     // Display a Pincode, and wait 7 times the interval before acting as
    844     // if the other end accepted it.
    845     agent_service_provider->DisplayPinCode(object_path, "123456");
    846 
    847     base::MessageLoop::current()->PostDelayedTask(
    848         FROM_HERE,
    849         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
    850                    base::Unretained(this),
    851                    object_path, callback, error_callback),
    852         base::TimeDelta::FromMilliseconds(7 * simulation_interval_ms_));
    853 
    854   } else if (object_path == dbus::ObjectPath(kVanishingDevicePath)) {
    855     // The vanishing device simulates being too far away, and thus times out.
    856     base::MessageLoop::current()->PostDelayedTask(
    857         FROM_HERE,
    858         base::Bind(&FakeBluetoothDeviceClient::TimeoutSimulatedPairing,
    859                    base::Unretained(this),
    860                    object_path, error_callback),
    861         base::TimeDelta::FromMilliseconds(4 * simulation_interval_ms_));
    862 
    863   } else if (object_path == dbus::ObjectPath(kDisplayPasskeyPath)) {
    864     // Display a passkey, and each interval act as if another key was entered
    865     // for it.
    866     agent_service_provider->DisplayPasskey(object_path, 123456, 0);
    867 
    868     base::MessageLoop::current()->PostDelayedTask(
    869         FROM_HERE,
    870         base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress,
    871                    base::Unretained(this),
    872                    1, object_path, callback, error_callback),
    873         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
    874 
    875   } else if (object_path == dbus::ObjectPath(kRequestPinCodePath)) {
    876     // Request a Pincode.
    877     agent_service_provider->RequestPinCode(
    878         object_path,
    879         base::Bind(&FakeBluetoothDeviceClient::PinCodeCallback,
    880                    base::Unretained(this),
    881                    object_path,
    882                    callback,
    883                    error_callback));
    884 
    885   } else if (object_path == dbus::ObjectPath(kConfirmPasskeyPath)) {
    886     // Request confirmation of a Passkey.
    887     agent_service_provider->RequestConfirmation(
    888         object_path, 123456,
    889         base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback,
    890                    base::Unretained(this),
    891                    object_path,
    892                    callback,
    893                    error_callback));
    894 
    895   } else if (object_path == dbus::ObjectPath(kRequestPasskeyPath)) {
    896     // Request a Passkey from the user.
    897     agent_service_provider->RequestPasskey(
    898         object_path,
    899         base::Bind(&FakeBluetoothDeviceClient::PasskeyCallback,
    900                    base::Unretained(this),
    901                    object_path,
    902                    callback,
    903                    error_callback));
    904 
    905   } else if (object_path == dbus::ObjectPath(kUnpairableDevicePath)) {
    906     // Fails the pairing with an org.bluez.Error.Failed error.
    907     base::MessageLoop::current()->PostDelayedTask(
    908         FROM_HERE,
    909         base::Bind(&FakeBluetoothDeviceClient::FailSimulatedPairing,
    910                    base::Unretained(this),
    911                    object_path, error_callback),
    912         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
    913 
    914   } else if (object_path == dbus::ObjectPath(kJustWorksPath)) {
    915     if (incoming_request) {
    916       agent_service_provider->RequestAuthorization(
    917           object_path,
    918           base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback,
    919                      base::Unretained(this),
    920                      object_path,
    921                      callback,
    922                      error_callback));
    923 
    924     } else {
    925       // No need to call anything on the pairing delegate, just wait 3 times
    926       // the interval before acting as if the other end accepted it.
    927       base::MessageLoop::current()->PostDelayedTask(
    928           FROM_HERE,
    929           base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
    930                      base::Unretained(this),
    931                      object_path, callback, error_callback),
    932           base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
    933 
    934     }
    935 
    936   } else {
    937     error_callback.Run(kNoResponseError, "No pairing fake");
    938   }
    939 }
    940 
    941 void FakeBluetoothDeviceClient::CompleteSimulatedPairing(
    942     const dbus::ObjectPath& object_path,
    943     const base::Closure& callback,
    944     const ErrorCallback& error_callback) {
    945   VLOG(1) << "CompleteSimulatedPairing: " << object_path.value();
    946   if (pairing_cancelled_) {
    947     pairing_cancelled_ = false;
    948 
    949     error_callback.Run(bluetooth_device::kErrorAuthenticationCanceled,
    950                        "Cancelled");
    951   } else {
    952     Properties* properties = GetProperties(object_path);
    953 
    954     properties->paired.ReplaceValue(true);
    955     callback.Run();
    956 
    957     AddInputDeviceIfNeeded(object_path, properties);
    958   }
    959 }
    960 
    961 void FakeBluetoothDeviceClient::TimeoutSimulatedPairing(
    962     const dbus::ObjectPath& object_path,
    963     const ErrorCallback& error_callback) {
    964   VLOG(1) << "TimeoutSimulatedPairing: " << object_path.value();
    965 
    966   error_callback.Run(bluetooth_device::kErrorAuthenticationTimeout,
    967                      "Timed out");
    968 }
    969 
    970 void FakeBluetoothDeviceClient::CancelSimulatedPairing(
    971     const dbus::ObjectPath& object_path,
    972     const ErrorCallback& error_callback) {
    973   VLOG(1) << "CancelSimulatedPairing: " << object_path.value();
    974 
    975   error_callback.Run(bluetooth_device::kErrorAuthenticationCanceled,
    976                      "Canceled");
    977 }
    978 
    979 void FakeBluetoothDeviceClient::RejectSimulatedPairing(
    980     const dbus::ObjectPath& object_path,
    981     const ErrorCallback& error_callback) {
    982   VLOG(1) << "RejectSimulatedPairing: " << object_path.value();
    983 
    984   error_callback.Run(bluetooth_device::kErrorAuthenticationRejected,
    985                      "Rejected");
    986 }
    987 
    988 void FakeBluetoothDeviceClient::FailSimulatedPairing(
    989     const dbus::ObjectPath& object_path,
    990     const ErrorCallback& error_callback) {
    991   VLOG(1) << "FailSimulatedPairing: " << object_path.value();
    992 
    993   error_callback.Run(bluetooth_device::kErrorFailed, "Failed");
    994 }
    995 
    996 void FakeBluetoothDeviceClient::AddInputDeviceIfNeeded(
    997     const dbus::ObjectPath& object_path,
    998     Properties* properties) {
    999   // If the paired device is a HID device based on it's bluetooth class,
   1000   // simulate the Input interface.
   1001   FakeBluetoothInputClient* fake_bluetooth_input_client =
   1002       static_cast<FakeBluetoothInputClient*>(
   1003           DBusThreadManager::Get()->GetBluetoothInputClient());
   1004 
   1005   if ((properties->bluetooth_class.value() & 0x001f03) == 0x000500)
   1006     fake_bluetooth_input_client->AddInputDevice(object_path);
   1007 }
   1008 
   1009 void FakeBluetoothDeviceClient::UpdateDeviceRSSI(
   1010     const dbus::ObjectPath& object_path,
   1011     int16 rssi) {
   1012   PropertiesMap::iterator iter = properties_map_.find(object_path);
   1013   if (iter == properties_map_.end()) {
   1014     VLOG(2) << "Fake device does not exist: " << object_path.value();
   1015     return;
   1016   }
   1017   Properties* properties = iter->second;
   1018   DCHECK(properties);
   1019   properties->rssi.ReplaceValue(rssi);
   1020 }
   1021 
   1022 void FakeBluetoothDeviceClient::PinCodeCallback(
   1023     const dbus::ObjectPath& object_path,
   1024     const base::Closure& callback,
   1025     const ErrorCallback& error_callback,
   1026     BluetoothAgentServiceProvider::Delegate::Status status,
   1027     const std::string& pincode) {
   1028   VLOG(1) << "PinCodeCallback: " << object_path.value();
   1029 
   1030   if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) {
   1031     base::MessageLoop::current()->PostDelayedTask(
   1032         FROM_HERE,
   1033         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
   1034                    base::Unretained(this),
   1035                    object_path, callback, error_callback),
   1036         base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
   1037 
   1038   } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) {
   1039     base::MessageLoop::current()->PostDelayedTask(
   1040         FROM_HERE,
   1041         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
   1042                    base::Unretained(this),
   1043                    object_path, error_callback),
   1044         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
   1045 
   1046   } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) {
   1047     base::MessageLoop::current()->PostDelayedTask(
   1048         FROM_HERE,
   1049         base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing,
   1050                    base::Unretained(this),
   1051                    object_path, error_callback),
   1052         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
   1053 
   1054   }
   1055 }
   1056 
   1057 void FakeBluetoothDeviceClient::PasskeyCallback(
   1058     const dbus::ObjectPath& object_path,
   1059     const base::Closure& callback,
   1060     const ErrorCallback& error_callback,
   1061     BluetoothAgentServiceProvider::Delegate::Status status,
   1062     uint32 passkey) {
   1063   VLOG(1) << "PasskeyCallback: " << object_path.value();
   1064 
   1065   if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) {
   1066     base::MessageLoop::current()->PostDelayedTask(
   1067         FROM_HERE,
   1068         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
   1069                    base::Unretained(this),
   1070                    object_path, callback, error_callback),
   1071         base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
   1072 
   1073   } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) {
   1074     base::MessageLoop::current()->PostDelayedTask(
   1075         FROM_HERE,
   1076         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
   1077                    base::Unretained(this),
   1078                    object_path, error_callback),
   1079         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
   1080 
   1081   } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) {
   1082     base::MessageLoop::current()->PostDelayedTask(
   1083         FROM_HERE,
   1084         base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing,
   1085                    base::Unretained(this),
   1086                    object_path, error_callback),
   1087         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
   1088 
   1089   }
   1090 }
   1091 
   1092 void FakeBluetoothDeviceClient::ConfirmationCallback(
   1093     const dbus::ObjectPath& object_path,
   1094     const base::Closure& callback,
   1095     const ErrorCallback& error_callback,
   1096     BluetoothAgentServiceProvider::Delegate::Status status) {
   1097   VLOG(1) << "ConfirmationCallback: " << object_path.value();
   1098 
   1099   if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) {
   1100     base::MessageLoop::current()->PostDelayedTask(
   1101         FROM_HERE,
   1102         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
   1103                    base::Unretained(this),
   1104                    object_path, callback, error_callback),
   1105         base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
   1106 
   1107   } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) {
   1108     base::MessageLoop::current()->PostDelayedTask(
   1109         FROM_HERE,
   1110         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
   1111                    base::Unretained(this),
   1112                    object_path, error_callback),
   1113         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
   1114 
   1115   } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) {
   1116     base::MessageLoop::current()->PostDelayedTask(
   1117         FROM_HERE,
   1118         base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing,
   1119                    base::Unretained(this),
   1120                    object_path, error_callback),
   1121         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
   1122 
   1123   }
   1124 }
   1125 
   1126 void FakeBluetoothDeviceClient::SimulateKeypress(
   1127     uint16 entered,
   1128     const dbus::ObjectPath& object_path,
   1129     const base::Closure& callback,
   1130     const ErrorCallback& error_callback) {
   1131   VLOG(1) << "SimulateKeypress " << entered << ": " << object_path.value();
   1132 
   1133   FakeBluetoothAgentManagerClient* fake_bluetooth_agent_manager_client =
   1134       static_cast<FakeBluetoothAgentManagerClient*>(
   1135           DBusThreadManager::Get()->GetBluetoothAgentManagerClient());
   1136   FakeBluetoothAgentServiceProvider* agent_service_provider =
   1137       fake_bluetooth_agent_manager_client->GetAgentServiceProvider();
   1138 
   1139   // The agent service provider object could have been destroyed after the
   1140   // pairing is canceled.
   1141   if (!agent_service_provider)
   1142     return;
   1143 
   1144   agent_service_provider->DisplayPasskey(object_path, 123456, entered);
   1145 
   1146   if (entered < 7) {
   1147     base::MessageLoop::current()->PostDelayedTask(
   1148         FROM_HERE,
   1149         base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress,
   1150                    base::Unretained(this),
   1151                    entered + 1, object_path, callback, error_callback),
   1152         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
   1153 
   1154   } else {
   1155     base::MessageLoop::current()->PostDelayedTask(
   1156         FROM_HERE,
   1157         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
   1158                    base::Unretained(this),
   1159                    object_path, callback, error_callback),
   1160         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
   1161 
   1162   }
   1163 }
   1164 
   1165 void FakeBluetoothDeviceClient::ConnectionCallback(
   1166     const dbus::ObjectPath& object_path,
   1167     const base::Closure& callback,
   1168     const ErrorCallback& error_callback,
   1169     BluetoothProfileServiceProvider::Delegate::Status status) {
   1170   VLOG(1) << "ConnectionCallback: " << object_path.value();
   1171 
   1172   if (status == BluetoothProfileServiceProvider::Delegate::SUCCESS) {
   1173     callback.Run();
   1174   } else if (status == BluetoothProfileServiceProvider::Delegate::CANCELLED) {
   1175     // TODO(keybuk): tear down this side of the connection
   1176     error_callback.Run(bluetooth_device::kErrorFailed, "Canceled");
   1177   } else if (status == BluetoothProfileServiceProvider::Delegate::REJECTED) {
   1178     // TODO(keybuk): tear down this side of the connection
   1179     error_callback.Run(bluetooth_device::kErrorFailed, "Rejected");
   1180   }
   1181 }
   1182 
   1183 void FakeBluetoothDeviceClient::DisconnectionCallback(
   1184     const dbus::ObjectPath& object_path,
   1185     const base::Closure& callback,
   1186     const ErrorCallback& error_callback,
   1187     BluetoothProfileServiceProvider::Delegate::Status status) {
   1188   VLOG(1) << "DisconnectionCallback: " << object_path.value();
   1189 
   1190   if (status == BluetoothProfileServiceProvider::Delegate::SUCCESS) {
   1191     // TODO(keybuk): tear down this side of the connection
   1192     callback.Run();
   1193   } else if (status == BluetoothProfileServiceProvider::Delegate::CANCELLED) {
   1194     error_callback.Run(bluetooth_device::kErrorFailed, "Canceled");
   1195   } else if (status == BluetoothProfileServiceProvider::Delegate::REJECTED) {
   1196     error_callback.Run(bluetooth_device::kErrorFailed, "Rejected");
   1197   }
   1198 }
   1199 
   1200 }  // namespace chromeos
   1201