src/chrome/browser/ui/webui/options/chromeos/bluetooth_options_handler.cc

   1 // Copyright (c) 2012 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 "chrome/browser/ui/webui/options/chromeos/bluetooth_options_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/command_line.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/values.h"
  14 #include "content/public/browser/web_ui.h"
  15 #include "device/bluetooth/bluetooth_adapter.h"
  16 #include "device/bluetooth/bluetooth_adapter_factory.h"
  17 #include "device/bluetooth/bluetooth_device.h"
  18 #include "grit/chromium_strings.h"
  19 #include "grit/generated_resources.h"
  20 #include "third_party/cros_system_api/dbus/service_constants.h"
  21 #include "ui/base/l10n/l10n_util.h"
  22
  23 namespace {
  24
  25 // |UpdateDeviceCallback| takes a variable length list as an argument. The
  26 // value stored in each list element is indicated by the following constants.
  27 const int kUpdateDeviceAddressIndex = 0;
  28 const int kUpdateDeviceCommandIndex = 1;
  29 const int kUpdateDeviceAuthTokenIndex = 2;
  30
  31 // |UpdateDeviceCallback| provides a command value of one of the following
  32 // constants that indicates what update it is providing to us.
  33 const char kConnectCommand[] = "connect";
  34 const char kCancelCommand[] = "cancel";
  35 const char kAcceptCommand[] = "accept";
  36 const char kRejectCommand[] = "reject";
  37 const char kDisconnectCommand[] = "disconnect";
  38 const char kForgetCommand[] = "forget";
  39
  40 // |SendDeviceNotification| may include a pairing parameter whose value
  41 // is one of the following constants instructing the UI to perform a certain
  42 // action.
  43 const char kStartConnecting[] = "bluetoothStartConnecting";
  44 const char kEnterPinCode[] = "bluetoothEnterPinCode";
  45 const char kEnterPasskey[] = "bluetoothEnterPasskey";
  46 const char kRemotePinCode[] = "bluetoothRemotePinCode";
  47 const char kRemotePasskey[] = "bluetoothRemotePasskey";
  48 const char kConfirmPasskey[] = "bluetoothConfirmPasskey";
  49
  50 // An invalid |entered| value to represent the "undefined" value.
  51 const int kInvalidEntered = 0xFFFF;
  52
  53 }  // namespace
  54
  55 namespace chromeos {
  56 namespace options {
  57
  58 BluetoothOptionsHandler::BluetoothOptionsHandler() :
  59     discovering_(false),
  60     pairing_device_passkey_(1000000),
  61     pairing_device_entered_(kInvalidEntered),
  62     weak_ptr_factory_(this) {
  63 }
  64
  65 BluetoothOptionsHandler::~BluetoothOptionsHandler() {
  66   if (discovering_) {
  67     adapter_->StopDiscovering(
  68         base::Bind(&base::DoNothing),
  69         base::Bind(&base::DoNothing));
  70     discovering_ = false;
  71   }
  72   if (adapter_.get())
  73     adapter_->RemoveObserver(this);
  74 }
  75
  76 void BluetoothOptionsHandler::GetLocalizedValues(
  77     DictionaryValue* localized_strings) {
  78   DCHECK(localized_strings);
  79
  80   static OptionsStringResource resources[] = {
  81     { "bluetooth", IDS_OPTIONS_SETTINGS_SECTION_TITLE_BLUETOOTH },
  82     { "disableBluetooth", IDS_OPTIONS_SETTINGS_BLUETOOTH_DISABLE },
  83     { "enableBluetooth", IDS_OPTIONS_SETTINGS_BLUETOOTH_ENABLE },
  84     { "addBluetoothDevice", IDS_OPTIONS_SETTINGS_ADD_BLUETOOTH_DEVICE },
  85     { "bluetoothAddDeviceTitle",
  86         IDS_OPTIONS_SETTINGS_BLUETOOTH_ADD_DEVICE_TITLE },
  87     { "bluetoothOptionsPageTabTitle",
  88         IDS_OPTIONS_SETTINGS_BLUETOOTH_ADD_DEVICE_TITLE },
  89     { "findBluetoothDevices", IDS_OPTIONS_SETTINGS_FIND_BLUETOOTH_DEVICES },
  90     { "bluetoothNoDevices", IDS_OPTIONS_SETTINGS_BLUETOOTH_NO_DEVICES },
  91     { "bluetoothNoDevicesFound",
  92         IDS_OPTIONS_SETTINGS_BLUETOOTH_NO_DEVICES_FOUND },
  93     { "bluetoothScanning", IDS_OPTIONS_SETTINGS_BLUETOOTH_SCANNING },
  94     { "bluetoothDeviceConnecting", IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECTING },
  95     { "bluetoothConnectDevice", IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT },
  96     { "bluetoothDisconnectDevice", IDS_OPTIONS_SETTINGS_BLUETOOTH_DISCONNECT },
  97     { "bluetoothForgetDevice", IDS_OPTIONS_SETTINGS_BLUETOOTH_FORGET },
  98     { "bluetoothCancel", IDS_OPTIONS_SETTINGS_BLUETOOTH_CANCEL },
  99     { "bluetoothEnterKey", IDS_OPTIONS_SETTINGS_BLUETOOTH_ENTER_KEY },
 100     { "bluetoothDismissError", IDS_OPTIONS_SETTINGS_BLUETOOTH_DISMISS_ERROR },
 101
 102     // Device connecting and pairing.
 103     { "bluetoothStartConnecting",
 104         IDS_OPTIONS_SETTINGS_BLUETOOTH_START_CONNECTING },
 105     { "bluetoothAcceptPasskey",
 106         IDS_OPTIONS_SETTINGS_BLUETOOTH_ACCEPT_PASSKEY },
 107     { "bluetoothRejectPasskey",
 108         IDS_OPTIONS_SETTINGS_BLUETOOTH_REJECT_PASSKEY },
 109     { "bluetoothEnterPinCode",
 110         IDS_OPTIONS_SETTINGS_BLUETOOTH_ENTER_PIN_CODE_REQUEST },
 111     { "bluetoothEnterPasskey",
 112         IDS_OPTIONS_SETTINGS_BLUETOOTH_ENTER_PASSKEY_REQUEST },
 113     { "bluetoothRemotePinCode",
 114         IDS_OPTIONS_SETTINGS_BLUETOOTH_REMOTE_PIN_CODE_REQUEST },
 115     { "bluetoothRemotePasskey",
 116         IDS_OPTIONS_SETTINGS_BLUETOOTH_REMOTE_PASSKEY_REQUEST },
 117     { "bluetoothConfirmPasskey",
 118         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONFIRM_PASSKEY_REQUEST },
 119
 120     // Error messages.
 121     { "bluetoothStartDiscoveryFailed",
 122         IDS_OPTIONS_SETTINGS_BLUETOOTH_START_DISCOVERY_FAILED },
 123     { "bluetoothStopDiscoveryFailed",
 124         IDS_OPTIONS_SETTINGS_BLUETOOTH_STOP_DISCOVERY_FAILED },
 125     { "bluetoothChangePowerFailed",
 126         IDS_OPTIONS_SETTINGS_BLUETOOTH_CHANGE_POWER_FAILED },
 127     { "bluetoothConnectUnknownError",
 128         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT_UNKNOWN_ERROR },
 129     { "bluetoothConnectInProgress",
 130         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT_IN_PROGRESS },
 131     { "bluetoothConnectFailed",
 132         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT_FAILED },
 133     { "bluetoothConnectAuthFailed",
 134         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT_AUTH_FAILED },
 135     { "bluetoothConnectAuthCanceled",
 136         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT_AUTH_CANCELED },
 137     { "bluetoothConnectAuthRejected",
 138         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT_AUTH_REJECTED },
 139     { "bluetoothConnectAuthTimeout",
 140         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT_AUTH_TIMEOUT },
 141     { "bluetoothConnectUnsupportedDevice",
 142         IDS_OPTIONS_SETTINGS_BLUETOOTH_CONNECT_UNSUPPORTED_DEVICE },
 143     { "bluetoothDisconnectFailed",
 144         IDS_OPTIONS_SETTINGS_BLUETOOTH_DISCONNECT_FAILED },
 145     { "bluetoothForgetFailed",
 146         IDS_OPTIONS_SETTINGS_BLUETOOTH_FORGET_FAILED }};
 147
 148   RegisterStrings(localized_strings, resources, arraysize(resources));
 149 }
 150
 151 // TODO(kevers): Reorder methods to match ordering in the header file.
 152
 153 void BluetoothOptionsHandler::AdapterPresentChanged(
 154     device::BluetoothAdapter* adapter,
 155     bool present) {
 156   DCHECK(adapter == adapter_.get());
 157   if (present) {
 158     web_ui()->CallJavascriptFunction(
 159         "options.BrowserOptions.showBluetoothSettings");
 160
 161     // Update the checkbox and visibility based on the powered state of the
 162     // new adapter.
 163     AdapterPoweredChanged(adapter_.get(), adapter_->IsPowered());
 164   } else {
 165     web_ui()->CallJavascriptFunction(
 166         "options.BrowserOptions.hideBluetoothSettings");
 167   }
 168 }
 169
 170 void BluetoothOptionsHandler::AdapterPoweredChanged(
 171     device::BluetoothAdapter* adapter,
 172     bool powered) {
 173   DCHECK(adapter == adapter_.get());
 174   base::FundamentalValue checked(powered);
 175   web_ui()->CallJavascriptFunction(
 176       "options.BrowserOptions.setBluetoothState", checked);
 177 }
 178
 179 void BluetoothOptionsHandler::RegisterMessages() {
 180   web_ui()->RegisterMessageCallback("bluetoothEnableChange",
 181       base::Bind(&BluetoothOptionsHandler::EnableChangeCallback,
 182                  base::Unretained(this)));
 183   web_ui()->RegisterMessageCallback("findBluetoothDevices",
 184       base::Bind(&BluetoothOptionsHandler::FindDevicesCallback,
 185                  base::Unretained(this)));
 186   web_ui()->RegisterMessageCallback("updateBluetoothDevice",
 187       base::Bind(&BluetoothOptionsHandler::UpdateDeviceCallback,
 188                  base::Unretained(this)));
 189   web_ui()->RegisterMessageCallback("stopBluetoothDeviceDiscovery",
 190       base::Bind(&BluetoothOptionsHandler::StopDiscoveryCallback,
 191                  base::Unretained(this)));
 192   web_ui()->RegisterMessageCallback("getPairedBluetoothDevices",
 193       base::Bind(&BluetoothOptionsHandler::GetPairedDevicesCallback,
 194                  base::Unretained(this)));
 195 }
 196
 197 void BluetoothOptionsHandler::InitializeHandler() {
 198   device::BluetoothAdapterFactory::GetAdapter(
 199       base::Bind(&BluetoothOptionsHandler::InitializeAdapter,
 200                  weak_ptr_factory_.GetWeakPtr()));
 201 }
 202
 203 void BluetoothOptionsHandler::InitializePage() {
 204   // Show or hide the bluetooth settings and update the checkbox based
 205   // on the current present/powered state.
 206   AdapterPresentChanged(adapter_.get(), adapter_->IsPresent());
 207   // Automatically start device discovery if the "Add Bluetooth Device"
 208   // overlay is visible.
 209   web_ui()->CallJavascriptFunction(
 210       "options.BluetoothOptions.updateDiscovery");
 211 }
 212
 213 void BluetoothOptionsHandler::InitializeAdapter(
 214     scoped_refptr<device::BluetoothAdapter> adapter) {
 215   adapter_ = adapter;
 216   CHECK(adapter_.get());
 217   adapter_->AddObserver(this);
 218 }
 219
 220 void BluetoothOptionsHandler::EnableChangeCallback(
 221     const ListValue* args) {
 222   bool bluetooth_enabled;
 223   args->GetBoolean(0, &bluetooth_enabled);
 224
 225   adapter_->SetPowered(bluetooth_enabled,
 226                        base::Bind(&base::DoNothing),
 227                        base::Bind(&BluetoothOptionsHandler::EnableChangeError,
 228                                   weak_ptr_factory_.GetWeakPtr()));
 229 }
 230
 231 void BluetoothOptionsHandler::EnableChangeError() {
 232   VLOG(1) << "Failed to change power state.";
 233   ReportError("bluetoothChangePowerFailed", std::string());
 234 }
 235
 236 void BluetoothOptionsHandler::FindDevicesCallback(
 237     const ListValue* args) {
 238   if (!discovering_) {
 239     discovering_ = true;
 240     adapter_->StartDiscovering(
 241         base::Bind(&base::DoNothing),
 242         base::Bind(&BluetoothOptionsHandler::FindDevicesError,
 243                    weak_ptr_factory_.GetWeakPtr()));
 244   }
 245 }
 246
 247 void BluetoothOptionsHandler::FindDevicesError() {
 248   VLOG(1) << "Failed to start discovery.";
 249   ReportError("bluetoothStartDiscoveryFailed", std::string());
 250 }
 251
 252 void BluetoothOptionsHandler::UpdateDeviceCallback(
 253     const ListValue* args) {
 254   std::string address;
 255   args->GetString(kUpdateDeviceAddressIndex, &address);
 256
 257   device::BluetoothDevice* device = adapter_->GetDevice(address);
 258   if (!device)
 259     return;
 260
 261   std::string command;
 262   args->GetString(kUpdateDeviceCommandIndex, &command);
 263
 264   if (command == kConnectCommand) {
 265     int size = args->GetSize();
 266     if (size > kUpdateDeviceAuthTokenIndex) {
 267       // PIN code or Passkey entry during the pairing process.
 268       std::string auth_token;
 269       args->GetString(kUpdateDeviceAuthTokenIndex, &auth_token);
 270
 271       if (device->ExpectingPinCode()) {
 272         DeviceConnecting(device);
 273         // PIN Code is an array of 1 to 16 8-bit bytes, the usual
 274         // interpretation, and the one shared by BlueZ, is a UTF-8 string
 275         // of as many characters that will fit in that space, thus we
 276         // can use the auth token from JavaScript unmodified.
 277         VLOG(1) << "PIN Code supplied: " << address << ": " << auth_token;
 278         device->SetPinCode(auth_token);
 279       } else if (device->ExpectingPasskey()) {
 280         DeviceConnecting(device);
 281         // Passkey is a numeric in the range 0-999999, in this case the
 282         // JavaScript code should have ensured the auth token string only
 283         // contains digits so a simple conversion is sufficient. In the
 284         // failure case, just use 0 since that's the most likely Passkey
 285         // anyway, and if it's refused the device will request a new one.
 286         unsigned passkey = 0;
 287         base::StringToUint(auth_token, &passkey);
 288
 289         VLOG(1) << "Passkey supplied: " << address << ": " << passkey;
 290         device->SetPasskey(passkey);
 291       } else {
 292         LOG(WARNING) << "Auth token supplied after pairing ended: " << address
 293                      << ": " << auth_token;
 294       }
 295     } else {
 296       // Determine if the device supports pairing:
 297       PairingDelegate* delegate = NULL;
 298       if (device->IsPairable())
 299         delegate = this;
 300
 301       // Connection request.
 302       VLOG(1) << "Connect: " << address;
 303       device->Connect(
 304           delegate,
 305           base::Bind(&BluetoothOptionsHandler::Connected,
 306                      weak_ptr_factory_.GetWeakPtr()),
 307           base::Bind(&BluetoothOptionsHandler::ConnectError,
 308                      weak_ptr_factory_.GetWeakPtr(),
 309                      device->GetAddress()));
 310     }
 311   } else if (command == kCancelCommand) {
 312     // Cancel pairing.
 313     VLOG(1) << "Cancel pairing: " << address;
 314     device->CancelPairing();
 315   } else if (command == kAcceptCommand) {
 316     // Confirm displayed Passkey.
 317     VLOG(1) << "Confirm pairing: " << address;
 318     device->ConfirmPairing();
 319   } else if (command == kRejectCommand) {
 320     // Reject displayed Passkey.
 321     VLOG(1) << "Reject pairing: " << address;
 322     device->RejectPairing();
 323   } else if (command == kDisconnectCommand) {
 324     // Disconnect from device.
 325     VLOG(1) << "Disconnect device: " << address;
 326     device->Disconnect(
 327         base::Bind(&base::DoNothing),
 328         base::Bind(&BluetoothOptionsHandler::DisconnectError,
 329                    weak_ptr_factory_.GetWeakPtr(),
 330                    device->GetAddress()));
 331   } else if (command == kForgetCommand) {
 332     // Disconnect from device and delete pairing information.
 333     VLOG(1) << "Forget device: " << address;
 334     device->Forget(base::Bind(&BluetoothOptionsHandler::ForgetError,
 335                               weak_ptr_factory_.GetWeakPtr(),
 336                               device->GetAddress()));
 337   } else {
 338     LOG(WARNING) << "Unknown updateBluetoothDevice command: " << command;
 339   }
 340 }
 341
 342 void BluetoothOptionsHandler::Connected() {
 343   // Invalidate the local cache.
 344   pairing_device_address_.clear();
 345   pairing_device_entered_ = kInvalidEntered;
 346
 347   web_ui()->CallJavascriptFunction(
 348       "options.BluetoothPairing.dismissDialog");
 349 }
 350
 351 void BluetoothOptionsHandler::ConnectError(
 352     const std::string& address,
 353     device::BluetoothDevice::ConnectErrorCode error_code) {
 354   const char* error_name = NULL;
 355
 356   // Invalidate the local cache.
 357   pairing_device_address_.clear();
 358   pairing_device_entered_ = kInvalidEntered;
 359
 360   VLOG(1) << "Failed to connect to device: " << address;
 361   switch (error_code) {
 362     case device::BluetoothDevice::ERROR_UNKNOWN:
 363       error_name = "bluetoothConnectUnknownError";
 364       break;
 365     case device::BluetoothDevice::ERROR_INPROGRESS:
 366       error_name = "bluetoothConnectInProgress";
 367       break;
 368     case device::BluetoothDevice::ERROR_FAILED:
 369       error_name = "bluetoothConnectFailed";
 370       break;
 371     case device::BluetoothDevice::ERROR_AUTH_FAILED:
 372       error_name = "bluetoothConnectAuthFailed";
 373       break;
 374     case device::BluetoothDevice::ERROR_AUTH_CANCELED:
 375       error_name = "bluetoothConnectAuthCanceled";
 376       break;
 377     case device::BluetoothDevice::ERROR_AUTH_REJECTED:
 378       error_name = "bluetoothConnectAuthRejected";
 379       break;
 380     case device::BluetoothDevice::ERROR_AUTH_TIMEOUT:
 381       error_name = "bluetoothConnectAuthTimeout";
 382       break;
 383     case device::BluetoothDevice::ERROR_UNSUPPORTED_DEVICE:
 384       error_name = "bluetoothConnectUnsupportedDevice";
 385       break;
 386   }
 387   // Report an error only if there's an error to report.
 388   if (error_name)
 389     ReportError(error_name, address);
 390 }
 391
 392 void BluetoothOptionsHandler::DisconnectError(const std::string& address) {
 393   VLOG(1) << "Failed to disconnect from device: " << address;
 394   ReportError("bluetoothDisconnectFailed", address);
 395 }
 396
 397 void BluetoothOptionsHandler::ForgetError(const std::string& address) {
 398   VLOG(1) << "Failed to disconnect and unpair device: " << address;
 399   ReportError("bluetoothForgetFailed", address);
 400 }
 401
 402 void BluetoothOptionsHandler::StopDiscoveryCallback(
 403     const ListValue* args) {
 404   if (discovering_) {
 405     adapter_->StopDiscovering(
 406         base::Bind(&base::DoNothing),
 407         base::Bind(&BluetoothOptionsHandler::StopDiscoveryError,
 408                    weak_ptr_factory_.GetWeakPtr()));
 409     discovering_ = false;
 410   }
 411 }
 412
 413 void BluetoothOptionsHandler::StopDiscoveryError() {
 414   VLOG(1) << "Failed to stop discovery.";
 415   ReportError("bluetoothStopDiscoveryFailed", std::string());
 416 }
 417
 418 void BluetoothOptionsHandler::GetPairedDevicesCallback(
 419     const ListValue* args) {
 420   device::BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
 421
 422   for (device::BluetoothAdapter::DeviceList::iterator iter = devices.begin();
 423        iter != devices.end(); ++iter)
 424     SendDeviceNotification(*iter, NULL);
 425 }
 426
 427 void BluetoothOptionsHandler::SendDeviceNotification(
 428     const device::BluetoothDevice* device,
 429     base::DictionaryValue* params) {
 430   base::DictionaryValue js_properties;
 431   js_properties.SetString("name", device->GetName());
 432   js_properties.SetString("address", device->GetAddress());
 433   js_properties.SetBoolean("paired", device->IsPaired());
 434   js_properties.SetBoolean("connected", device->IsConnected());
 435   js_properties.SetBoolean("connecting", device->IsConnecting());
 436   js_properties.SetBoolean("connectable", device->IsConnectable());
 437   if (params)
 438     js_properties.MergeDictionary(params);
 439
 440   // Use the cached values to update js_property.
 441   if (device->GetAddress() == pairing_device_address_) {
 442     std::string pairing;
 443     if (!js_properties.GetString("pairing", &pairing)) {
 444       pairing = pairing_device_pairing_;
 445       js_properties.SetString("pairing", pairing);
 446     }
 447     if (pairing == kRemotePinCode && !js_properties.HasKey("pincode"))
 448       js_properties.SetString("pincode", pairing_device_pincode_);
 449     if (pairing == kRemotePasskey && !js_properties.HasKey("passkey"))
 450       js_properties.SetInteger("passkey", pairing_device_passkey_);
 451     if ((pairing == kRemotePinCode || pairing == kRemotePasskey) &&
 452         !js_properties.HasKey("entered") &&
 453         pairing_device_entered_ != kInvalidEntered) {
 454       js_properties.SetInteger("entered", pairing_device_entered_);
 455     }
 456   }
 457
 458   // Update the cache with the new information.
 459   if (js_properties.HasKey("pairing")) {
 460     pairing_device_address_ = device->GetAddress();
 461     js_properties.GetString("pairing", &pairing_device_pairing_);
 462     js_properties.GetString("pincode", &pairing_device_pincode_);
 463     js_properties.GetInteger("passkey", &pairing_device_passkey_);
 464     if (!js_properties.GetInteger("entered", &pairing_device_entered_))
 465       pairing_device_entered_ = kInvalidEntered;
 466   }
 467
 468   web_ui()->CallJavascriptFunction(
 469       "options.BrowserOptions.addBluetoothDevice",
 470       js_properties);
 471 }
 472
 473 void BluetoothOptionsHandler::RequestPinCode(device::BluetoothDevice* device) {
 474   DictionaryValue params;
 475   params.SetString("pairing", kEnterPinCode);
 476   SendDeviceNotification(device, &params);
 477 }
 478
 479 void BluetoothOptionsHandler::RequestPasskey(device::BluetoothDevice* device) {
 480   DictionaryValue params;
 481   params.SetString("pairing", kEnterPasskey);
 482   SendDeviceNotification(device, &params);
 483 }
 484
 485 void BluetoothOptionsHandler::DisplayPinCode(device::BluetoothDevice* device,
 486                                              const std::string& pincode) {
 487   DictionaryValue params;
 488   params.SetString("pairing", kRemotePinCode);
 489   params.SetString("pincode", pincode);
 490   SendDeviceNotification(device, &params);
 491 }
 492
 493 void BluetoothOptionsHandler::DisplayPasskey(device::BluetoothDevice* device,
 494                                              uint32 passkey) {
 495   DictionaryValue params;
 496   params.SetString("pairing", kRemotePasskey);
 497   params.SetInteger("passkey", passkey);
 498   SendDeviceNotification(device, &params);
 499 }
 500
 501 void BluetoothOptionsHandler::KeysEntered(device::BluetoothDevice* device,
 502                                           uint32 entered) {
 503   DictionaryValue params;
 504   params.SetInteger("entered", entered);
 505   SendDeviceNotification(device, &params);
 506 }
 507
 508 void BluetoothOptionsHandler::ConfirmPasskey(device::BluetoothDevice* device,
 509                                              uint32 passkey) {
 510   DictionaryValue params;
 511   params.SetString("pairing", kConfirmPasskey);
 512   params.SetInteger("passkey", passkey);
 513   SendDeviceNotification(device, &params);
 514 }
 515
 516 void BluetoothOptionsHandler::DismissDisplayOrConfirm() {
 517   DCHECK(adapter_.get());
 518
 519   // We can receive this delegate call when we haven't been asked to display or
 520   // confirm anything; we can determine that by checking whether we've saved
 521   // pairing information for the device. This is also a handy way to get the
 522   // BluetoothDevice object we need.
 523   if (!pairing_device_address_.empty()) {
 524     device::BluetoothDevice* device =
 525         adapter_->GetDevice(pairing_device_address_);
 526     DCHECK(device);
 527     DeviceConnecting(device);
 528   }
 529 }
 530
 531 void BluetoothOptionsHandler::ReportError(
 532     const std::string& error,
 533     const std::string& address) {
 534   base::DictionaryValue properties;
 535   properties.SetString("label", error);
 536   properties.SetString("address", address);
 537   web_ui()->CallJavascriptFunction(
 538       "options.BluetoothPairing.showMessage",
 539       properties);
 540 }
 541
 542 void BluetoothOptionsHandler::DeviceAdded(device::BluetoothAdapter* adapter,
 543                                           device::BluetoothDevice* device) {
 544   DCHECK(adapter == adapter_.get());
 545   DCHECK(device);
 546   SendDeviceNotification(device, NULL);
 547 }
 548
 549 void BluetoothOptionsHandler::DeviceChanged(device::BluetoothAdapter* adapter,
 550                                             device::BluetoothDevice* device) {
 551   DCHECK(adapter == adapter_.get());
 552   DCHECK(device);
 553   SendDeviceNotification(device, NULL);
 554 }
 555
 556 void BluetoothOptionsHandler::DeviceRemoved(device::BluetoothAdapter* adapter,
 557                                             device::BluetoothDevice* device) {
 558   DCHECK(adapter == adapter_.get());
 559   DCHECK(device);
 560
 561   // Invalidate the local cache if the pairing device is removed.
 562   if (pairing_device_address_ == device->GetAddress()) {
 563     pairing_device_address_.clear();
 564     pairing_device_entered_ = kInvalidEntered;
 565   }
 566
 567   base::StringValue address(device->GetAddress());
 568   web_ui()->CallJavascriptFunction(
 569       "options.BrowserOptions.removeBluetoothDevice",
 570       address);
 571 }
 572
 573 void BluetoothOptionsHandler::DeviceConnecting(
 574     device::BluetoothDevice* device) {
 575   DCHECK(device);
 576   DictionaryValue params;
 577   params.SetString("pairing", kStartConnecting);
 578   SendDeviceNotification(device, &params);
 579 }
 580
 581 }  // namespace options
 582 }  // namespace chromeos