MD Settings: Bluetooth: Additional polish

chrome/browser/resources/settings/bluetooth_page/bluetooth_page.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview
  * 'settings-bluetooth-page' is the settings page for managing bluetooth
  *  properties and devices.
  *
  * Example:
@@ skipping 61 matching lines @@
     },
 
     /**
      * Set to the name of the dialog to show. This page uses a single
      * paper-dialog to host one of two dialog elements, 'addDevice' or
      * 'pairDevice'. This allows a seamless transition between adding and
      * pairing dialogs. Note: This property should be set before opening the
      * dialog, and setting the property will not itself cause the dialog to
      * open.
      */
-    dialog: String,
+    dialogId: String,
 
     /**
      * Current Pairing device.
      * @type {?chrome.bluetooth.Device|undefined}
      */
     pairingDevice: Object,
 
     /**
      * Current Pairing event.
      * @type {?chrome.bluetoothPrivate.PairingEvent|undefined}
@@ skipping 68 matching lines @@
         this.bluetoothDeviceUpdatedListener_);
     this.bluetooth.onDeviceChanged.addListener(
         this.bluetoothDeviceUpdatedListener_);
 
     this.bluetoothDeviceRemovedListener_ =
         this.onBluetoothDeviceRemoved_.bind(this);
     this.bluetooth.onDeviceRemoved.addListener(
         this.bluetoothDeviceRemovedListener_);
 
     // Request the inital adapter state.
-    this.bluetooth.getAdapterState(
-        this.bluetoothAdapterStateChangedListener_);
+    this.bluetooth.getAdapterState(this.bluetoothAdapterStateChangedListener_);
   },
 
   /** @override */
   detached: function() {
     if (this.bluetoothAdapterStateChangedListener_) {
       this.bluetooth.onAdapterStateChanged.removeListener(
           this.bluetoothAdapterStateChangedListener_);
     }
     if (this.bluetoothDeviceUpdatedListener_) {
       this.bluetooth.onDeviceAdded.removeListener(
@@ skipping 64 matching lines @@
     this.updateDeviceList_();
   },
 
   /**
    * Process bluetooth.onDeviceAdded and onDeviceChanged events.
    * @param {!chrome.bluetooth.Device} device
    * @private
    */
   onBluetoothDeviceUpdated_: function(device) {
     var address = device.address;
-    if (this.dialog && this.pairingDevice &&
+    if (this.dialogId && this.pairingDevice &&
         this.pairingDevice.address == address) {
       this.pairingDevice = device;
     }
     var index = this.getDeviceIndex_(address);
     if (index >= 0) {
       // Use splice to update the item in order to update the dom-repeat lists.
       // See https://github.com/Polymer/polymer/issues/3254.
       this.splice('deviceList', index, 1, device);
       return;
     }
@@ skipping 24 matching lines @@
       this.bluetoothPrivate.onPairing.addListener(
           this.bluetoothPrivateOnPairingListener_);
     }
 
     this.bluetooth.startDiscovery(function() {
       if (chrome.runtime.lastError) {
         if (chrome.runtime.lastError.message == 'Failed to stop discovery') {
           // May happen if also started elsewhere; ignore.
           return;
         }
-        console.error('startDsicovery Error: ' +
-                      chrome.runtime.lastError.message);
+        console.error(
+            'startDsicovery Error: ' + chrome.runtime.lastError.message);
       }
     });
   },
 
   /** @private */
   stopDiscovery_: function() {
     if (!this.get('adapterState.discovering'))
       return;
 
     if (this.bluetoothPrivateOnPairingListener_) {
       this.bluetoothPrivate.onPairing.removeListener(
           this.bluetoothPrivateOnPairingListener_);
       this.bluetoothPrivateOnPairingListener_ = undefined;
     }
 
     this.bluetooth.stopDiscovery(function() {
       if (chrome.runtime.lastError) {
-        console.error('Error stopping bluetooth discovery: ' +
+        console.error(
+            'Error stopping bluetooth discovery: ' +
             chrome.runtime.lastError.message);
       }
     });
   },
 
   /**
    * Process bluetoothPrivate.onPairing events.
    * @param {!chrome.bluetoothPrivate.PairingEvent} e
    * @private
    */
   onBluetoothPrivateOnPairing_: function(e) {
-    if (!this.dialog || !this.pairingDevice ||
+    if (!this.dialogId || !this.pairingDevice ||
         e.device.address != this.pairingDevice.address) {
       return;
     }
     if (e.pairing == chrome.bluetoothPrivate.PairingEventType.KEYS_ENTERED &&
         e.passkey === undefined && this.pairingEvent) {
       // 'keysEntered' event might not include the updated passkey so preserve
       // the current one.
       e.passkey = this.pairingEvent.passkey;
     }
     this.pairingEvent = e;
@@ skipping 53 matching lines @@
         return i;
     }
     return -1;
   },
 
   /**
    * @param {!chrome.bluetooth.Device} device
    * @return {string} The text to display for |device| in the device list.
    * @private
    */
-  getDeviceName_: function(device) {
-    return device.name || device.address;
-  },
+  getDeviceName_: function(device) { return device.name || device.address; },
 
   /**
    * @param {!chrome.bluetooth.Device} device
    * @return {boolean}
    * @private
    */
   deviceIsPairedOrConnecting_: function(device) {
     return !!device.paired || !!device.connecting;
   },
 
@@ skipping 47 matching lines @@
 
   /**
    * @param {!chrome.bluetooth.Device} device
    * @private
    */
   forgetDevice_: function(device) {
     this.bluetoothPrivate.forgetDevice(device.address, function() {
       if (chrome.runtime.lastError) {
         console.error(
             'Error forgetting: ' + device.name + ': ' +
-                chrome.runtime.lastError.message);
+            chrome.runtime.lastError.message);
       }
       this.updateDeviceList_();
     }.bind(this));
   },
 
   /**
-   * @param {string} dialog
+   * @param {string} dialogId
    * @param {string} dialogToShow The name of the dialog.
    * @return {boolean}
    * @private
    */
-  dialogIsVisible_(dialog, dialogToShow) {
-    return dialogToShow == dialog;
-  },
+  dialogIsVisible_(dialogId, dialogToShow) { return dialogToShow == dialogId; },
 
   /**
    * @param {string} dialogId
    * @private
    */
   openDialog_: function(dialogId) {
-    if (this.dialog) {
+    if (this.dialogId) {
       // Dialog already opened, just update the contents.
-      this.dialog = dialogId;
+      this.dialogId = dialogId;
       return;
     }
-    this.dialog = dialogId;
+    this.dialogId = dialogId;
     // Call flush so that the dialog gets sized correctly before it is opened.
     Polymer.dom.flush();
     var dialog = this.$$('#deviceDialog');
     dialog.open();
     dialog.focus();
   },
 
   /** @private */
   closeDialog_: function() {
-    if (!this.dialog)
+    if (!this.dialogId)
       return;
     var dialog = this.$$('#deviceDialog');
     dialog.close();
-    this.dialog = '';
+    this.dialogId = '';
     this.pairingDevice = null;
     this.pairingEvent = null;
   },
 
   /** @private */
   onCloseDialog_: function(event) { this.closeDialog_(); },
 
   /** @private */
   onDialogOpened_: function() { this.startDiscovery_(); },
 
   /** @private */
   onDialogClosed_: function() { this.stopDiscovery_(); },
 });