MD Settings: Move bluetooth UI from dialog to subpage

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

 // Copyright 2017 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-subpage' is the settings subpage for managing bluetooth
  *  properties and devices.
  */
 
+// NOTE(dbeam): even though this behaviors is only used privately, it must

[fukino, 2017/02/08 16:58:24]

nit: s/behaviors/behavior

[stevenjb, 2017/02/08 20:27:00]

Done.

+// be globally accessible for Closure's --polymer_pass to compile happily.
+
 Polymer({
   is: 'settings-bluetooth-subpage',
 
-  behaviors: [I18nBehavior, CrScrollableBehavior],
+  behaviors: [
+    I18nBehavior,
+    CrScrollableBehavior,
+    settings.RouteObserverBehavior,
+  ],
 
   properties: {
     /** Reflects the bluetooth-page property. */
     bluetoothEnabled: {
       type: Boolean,
+      observer: 'bluetoothEnabledChanged_',
       notify: true,
     },
 
     /**
      * The bluetooth adapter state, cached by bluetooth-page.
      * @type {!chrome.bluetooth.AdapterState|undefined}
      */
     adapterState: Object,
 
     /** Informs bluetooth-page whether to show the spinner in the header. */
-    showSpinner: {
+    showSpinner_: {
       type: Boolean,
       notify: true,
-      computed: 'computeShowSpinner_(bluetoothEnabled, dialogId_)',
+      computed: 'computeShowSpinner_(adapterState.*, dialogId_)',
     },
 
     /**
      * The ordered list of bluetooth devices.
      * @type {!Array<!chrome.bluetooth.Device>}
      * @private
      */
     deviceList_: {
       type: Array,
       value: function() {
@@ skipping 10 matching lines @@
       value: /** @return {Array} */ function() {
         return [];
       },
     },
 
     /**
      * Reflects the iron-list selecteditem property.
      * @type {!chrome.bluetooth.Device}
      * @private
      */
-    selectedItem_: {
+    selectedPairedItem_: {
       type: Object,
-      observer: 'selectedItemChanged_',
+      observer: 'selectedPairedItemChanged_',
+    },
+
+    /**
+     * The ordered list of unpaired bluetooth devices.
+     * @type {!Array<!chrome.bluetooth.Device>}
+     */
+    unpairedDeviceList_: {
+      type: Array,
+      value: /** @return {Array} */ function() {
+        return [];
+      },
+    },
+
+    /**
+     * Reflects the iron-list selecteditem property.
+     * @type {!chrome.bluetooth.Device}
+     */
+    selectedUnpairedItem_: {
+      type: Object,
+      observer: 'selectedUnpairedItemChanged_',
     },
 
     /**
      * Set to the name of the dialog to show. This page uses a single
-     * paper-dialog to host one of three dialog elements, 'addDevice',
-     * 'pairDevice', or 'connectError'. This allows a seamless transition
-     * between dialogs. Note: This property should be set before opening the
-     * dialog and setting the property will not itself cause the dialog to open.
+     * paper-dialog to host one of two dialog elements: 'pairDevice' or
+     * 'connectError'. This allows a seamless transition between dialogs.
+     * Note: This property should be set before opening the dialog and setting
+     * the property will not itself cause the dialog to open.
      * @private
      */
     dialogId_: {
       type: String,
       value: '',
     },
 
     /**
      * Current Pairing device.
      * @type {!chrome.bluetooth.Device|undefined}
@@ skipping 69 matching lines @@
           this.bluetoothAdapterStateChangedListener_);
     }
     if (this.bluetoothDeviceUpdatedListener_) {
       this.bluetooth.onDeviceAdded.removeListener(
           this.bluetoothDeviceUpdatedListener_);
       this.bluetooth.onDeviceChanged.removeListener(
           this.bluetoothDeviceUpdatedListener_);
     }
   },
 
+  /**
+   * settings.RouteObserverBehavior
+   * @param {!settings.Route} route
+   * @protected
+   */
+  currentRouteChanged: function(route) {
+    if (route == settings.Route.BLUETOOTH_DEVICES) {
+      if (this.bluetoothEnabled)
+        this.startDiscovery_();
+    } else {
+      this.stopDiscovery_();
+    }
+  },
+
   /** @private */
   computeShowSpinner_: function() {
-    return this.bluetoothEnabled && !this.dialogId_;
+    return !this.dialogId_ && this.get('adapterState.discovering');
   },
 
   /** @private */
   adapterStateChanged_: function() {
     this.updateDeviceList_();
   },
 
   /** @private */
+  bluetoothEnabledChanged_: function() {
+    if (settings.getCurrentRoute() == settings.Route.BLUETOOTH_DEVICES &&
+        this.bluetoothEnabled) {
+      this.startDiscovery_();
+    } else{

[fukino, 2017/02/08 16:58:23]

nit: space after else

[stevenjb, 2017/02/08 20:27:01]

Done.

+      this.stopDiscovery_();
+    }
+  },
+
+  /** @private */
   deviceListChanged_: function() {
-    this.saveScroll(this.$.devices);
+    this.saveScroll(this.$.pairedDevices);
+    this.saveScroll(this.$.unpairedDevices);
     this.pairedDeviceList_ = this.deviceList_.filter(function(device) {
       return !!device.paired || !!device.connecting;
     });
+    this.unpairedDeviceList_ = this.deviceList_.filter(function(device) {
+      return !device.paired;
+    });
     this.updateScrollableContents();
-    this.restoreScroll(this.$.devices);
+    this.restoreScroll(this.$.unpairedDevices);
+    this.restoreScroll(this.$.pairedDevices);
   },
 
   /** @private */
-  selectedItemChanged_: function() {
-    if (this.selectedItem_)
-      this.connectDevice_(this.selectedItem_);
+  selectedPairedItemChanged_: function() {
+    if (this.selectedPairedItem_)
+      this.connectDevice_(this.selectedPairedItem_);
+  },
+
+  /** @private */
+  selectedUnpairedItemChanged_: function() {
+    if (this.selectedUnpairedItem_)
+      this.connectDevice_(this.selectedUnpairedItem_);
   },
 
   /**
    * If bluetooth is enabled, request the complete list of devices and update
    * this.deviceList_.
    * @private
    */
   updateDeviceList_: function() {
     if (!this.bluetoothEnabled) {
       this.deviceList_ = [];
@@ skipping 63 matching lines @@
       var lastError = chrome.runtime.lastError;
       if (lastError) {
         if (lastError.message == 'Failed to stop discovery')
           return;  // May happen if also stopped elsewhere, ignore.
         console.error('stopDiscovery Error: ' + lastError.message);
       }
     });
   },
 
   /**
-   * @param {!Event} e
-   * @private
-   */
-  onAddDeviceTap_: function(e) {
-    e.preventDefault();
-    this.openDialog_('addDevice');
-  },
-
-  /**
    * @param {!{detail: {action: string, device: !chrome.bluetooth.Device}}} e
    * @private
    */
   onDeviceEvent_: function(e) {
     var action = e.detail.action;
     var device = e.detail.device;
     if (action == 'connect')
       this.connectDevice_(device);
     else if (action == 'disconnect')
       this.disconnectDevice_(device);
     else if (action == 'remove')
       this.forgetDevice_(device);
     else
       console.error('Unexected action: ' + action);
   },
 
   /**
    * @return {string}
    * @private
    */
   getOffOnString_: function() {
     return this.i18n(this.bluetoothEnabled ? 'bluetoothOn' : 'bluetoothOff');
   },
 
   /**
+   * @param {boolean} bluetoothEnabled
+   * @param {!Array<!chrome.bluetooth.Device>} deviceList
    * @return {boolean}
    * @private
    */
-  showDevices_: function() {
-    return this.bluetoothEnabled && this.pairedDeviceList_.length > 0;
+  showDevices_: function(bluetoothEnabled, deviceList) {
+    return bluetoothEnabled && deviceList.length > 0;
   },
 
   /**
+   * @param {boolean} bluetoothEnabled
+   * @param {!Array<!chrome.bluetooth.Device>} deviceList
    * @return {boolean}
    * @private
    */
-  showNoDevices_: function() {
-    return this.bluetoothEnabled && this.pairedDeviceList_.length == 0;
+  showNoDevices_: function(bluetoothEnabled, deviceList) {
+    return bluetoothEnabled && deviceList.length == 0;
   },
 
   /**
    * @param {!chrome.bluetooth.Device} device
    * @private
    */
   connectDevice_: function(device) {
     // If the device is not paired, show the pairing dialog before connecting.
     if (!device.paired) {
       this.pairingDevice_ = device;
       this.openDialog_('pairDevice');
     }
 
     this.bluetoothPrivate.connect(device.address, function(result) {
       var error;
       if (chrome.runtime.lastError) {
         error = chrome.runtime.lastError.message;
       } else {
         switch (result) {
+          case chrome.bluetoothPrivate.ConnectResultType.IN_PROGRESS:
+            return;  // Do not close the dialog
           case chrome.bluetoothPrivate.ConnectResultType.ALREADY_CONNECTED:
           case chrome.bluetoothPrivate.ConnectResultType.AUTH_CANCELED:
-          case chrome.bluetoothPrivate.ConnectResultType.IN_PROGRESS:
           case chrome.bluetoothPrivate.ConnectResultType.SUCCESS:
             break;
           default:
             error = result;
         }
       }
 
       if (!error) {
         this.$.deviceDialog.close();
         return;
@@ skipping 47 matching lines @@
   openDialog_: function(dialogId) {
     if (this.dialogId_) {
       // Dialog already opened, just update the contents.
       this.dialogId_ = dialogId;
       return;
     }
     this.dialogId_ = dialogId;
     // Call flush so that the dialog gets sized correctly before it is opened.
     Polymer.dom.flush();
     this.$.deviceDialog.open();
-    this.startDiscovery_();
   },
 
   /** @private */
   onDialogClosed_: function() {
-    this.stopDiscovery_();
     this.dialogId_ = '';
     this.pairingDevice_ = undefined;
   },
 });