Update cryptotoken to 0.8.63

chrome/browser/resources/cryptotoken/singlesigner.js

 // Copyright 2014 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 A single gnubby signer wraps the process of opening a gnubby,
  * signing each challenge in an array of challenges until a success condition
  * is satisfied, and finally yielding the gnubby upon success.
  *
  */
@@ skipping 54 matching lines @@
   /** @private {string|undefined} */
   this.logMsgUrl_ = opt_logMsgUrl;
 
   /** @private {!Array.<!SignHelperChallenge>} */
   this.challenges_ = [];
   /** @private {number} */
   this.challengeIndex_ = 0;
   /** @private {boolean} */
   this.challengesSet_ = false;
 
-  /** @private {!Array.<string>} */
-  this.notForMe_ = [];
+  /** @private {!Object.<string, number>} */
+  this.cachedError_ = [];
 }
 
 /** @enum {number} */
 SingleGnubbySigner.State = {
   /** Initial state. */
   INIT: 0,
   /** The signer is attempting to open a gnubby. */
   OPENING: 1,
   /** The signer's gnubby opened, but is busy. */
   BUSY: 2,
@@ skipping 148 matching lines @@
           }
         }, SingleGnubbySigner.OPEN_DELAY_MILLIS);
       } else {
         this.goToError_(DeviceStatusCodes.BUSY_STATUS);
       }
       break;
     default:
       // TODO: This won't be confused with success, but should it be
       // part of the same namespace as the other error codes, which are
       // always in DeviceStatusCodes.*?
-      this.goToError_(rc);
+      this.goToError_(rc, true);
   }
 };
 
 /**
  * Called with the result of a version command.
  * @param {number} rc Result of version command.
  * @param {ArrayBuffer=} opt_data Version.
  * @private
  */
 SingleGnubbySigner.prototype.versionCallback_ = function(rc, opt_data) {
   if (rc) {
-    this.goToError_(rc);
+    this.goToError_(rc, true);
     return;
   }
   this.state_ = SingleGnubbySigner.State.IDLE;
   this.version_ = UTIL_BytesToString(new Uint8Array(opt_data || []));
   this.doSign_(this.challengeIndex_);
 };
 
 /**
  * @param {number} challengeIndex Index of challenge to sign
  * @private
@@ skipping 20 matching lines @@
 
   if (challengeIndex >= this.challenges_.length) {
     this.signCallback_(challengeIndex, DeviceStatusCodes.WRONG_DATA_STATUS);
     return;
   }
 
   var challenge = this.challenges_[challengeIndex];
   var challengeHash = challenge.challengeHash;
   var appIdHash = challenge.appIdHash;
   var keyHandle = challenge.keyHandle;
-  if (this.notForMe_.indexOf(keyHandle) != -1) {
+  if (this.cachedError_.hasOwnProperty(keyHandle)) {
     // Cache hit: return wrong data again.
-    this.signCallback_(challengeIndex, DeviceStatusCodes.WRONG_DATA_STATUS);
+    this.signCallback_(challengeIndex, this.cachedError_[keyHandle]);
   } else if (challenge.version && challenge.version != this.version_) {
     // Sign challenge for a different version of gnubby: return wrong data.
     this.signCallback_(challengeIndex, DeviceStatusCodes.WRONG_DATA_STATUS);
   } else {
     var nowink = false;
     this.gnubby_.sign(challengeHash, appIdHash, keyHandle,
         this.signCallback_.bind(this, challengeIndex),
         nowink);
   }
 };
 
 /**
  * Called with the result of a single sign operation.
  * @param {number} challengeIndex the index of the challenge just attempted
  * @param {number} code the result of the sign operation
  * @param {ArrayBuffer=} opt_info Optional result data
  * @private
  */
 SingleGnubbySigner.prototype.signCallback_ =
     function(challengeIndex, code, opt_info) {
   console.log(UTIL_fmt('gnubby ' + JSON.stringify(this.gnubbyId_) +
       ', challenge ' + challengeIndex + ' yielded ' + code.toString(16)));
   if (this.state_ != SingleGnubbySigner.State.SIGNING) {
     console.log(UTIL_fmt('already done!'));
     // We're done, the caller's no longer interested.
     return;
   }
 
-  // Cache wrong data result, re-asking the gnubby to sign it won't produce
-  // different results.
-  if (code == DeviceStatusCodes.WRONG_DATA_STATUS) {
+  // Cache wrong data or wrong length results, re-asking the gnubby to sign it
+  // won't produce different results.
+  if (code == DeviceStatusCodes.WRONG_DATA_STATUS ||
+      code == DeviceStatusCodes.WRONG_LENGTH_STATUS) {
     if (challengeIndex < this.challenges_.length) {
       var challenge = this.challenges_[challengeIndex];
-      if (this.notForMe_.indexOf(challenge.keyHandle) == -1) {
-        this.notForMe_.push(challenge.keyHandle);
+      if (!this.cachedError_.hasOwnProperty(challenge.keyHandle)) {
+        this.cachedError_[challenge.keyHandle] = code;
       }
     }
   }
 
   var self = this;
   switch (code) {
     case DeviceStatusCodes.GONE_STATUS:
       this.goToError_(code);
       break;
 
@@ skipping 11 matching lines @@
       }
       break;
 
     case DeviceStatusCodes.WAIT_TOUCH_STATUS:
       window.setTimeout(function() {
         self.doSign_(self.challengeIndex_);
       }, SingleGnubbySigner.SIGN_DELAY_MILLIS);
       break;
 
     case DeviceStatusCodes.WRONG_DATA_STATUS:
+    case DeviceStatusCodes.WRONG_LENGTH_STATUS:
       if (this.challengeIndex_ < this.challenges_.length - 1) {
         this.doSign_(++this.challengeIndex_);
       } else if (this.forEnroll_) {
         this.goToSuccess_(code);
       } else {
         this.goToError_(code);
       }
       break;
 
     default:
       if (this.forEnroll_) {
-        this.goToError_(code);
+        this.goToError_(code, true);
       } else if (this.challengeIndex_ < this.challenges_.length - 1) {
         this.doSign_(++this.challengeIndex_);
       } else {
-        this.goToError_(code);
+        this.goToError_(code, true);
       }
   }
 };
 
 /**
  * Switches to the error state, and notifies caller.
  * @param {number} code Error code
+ * @param {boolean=} opt_warn Whether to warn in the console about the error.
  * @private
  */
-SingleGnubbySigner.prototype.goToError_ = function(code) {
+SingleGnubbySigner.prototype.goToError_ = function(code, opt_warn) {
   this.state_ = SingleGnubbySigner.State.COMPLETE;
-  console.log(UTIL_fmt('failed (' + code.toString(16) + ')'));
+  var logFn = opt_warn ? console.warn.bind(console) : console.log.bind(console);
+  logFn(UTIL_fmt('failed (' + code.toString(16) + ')'));
   // Since this gnubby can no longer produce a useful result, go ahead and
   // close it.
   this.close();
   var result = { code: code };
   this.completeCb_(result);
 };
 
 /**
  * Switches to the success state, and notifies caller.
  * @param {number} code Status code
@@ skipping 11 matching lines @@
       result['challenge'] = opt_challenge;
     }
     if (opt_info) {
       result['info'] = opt_info;
     }
   }
   this.completeCb_(result);
   // this.gnubby_ is now owned by completeCb_.
   this.gnubby_ = null;
 };