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