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
     },
 
     /**
      * setModes_ is a partially applied function that stores the previously
      * entered password. It's defined only when the user has already entered a
@@ skipping 41 matching lines @@
         return loadTimeData.getBoolean('fingerprintUnlockEnabled');
       },
       readOnly: true,
     },
 
     /** @private */
     numFingerprints_: {
       type: Number,
       value: 0,
     },
+
+    /** @private {!settings.EasyUnlockBrowserProxy} */
+    easyUnlockBrowserProxy_: {
+      type: Object,
+      value: function() {
+        return settings.EasyUnlockBrowserProxyImpl.getInstance();
+      },
+    },
+
+    /**
+     * 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.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.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.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) {
+    e.preventDefault();

[jdufault, 2017/04/06 21:04:45]

Can the preventDefault be removed? Looks like this was copied but we should
figure out why it is there and add a comment.

[sammiequon, 2017/04/06 22:23:50]

Seems like this is settings-wide thing explicitly added in
https://codereview.chromium.org/2557073003. Do we still need a comment?

[jdufault, 2017/04/06 22:31:44]

It if clearly breaks w/o e.preventDefault() no comment, but if the breakage is
subtle please add one.

[sammiequon, 2017/04/06 23:36:27]

Done.

+    this.showEasyUnlockTurnOffDialog_ = true;
+  },
+
+  /** @private */
+  onEasyUnlockTurnOffDialogClose_: function() {
+    this.showEasyUnlockTurnOffDialog_ = false;
+  },
 });