DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

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 32 matching lines @@
  *     enroll operation.
  * @param {function(SingleSignerResult)}
  *     completeCb Called when this signer completes, i.e. no further results are
  *     possible.
  * @param {Countdown} timer An advisory timer, beyond whose expiration the
  *     signer will not attempt any new operations, assuming the caller is no
  *     longer interested in the outcome.
  * @param {string=} opt_logMsgUrl A URL to post log messages to.
  * @constructor
  */
-function SingleGnubbySigner(gnubbyId, forEnroll, completeCb, timer,
-    opt_logMsgUrl) {
+function SingleGnubbySigner(
+    gnubbyId, forEnroll, completeCb, timer, opt_logMsgUrl) {
   /** @private {GnubbyDeviceId} */
   this.gnubbyId_ = gnubbyId;
   /** @private {SingleGnubbySigner.State} */
   this.state_ = SingleGnubbySigner.State.INIT;
   /** @private {boolean} */
   this.forEnroll_ = forEnroll;
   /** @private {function(SingleSignerResult)} */
   this.completeCb_ = completeCb;
   /** @private {Countdown} */
   this.timer_ = timer;
@@ skipping 43 matching lines @@
 
 /**
  * Closes this signer's gnubby, if it's held.
  */
 SingleGnubbySigner.prototype.close = function() {
   if (this.state_ == SingleGnubbySigner.State.OPENING) {
     if (this.openCanceller_)
       this.openCanceller_();
   }
 
-  if (!this.gnubby_) return;
+  if (!this.gnubby_)
+    return;
   this.state_ = SingleGnubbySigner.State.CLOSING;
   this.gnubby_.closeWhenIdle(this.closed_.bind(this));
 };
 
 /**
  * Called when this signer's gnubby is closed.
  * @private
  */
 SingleGnubbySigner.prototype.closed_ = function() {
   this.gnubby_ = null;
@@ skipping 58 matching lines @@
  */
 SingleGnubbySigner.prototype.open_ = function() {
   var appIdHash;
   if (this.challenges_.length) {
     // Assume the first challenge's appId is representative of all of them.
     appIdHash = B64_encode(this.challenges_[0].appIdHash);
   }
   if (this.state_ == SingleGnubbySigner.State.INIT) {
     this.state_ = SingleGnubbySigner.State.OPENING;
     this.openCanceller_ = DEVICE_FACTORY_REGISTRY.getGnubbyFactory().openGnubby(
-        this.gnubbyId_,
-        this.forEnroll_,
-        this.openCallback_.bind(this),
-        appIdHash,
-        this.logMsgUrl_,
+        this.gnubbyId_, this.forEnroll_, this.openCallback_.bind(this),
+        appIdHash, this.logMsgUrl_,
         'singlesigner.js:SingleGnubbySigner.prototype.open_');
   }
 };
 
 /**
  * How long to delay retrying a failed open.
  */
 SingleGnubbySigner.OPEN_DELAY_MILLIS = 200;
 
 /**
@@ skipping 23 matching lines @@
       }
       break;
     case DeviceStatusCodes.BUSY_STATUS:
       this.gnubby_ = gnubby;
       this.state_ = SingleGnubbySigner.State.BUSY;
       // If there's still time, retry the open.
       if (!this.timer_ || !this.timer_.expired()) {
         var self = this;
         window.setTimeout(function() {
           if (self.gnubby_) {
-            this.openCanceller_ = DEVICE_FACTORY_REGISTRY
-              .getGnubbyFactory().openGnubby(
-                self.gnubbyId_,
-                self.forEnroll_,
-                self.openCallback_.bind(self),
-                self.logMsgUrl_,
-                'singlesigner.js:SingleGnubbySigner.prototype.openCallback_');
+            this.openCanceller_ =
+                DEVICE_FACTORY_REGISTRY.getGnubbyFactory().openGnubby(
+                    self.gnubbyId_, self.forEnroll_,
+                    self.openCallback_.bind(self), self.logMsgUrl_,
+                    'singlesigner.js:SingleGnubbySigner.prototype.openCallback_');
           }
         }, 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.*?
@@ skipping 67 matching lines @@
   var appIdHash = challenge.appIdHash;
   var keyHandle = challenge.keyHandle;
   if (this.cachedError_.hasOwnProperty(keyHandle)) {
     // Cache hit: return wrong data again.
     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);
+    this.gnubby_.sign(
+        challengeHash, appIdHash, keyHandle,
+        this.signCallback_.bind(this, challengeIndex), nowink);
   }
 };
 
 /**
  * @param {number} code The result of a sign operation.
  * @return {boolean} Whether the error indicates the key handle is invalid
  *     for this gnubby.
  */
 SingleGnubbySigner.signErrorIndicatesInvalidKeyHandle = function(code) {
-  return (code == DeviceStatusCodes.WRONG_DATA_STATUS ||
+  return (
+      code == DeviceStatusCodes.WRONG_DATA_STATUS ||
       code == DeviceStatusCodes.WRONG_LENGTH_STATUS ||
       code == DeviceStatusCodes.INVALID_DATA_STATUS);
 };
 
 /**
  * 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)));
+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 certain idempotent errors, re-asking the gnubby to sign it
   // won't produce different results.
   if (SingleGnubbySigner.signErrorIndicatesInvalidKeyHandle(code)) {
     if (challengeIndex < this.challenges_.length) {
@@ skipping 15 matching lines @@
       break;
 
     case DeviceStatusCodes.BUSY_STATUS:
       this.doSign_(this.challengeIndex_);
       break;
 
     case DeviceStatusCodes.OK_STATUS:
       // Lower bound on the minimum length, signature length can vary.
       var MIN_SIGNATURE_LENGTH = 7;
       if (!opt_info || opt_info.byteLength < MIN_SIGNATURE_LENGTH) {
-        console.error(UTIL_fmt('Got short response to sign request (' +
+        console.error(UTIL_fmt(
+            'Got short response to sign request (' +
             (opt_info ? opt_info.byteLength : 0) + ' bytes), WTF?'));
       }
       if (this.forEnroll_) {
         this.goToError_(code);
       } else {
         this.goToSuccess_(code, this.challenges_[challengeIndex], opt_info);
       }
       break;
 
     case DeviceStatusCodes.WAIT_TOUCH_STATUS:
@@ skipping 42 matching lines @@
 /**
  * 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, opt_warn) {
   this.state_ = SingleGnubbySigner.State.COMPLETE;
   var logFn = opt_warn ? console.warn.bind(console) : console.log.bind(console);
   logFn(UTIL_fmt('failed (' + code.toString(16) + ')'));
-  var result = { code: code };
+  var result = {code: code};
   if (!this.forEnroll_ &&
       SingleGnubbySigner.signErrorIndicatesInvalidKeyHandle(code)) {
     // When a device yields an idempotent bad key handle error to all sign
     // challenges, and this is a sign request, we don't want to yield to the
     // web page that it's not enrolled just yet: we want the user to tap the
     // device first. We'll report the gnubby to the caller and let it close it
     // instead of closing it here.
     result.gnubby = this.gnubby_;
   } else {
     // Since this gnubby can no longer produce a useful result, go ahead and
     // close it.
     this.close();
   }
   this.completeCb_(result);
 };
 
 /**
  * Switches to the success state, and notifies caller.
  * @param {number} code Status code
  * @param {SignHelperChallenge=} opt_challenge The challenge signed
  * @param {ArrayBuffer=} opt_info Optional result data
  * @private
  */
-SingleGnubbySigner.prototype.goToSuccess_ =
-    function(code, opt_challenge, opt_info) {
+SingleGnubbySigner.prototype.goToSuccess_ = function(
+    code, opt_challenge, opt_info) {
   this.state_ = SingleGnubbySigner.State.COMPLETE;
   console.log(UTIL_fmt('success (' + code.toString(16) + ')'));
-  var result = { code: code, gnubby: this.gnubby_ };
+  var result = {code: code, gnubby: this.gnubby_};
   if (opt_challenge || opt_info) {
     if (opt_challenge) {
       result['challenge'] = opt_challenge;
     }
     if (opt_info) {
       result['info'] = opt_info;
     }
   }
   this.completeCb_(result);
   // this.gnubby_ is now owned by completeCb_.
   this.gnubby_ = null;
 };