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
- */
-var WEAK_PINS = [
-  '1234', '1111', '0000', '1212', '7777', '1004', '2000', '4444', '2222',
-  '6969'
-];
-
 Polymer({
   is: 'settings-setup-pin-dialog',
 
   behaviors: [I18nBehavior],
 
   properties: {
     /**
      * The current PIN keyboard value.
      * @private
      */
@@ skipping 61 matching lines @@
     this.onPinChange_();
   },
 
   /** @private */
   onCancelTap_: function() {
     this.resetState_();
     this.$.dialog.cancel();
   },
 
   /**
-   * Returns true if the given PIN is likely easy to guess.
-   * @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;
-  },
-
-  /**
-   * Returns true if the given PIN matches PIN requirements, such as minimum
-   * length.
-   * @private
-   * @param {string|undefined} pin
-   * @return {boolean}
-   */
-  isPinLongEnough_: function(pin) {
-    return !!pin && pin.length >= 4;
-  },
-
-  /**
    * Returns true if the PIN is ready to be changed to a new value.
    * @private
    * @return {boolean}
    */
   canSubmit_: function() {
-    return this.isPinLongEnough_(this.pinKeyboardValue_) &&
-           this.initialPin_ == this.pinKeyboardValue_;
+    return this.initialPin_ == this.pinKeyboardValue_;
   },
 
   /**
    * Notify the user about a problem.
    * @private
    * @param {string} messageId
    * @param {string} problemClass
+   * @param {string} additionalInformation Additional information to be
+   * displayed, such as the minimum/maximum length.
    */
-  showProblem_: function(messageId, problemClass) {
-    this.problemMessage_ = this.i18n(messageId);
+  showProblem_: function(messageId, problemClass, additionalInformation) {
+    this.problemMessage_ = this.i18n(messageId, additionalInformation);
     this.problemClass_ = problemClass;
     this.updateStyles();
+    this.enableSubmit_ = (problemClass != 'error');
   },
 
   /** @private */
   hideProblem_: function() {
     this.problemMessage_ = '';
     this.problemClass_ = '';
+    this.enableSubmit_ = true;
+  },
+
+  /**
+   * Processes the message received from the quick unlock api and hides/shows
+   * the problem based on the message.
+   * @private
+   * @param {Object} message The message received from isCredentialUsable.
+   */
+  processPinProblems_: function(message) {
+    if (message.failures.length < 1) {

[jdufault, 2016/10/04 23:11:45]

if (!messages.failures) {
  this.hideProblem_();
  return;
}

[sammiequon, 2016/10/24 21:16:10]

Done.

+      this.hideProblem_();
+      return;
+    }
+    switch (message.failures[0]) {
+      case 'TOO_SHORT':
+        this.showProblem_('configurePinTooShort', 'error',
+            message.minLength);
+        break;
+      case 'TOO_LONG':
+        this.showProblem_('configurePinTooLong', 'error',
+            message.maxLength);
+        break;
+      case 'TOO_WEAK':
+        this.showProblem_('configurePinWeakPin', 'warning');
+        break;
+      default:
+        assertNotReached();
+        break;
+    }
   },
 
   /** @private */
   onPinChange_: function() {
     if (!this.isConfirmStep_) {
-      var isPinLongEnough = this.isPinLongEnough_(this.pinKeyboardValue_);
-      var isWeak = isPinLongEnough && this.isPinWeak_(this.pinKeyboardValue_);
-
-      if (!isPinLongEnough && this.pinKeyboardValue_)
-        this.showProblem_('configurePinTooShort', 'error');
-      else if (isWeak)
-        this.showProblem_('configurePinWeakPin', 'warning');
-      else
-        this.hideProblem_();
-
-      this.enableSubmit_ = isPinLongEnough;
-
+      if (this.pinKeyboardValue_) {
+        chrome.quickUnlockPrivate.isCredentialUsable(
+            chrome.quickUnlockPrivate.QuickUnlockMode.PIN,
+            this.pinKeyboardValue_,
+            this.processPinProblems_.bind(this));
+      }
     } else {
       var canSubmit = this.canSubmit_();
 
       if (!canSubmit && this.pinKeyboardValue_)
         this.showProblem_('configurePinMismatched', 'error');
       else
         this.hideProblem_();
 
       this.enableSubmit_ = canSubmit;
     }
@@ skipping 56 matching lines @@
    * @private
    * @param {boolean} isConfirmStep
    * @return {string}
    */
   getContinueMessage_: function(isConfirmStep) {
     return this.i18n(isConfirmStep ? 'confirm' : 'configurePinContinueButton');
   },
 });
 
 })();