src/chromeos/dbus/fake_bluetooth_device_client.cc

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