MD Settings: Move easy unlock from people to lock screen.

chrome/browser/resources/settings/people_page/lock_screen.js

 // Copyright 2016 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-lock-screen' allows the user to change how they unlock their
  * device.
  *
  * Example:
  *
  * <settings-lock-screen
  *   prefs="{{prefs}}">
  * </settings-lock-screen>
  */
 
 Polymer({
   is: 'settings-lock-screen',
 
-  behaviors: [I18nBehavior, LockStateBehavior, settings.RouteObserverBehavior],
+  behaviors: [
+    I18nBehavior,
+    LockStateBehavior,
+    WebUIListenerBehavior,
+    settings.RouteObserverBehavior,
+  ],
 
   properties: {
     /** Preferences state. */
-    prefs: {
-      type: Object
-    },
+    prefs: {type: Object},
 
     /**
      * setModes_ is a partially applied function that stores the previously
      * entered password. It's defined only when the user has already entered a
      * valid password.
      *
      * @type {Object|undefined}
      * @private
      */
     setModes_: {
       type: Object,
-      observer: 'onSetModesChanged_'
+      observer: 'onSetModesChanged_',
     },
 
     /**
      * writeUma_ is a function that handles writing uma stats. It may be
      * overridden for tests.
      *
      * @type {Function}
      * @private
      */
     writeUma_: {
       type: Object,
-      value: function() { return settings.recordLockScreenProgress; }
+      value: function() {
+        return settings.recordLockScreenProgress;
+      },
     },
 
     /**
      * True if pin unlock settings should be displayed on this machine.
      * @private
      */
     pinUnlockEnabled_: {
       type: Boolean,
       value: function() {
         return loadTimeData.getBoolean('pinUnlockEnabled');
@@ skipping 11 matching lines @@
         return loadTimeData.getBoolean('fingerprintUnlockEnabled');
       },
       readOnly: true,
     },
 
     /** @private */
     numFingerprints_: {
       type: Number,
       value: 0,
     },
+
+    /**
+     * True if Easy Unlock is allowed on this machine.
+     */
+    easyUnlockAllowed_: {
+      type: Boolean,
+      value: function() {
+        return loadTimeData.getBoolean('easyUnlockAllowed');
+      },
+      readOnly: true,
+    },
+
+    /**
+     * True if Easy Unlock is enabled.
+     */
+    easyUnlockEnabled_: {
+      type: Boolean,
+      value: function() {
+        return loadTimeData.getBoolean('easyUnlockEnabled');
+      },
+    },
+
+    /**
+     * True if Easy Unlock's proximity detection feature is allowed.
+     */
+    easyUnlockProximityDetectionAllowed_: {
+      type: Boolean,
+      value: function() {
+        return loadTimeData.getBoolean('easyUnlockAllowed') &&
+            loadTimeData.getBoolean('easyUnlockProximityDetectionAllowed');
+      },
+      readOnly: true,
+    },
+
+    /** @private */
+    showEasyUnlockTurnOffDialog_: {
+      type: Boolean,
+      value: false,
+    },
   },
 
+  /** @private {?settings.EasyUnlockBrowserProxy} */
+  easyUnlockBrowserProxy_: null,
+
   /** @private {?settings.FingerprintBrowserProxy} */
-  browserProxy_: null,
+  fingerprintBrowserProxy_: null,
 
   /** selectedUnlockType is defined in LockStateBehavior. */
   observers: ['selectedUnlockTypeChanged_(selectedUnlockType)'],
 
   /** @override */
   attached: function() {
     if (this.shouldAskForPassword_(settings.getCurrentRoute()))
       this.$.passwordPrompt.open();
-    this.browserProxy_ = settings.FingerprintBrowserProxyImpl.getInstance();
+
+    this.easyUnlockBrowserProxy_ =
+        settings.EasyUnlockBrowserProxyImpl.getInstance();
+    this.fingerprintBrowserProxy_ =
+        settings.FingerprintBrowserProxyImpl.getInstance();
+
+    if (this.easyUnlockAllowed_) {
+      this.addWebUIListener(
+          'easy-unlock-enabled-status',
+          this.handleEasyUnlockEnabledStatusChanged_.bind(this));
+      this.easyUnlockBrowserProxy_.getEnabledStatus().then(
+          this.handleEasyUnlockEnabledStatusChanged_.bind(this));
+    }
   },
 
   /**
    * Overridden from settings.RouteObserverBehavior.
    * @param {!settings.Route} newRoute
    * @param {!settings.Route} oldRoute
    * @protected
    */
   currentRouteChanged: function(newRoute, oldRoute) {
     if (newRoute == settings.Route.LOCK_SCREEN &&
-        this.fingerprintUnlockEnabled_ &&
-        this.browserProxy_) {
-      this.browserProxy_.getNumFingerprints().then(
+        this.fingerprintUnlockEnabled_ && this.fingerprintBrowserProxy_) {
+      this.fingerprintBrowserProxy_.getNumFingerprints().then(
           function(numFingerprints) {
             this.numFingerprints_ = numFingerprints;
           }.bind(this));
     }
 
     if (this.shouldAskForPassword_(newRoute)) {
       this.$.passwordPrompt.open();
     } else if (newRoute != settings.Route.FINGERPRINT &&
         oldRoute != settings.Route.FINGERPRINT) {
       // If the user navigated away from the lock screen settings page they will
@@ skipping 81 matching lines @@
   },
 
   /**
    * @param {!settings.Route} route
    * @return {boolean} Whether the password dialog should be shown.
    * @private
    */
   shouldAskForPassword_: function(route) {
     return route == settings.Route.LOCK_SCREEN && !this.setModes_;
   },
+
+  /**
+   * Handler for when the Easy Unlock enabled status has changed.
+   * @private
+   */
+  handleEasyUnlockEnabledStatusChanged_: function(easyUnlockEnabled) {
+    this.easyUnlockEnabled_ = easyUnlockEnabled;
+    this.showEasyUnlockTurnOffDialog_ =
+        easyUnlockEnabled && this.showEasyUnlockTurnOffDialog_;
+  },
+
+  /** @private */
+  onEasyUnlockSetupTap_: function() {
+    this.easyUnlockBrowserProxy_.startTurnOnFlow();
+  },
+
+  /**
+   * @param {!Event} e
+   * @private
+   */
+  onEasyUnlockTurnOffTap_: function(e) {
+    // Prevent the end of the tap event from focusing what is underneath the
+    // button.
+    e.preventDefault();
+    this.showEasyUnlockTurnOffDialog_ = true;
+  },
+
+  /** @private */
+  onEasyUnlockTurnOffDialogClose_: function() {
+    this.showEasyUnlockTurnOffDialog_ = false;
+
+    // Restores focus on close to either the turn-off or set-up button,
+    // whichever is being displayed.
+    this.$$('.secondary-button').focus();
+  },
+
+  /**
+   * @param {boolean} enabled
+   * @param {!string} enabledStr
+   * @param {!string} disabledStr
+   * @private
+   */
+  getEasyUnlockDescription_: function(enabled, enabledStr, disabledStr) {
+    return enabled ? enabledStr : disabledStr;
+  },
+
+  /**
+   * @param {boolean} easyUnlockEnabled
+   * @param {boolean} proximityDetectionAllowed
+   * @private
+   */
+  getShowEasyUnlockToggle_: function(
+      easyUnlockEnabled, proximityDetectionAllowed) {
+    return easyUnlockEnabled && proximityDetectionAllowed;
+  },
 });