cros: Tweaked the good/bad pin checking on the js to use the new quick unlock api function.

chrome/browser/resources/settings/people_page/setup_pin_dialog.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-setup-pin-dialog' is the settings page for choosing a PIN.
  *
  * Example:
  *
  * <settings-setup-pin-dialog set-modes="[[quickUnlockSetModes]]">
  * </settings-setup-pin-dialog>
  */
 
 (function() {
 'use strict';
 
 /**
- * A list of the top-10 most commmonly used PINs. This list is taken from
- * www.datagenetics.com/blog/september32012/.
- * @const
+ * Keep in sync with the string keys provided by settings.
+ * @enum {string}
  */
-var WEAK_PINS = [
-  '1234', '1111', '0000', '1212', '7777', '1004', '2000', '4444', '2222',
-  '6969'
-];
+var MessageType = {
+  TOO_SHORT: 'configurePinTooShort',
+  TOO_LONG: 'configurePinTooLong',
+  TOO_WEAK: 'configurePinWeakPin',
+  MISMATCH: 'configurePinMismatched'
+};
+
+/** @enum {string} */
+var ProblemType = {
+  WARNING: 'warning',
+  ERROR: 'error'
+};
 
 Polymer({
   is: 'settings-setup-pin-dialog',
 
   behaviors: [I18nBehavior],
 
   properties: {
     /**
      * The current PIN keyboard value.
      * @private
@@ skipping 36 matching lines @@
     },
 
     /**
      * The current step/subpage we are on.
      * @private
      */
     isConfirmStep_: {
       type: Boolean,
       value: false
     },
+
+    /**
+     * Interface for chrome.quickUnlockPrivate calls. May be overriden by tests.
+     * @private
+     */
+    quickUnlockPrivate_: {
+      type: Object,
+      value: chrome.quickUnlockPrivate
+    },
   },
 
   /** @override */
   attached: function() {
     this.resetState_();
   },
 
   open: function() {
     this.$.dialog.showModal();
     this.$.pinKeyboard.focus();
   },
 
   close: function() {
     if (this.$.dialog.open)
       this.$.dialog.close();
 
     this.resetState_();
   },
 
   /**
    * Resets the element to the initial state.
    * @private
    */
   resetState_: function() {
     this.initialPin_ = '';
     this.pinKeyboardValue_ = '';
     this.enableSubmit_ = false;
     this.isConfirmStep_ = false;
+    this.hideProblem_();
     this.onPinChange_();
   },
 
   /** @private */
   onCancelTap_: function() {
     this.resetState_();
     this.$.dialog.close();
   },
 
   /**
-   * Returns true if the given PIN is likely easy to guess.
+   * Returns true if the PIN is ready to be changed to a new value.
    * @private
-   * @param {string} pin
    * @return {boolean}
    */
-  isPinWeak_: function(pin) {
-    // Warn if it's a top-10 pin.
-    if (WEAK_PINS.includes(pin))
-      return true;
-
-    // Warn if the PIN is consecutive digits.
-    var delta = 0;
-    for (var i = 1; i < pin.length; ++i) {
-      var prev = Number(pin[i - 1]);
-      var num = Number(pin[i]);
-      if (Number.isNaN(prev) || Number.isNaN(num))
-        return false;
-      delta = Math.max(delta, Math.abs(num - prev));
-    }
-
-    return delta <= 1;
+  canSubmit_: function() {
+    return this.initialPin_ == this.pinKeyboardValue_;
   },
 
   /**
-   * Returns true if the given PIN matches PIN requirements, such as minimum
-   * length.
+   * Handles writting the appropriate message to |problemMessage_|.
    * @private
-   * @param {string|undefined} pin
-   * @return {boolean}
+   * @param {string} messageId
+   * @param {chrome.quickUnlockPrivate.CredentialRequirements} requirements
+   *     The requirements received from getCredentialRequirements.
    */
-  isPinLongEnough_: function(pin) {
-    return !!pin && pin.length >= 4;
+  processPinRequirements_: function(messageId, requirements) {
+    var additionalInformation = '';
+    switch (messageId) {
+      case MessageType.TOO_SHORT:
+        additionalInformation = requirements.minLength.toString();
+        break;
+      case MessageType.TOO_LONG:
+        additionalInformation = requirements.maxLength.toString();
+        break;
+      case MessageType.TOO_WEAK:
+      case MessageType.MISMATCH:
+        break;
+      default:
+        assertNotReached();
+        break;
+    }
+    this.problemMessage_ = this.i18n(messageId, additionalInformation);
   },
 
   /**
-   * Returns true if the currently entered PIN is the same as the initially
-   * submitted PIN.
-   * @private
-   * @return {boolean}
-   */
-  isPinConfirmed_: function() {
-    return this.isPinLongEnough_(this.pinKeyboardValue_) &&
-           this.initialPin_ == this.pinKeyboardValue_;
-  },
-
-  /**
    * Notify the user about a problem.
    * @private
    * @param {string} messageId
    * @param {string} problemClass
    */
   showProblem_: function(messageId, problemClass) {
-    var previousMessage = this.problemMessage_;
-
-    // Update problem info.
-    this.problemMessage_ = this.i18n(messageId);
+    this.quickUnlockPrivate_.getCredentialRequirements(
+        chrome.quickUnlockPrivate.QuickUnlockMode.PIN,
+        this.processPinRequirements_.bind(this, messageId));
     this.problemClass_ = problemClass;
     this.updateStyles();
-
-    // If the problem message has changed, fire an alert.
-    if (previousMessage != this.problemMessage_)
-      this.$.problemDiv.setAttribute('role', 'alert');
-   },
+    this.enableSubmit_ = problemClass != ProblemType.ERROR &&
+        messageId != MessageType.MISMATCH;
+  },
 
   /** @private */
   hideProblem_: function() {
     this.problemMessage_ = '';
     this.problemClass_ = '';
   },
 
+  /**
+   * Processes the message received from the quick unlock api and hides/shows
+   * the problem based on the message.
+   * @private
+   * @param {chrome.quickUnlockPrivate.CredentialCheck} message The message
+   *     received from checkCredential.
+   */
+  processPinProblems_: function(message) {
+    if (!message.errors.length && !message.warnings.length) {
+      this.hideProblem_();
+      this.enableSubmit_ = true;
+      return;
+    }
+
+    if (message.warnings.length) {
+      assert(message.warnings[0] ==
+          chrome.quickUnlockPrivate.CredentialProblem.TOO_WEAK);
+      this.showProblem_(MessageType.TOO_WEAK, ProblemType.WARNING);
+    }
+
+    if (message.errors.length) {
+      switch (message.errors[0]) {
+        case chrome.quickUnlockPrivate.CredentialProblem.TOO_SHORT:
+          this.showProblem_(MessageType.TOO_SHORT, ProblemType.ERROR);
+          break;
+        case chrome.quickUnlockPrivate.CredentialProblem.TOO_LONG:
+          this.showProblem_(MessageType.TOO_LONG, ProblemType.ERROR);

[stevenjb, 2017/01/03 18:35:13]

break;

[sammiequon, 2017/01/03 22:15:07]

Done.

+        case chrome.quickUnlockPrivate.CredentialProblem.TOO_WEAK:
+          this.showProblem_(MessageType.TOO_WEAK, ProblemType.ERROR);
+          break;
+        default:
+          assertNotReached();
+          break;
+      }
+    }
+
+  },
+
   /** @private */
   onPinChange_: function() {
     if (!this.isConfirmStep_) {
-      var isPinLongEnough = this.isPinLongEnough_(this.pinKeyboardValue_);
-      var isWeak = isPinLongEnough && this.isPinWeak_(this.pinKeyboardValue_);
+      if (this.pinKeyboardValue_) {
+        this.quickUnlockPrivate_.checkCredential(
+            chrome.quickUnlockPrivate.QuickUnlockMode.PIN,
+            this.pinKeyboardValue_,
+            this.processPinProblems_.bind(this));
+      }
+      return;
+    }
 
-      if (!isPinLongEnough)
-        this.showProblem_('configurePinTooShort', 'warning');
-      else if (isWeak)
-        this.showProblem_('configurePinWeakPin', 'warning');
-      else
-        this.hideProblem_();
+    if (this.canSubmit_()) {
+      this.hideProblem_();
+      this.enableSubmit_ = true;
+      return;
+    }
 
-      this.enableSubmit_ = isPinLongEnough;
-
-    } else {
-      if (this.isPinConfirmed_())
-        this.hideProblem_();
-      else
-        this.showProblem_('configurePinMismatched', 'warning');
-
-      this.enableSubmit_ = true;
-    }
+    this.showProblem_(MessageType.MISMATCH, ProblemType.WARNING);
   },
 
   /** @private */
   onPinSubmit_: function() {
     if (!this.isConfirmStep_) {
-      if (this.isPinLongEnough_(this.pinKeyboardValue_)) {
-        this.initialPin_ = this.pinKeyboardValue_;
-        this.pinKeyboardValue_ = '';
-        this.isConfirmStep_ = true;
-        this.onPinChange_();
-        this.$.pinKeyboard.focus();
-        this.writeUma_(LockScreenProgress.ENTER_PIN);
-      }
-    } else {
-      // onPinSubmit_ gets called if the user hits enter on the PIN keyboard.
-      // The PIN is not guaranteed to be valid in that case.
-      if (!this.isPinConfirmed_()) {
-        this.showProblem_('configurePinMismatched', 'error');
+      this.initialPin_ = this.pinKeyboardValue_;
+      this.pinKeyboardValue_ = '';
+      this.isConfirmStep_ = true;
+      this.onPinChange_();
+      this.$.pinKeyboard.focus();
+      this.writeUma_(LockScreenProgress.ENTER_PIN);
+      return;
+    }
+    // onPinSubmit_ gets called if the user hits enter on the PIN keyboard.
+    // The PIN is not guaranteed to be valid in that case.
+    if (!this.canSubmit_()) {
+      this.showProblem_(MessageType.MISMATCH, ProblemType.ERROR);
+      return;
+    }
+
+    function onSetModesCompleted(didSet) {
+      if (!didSet) {
+        console.error('Failed to update pin');
         return;
       }
 
-      function onSetModesCompleted(didSet) {
-        if (!didSet) {
-          console.error('Failed to update pin');
-          return;
-        }
+      this.resetState_();
+      this.fire('done');
+    }
 
-        this.resetState_();
-        this.fire('done');
-      }
-
-      this.setModes.call(
-        null,
-        [chrome.quickUnlockPrivate.QuickUnlockMode.PIN],
-        [this.pinKeyboardValue_],
-        onSetModesCompleted.bind(this));
-      this.writeUma_(LockScreenProgress.CONFIRM_PIN);
-    }
+    this.setModes.call(
+      null,
+      [chrome.quickUnlockPrivate.QuickUnlockMode.PIN],
+      [this.pinKeyboardValue_],
+      onSetModesCompleted.bind(this));
+    this.writeUma_(LockScreenProgress.CONFIRM_PIN);
   },
 
   /**
    * @private
    * @param {string} problemMessage
    * @return {boolean}
    */
   hasProblem_: function(problemMessage) {
     return !!problemMessage;
   },
@@ skipping 12 matching lines @@
    * @private
    * @param {boolean} isConfirmStep
    * @return {string}
    */
   getContinueMessage_: function(isConfirmStep) {
     return this.i18n(isConfirmStep ? 'confirm' : 'configurePinContinueButton');
   },
 });
 
 })();