WIP: run clang-format-js on lots of things

chrome/browser/resources/cryptotoken/multiplesigner.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 multiple gnubby signer wraps the process of opening a number
  * of gnubbies, signing each challenge in an array of challenges until a
  * success condition is satisfied, and yielding each succeeding gnubby.
  *
  */
@@ skipping 23 matching lines @@
  *     whether this signer expects to produce more results. The boolean is a
  *     hint rather than a promise: it's possible for this signer to produce
  *     further results after saying it doesn't expect more, or to fail to
  *     produce further results after saying it does.
  * @param {number} timeoutMillis A timeout value, 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 MultipleGnubbySigner(forEnroll, allCompleteCb, gnubbyCompleteCb,
-    timeoutMillis, opt_logMsgUrl) {
+function MultipleGnubbySigner(
+    forEnroll, allCompleteCb, gnubbyCompleteCb, timeoutMillis, opt_logMsgUrl) {
   /** @private {boolean} */
   this.forEnroll_ = forEnroll;
   /** @private {function(boolean)} */
   this.allCompleteCb_ = allCompleteCb;
   /** @private {function(MultipleSignerResult, boolean)} */
   this.gnubbyCompleteCb_ = gnubbyCompleteCb;
   /** @private {string|undefined} */
   this.logMsgUrl_ = opt_logMsgUrl;
 
   /** @private {Array<SignHelperChallenge>} */
   this.challenges_ = [];
   /** @private {boolean} */
   this.challengesSet_ = false;
   /** @private {boolean} */
   this.complete_ = false;
   /** @private {number} */
   this.numComplete_ = 0;
   /** @private {!Object<string, GnubbyTracker>} */
   this.gnubbies_ = {};
   /** @private {Countdown} */
-  this.timer_ = DEVICE_FACTORY_REGISTRY.getCountdownFactory()
-      .createTimer(timeoutMillis);
+  this.timer_ =
+      DEVICE_FACTORY_REGISTRY.getCountdownFactory().createTimer(timeoutMillis);
   /** @private {Countdown} */
-  this.reenumerateTimer_ = DEVICE_FACTORY_REGISTRY.getCountdownFactory()
-      .createTimer(timeoutMillis);
+  this.reenumerateTimer_ =
+      DEVICE_FACTORY_REGISTRY.getCountdownFactory().createTimer(timeoutMillis);
 }
 
 /**
  * @typedef {{
  *   index: string,
  *   signer: SingleGnubbySigner,
  *   stillGoing: boolean,
  *   errorStatus: number
  * }}
  */
@@ skipping 95 matching lines @@
  * @const
  */
 MultipleGnubbySigner.PASSIVE_REENUMERATE_INTERVAL_MILLIS = 3000;
 
 /**
  * Reenumerates gnubbies if there's still time.
  * @param {boolean} activeScan Whether to poll more aggressively, e.g. if
  *     there are no devices present.
  * @private
  */
-MultipleGnubbySigner.prototype.maybeReEnumerateGnubbies_ =
-    function(activeScan) {
+MultipleGnubbySigner.prototype.maybeReEnumerateGnubbies_ = function(
+    activeScan) {
   if (this.reenumerateTimer_.expired()) {
     // If the timer is expired, call timeout_ if there aren't any still-running
     // gnubbies. (If there are some still running, the last will call timeout_
     // itself.)
     if (!this.anyPending_()) {
       this.timeout_(false);
     }
     return;
   }
   // Reenumerate more aggressively if there are no gnubbies present than if
@@ skipping 26 matching lines @@
  * @param {GnubbyDeviceId} gnubbyId The id of the gnubby to add.
  * @return {boolean} Whether the gnubby was added successfully.
  * @private
  */
 MultipleGnubbySigner.prototype.addGnubby_ = function(gnubbyId) {
   var index = JSON.stringify(gnubbyId);
   if (this.gnubbies_.hasOwnProperty(index)) {
     // Can't add the same gnubby twice.
     return false;
   }
-  var tracker = {
-      index: index,
-      errorStatus: 0,
-      stillGoing: false,
-      signer: null
-  };
+  var tracker = {index: index, errorStatus: 0, stillGoing: false, signer: null};
   tracker.signer = new SingleGnubbySigner(
-      gnubbyId,
-      this.forEnroll_,
-      this.signCompletedCallback_.bind(this, tracker),
-      this.timer_.clone(),
+      gnubbyId, this.forEnroll_,
+      this.signCompletedCallback_.bind(this, tracker), this.timer_.clone(),
       this.logMsgUrl_);
   this.gnubbies_[index] = tracker;
-  this.gnubbies_[index].stillGoing =
-      tracker.signer.doSign(this.challenges_);
+  this.gnubbies_[index].stillGoing = tracker.signer.doSign(this.challenges_);
   if (!this.gnubbies_[index].errorStatus) {
     this.gnubbies_[index].errorStatus = 0;
   }
   return true;
 };
 
 /**
  * Called by a SingleGnubbySigner upon completion.
  * @param {GnubbyTracker} tracker The tracker object of the gnubby whose result
  *     this is.
  * @param {SingleSignerResult} result The result of the sign operation.
  * @private
  */
-MultipleGnubbySigner.prototype.signCompletedCallback_ =
-    function(tracker, result) {
-  console.log(
-      UTIL_fmt((result.code ? 'failure.' : 'success!') +
-          ' gnubby ' + tracker.index +
-          ' got code ' + result.code.toString(16)));
+MultipleGnubbySigner.prototype.signCompletedCallback_ = function(
+    tracker, result) {
+  console.log(UTIL_fmt(
+      (result.code ? 'failure.' : 'success!') + ' gnubby ' + tracker.index +
+      ' got code ' + result.code.toString(16)));
   if (!tracker.stillGoing) {
     console.log(UTIL_fmt('gnubby ' + tracker.index + ' no longer running!'));
     // Shouldn't ever happen? Disregard.
     return;
   }
   tracker.stillGoing = false;
   tracker.errorStatus = result.code;
   var moreExpected = this.tallyCompletedGnubby_();
   switch (result.code) {
     case DeviceStatusCodes.GONE_STATUS:
@@ skipping 32 matching lines @@
 MultipleGnubbySigner.prototype.anyPending_ = function() {
   return this.numComplete_ < Object.keys(this.gnubbies_).length;
 };
 
 /**
  * Called upon timeout.
  * @param {boolean} anyPending Whether any gnubbies are awaiting results.
  * @private
  */
 MultipleGnubbySigner.prototype.timeout_ = function(anyPending) {
-  if (this.complete_) return;
+  if (this.complete_)
+    return;
   this.complete_ = true;
   // Defer notifying the caller that all are complete, in case the caller is
   // doing work in response to a gnubbyFound callback and has an inconsistent
   // view of the state of this signer.
   var self = this;
   window.setTimeout(function() {
     self.allCompleteCb_(anyPending);
   }, 0);
 };
 
 /**
  * @param {GnubbyTracker} tracker The tracker object of the gnubby whose result
  *     this is.
  * @param {SingleSignerResult} result Result object.
  * @param {boolean} moreExpected Whether more gnubbies may still produce an
  *     outcome.
  * @private
  */
-MultipleGnubbySigner.prototype.notifyGnubbyComplete_ =
-    function(tracker, result, moreExpected) {
-  console.log(UTIL_fmt('gnubby ' + tracker.index + ' complete (' +
-      result.code.toString(16) + ')'));
+MultipleGnubbySigner.prototype.notifyGnubbyComplete_ = function(
+    tracker, result, moreExpected) {
+  console.log(UTIL_fmt(
+      'gnubby ' + tracker.index + ' complete (' + result.code.toString(16) +
+      ')'));
   var signResult = {
     'code': result.code,
     'gnubby': result.gnubby,
     'gnubbyId': tracker.signer.getDeviceId()
   };
   if (result['challenge'])
     signResult['challenge'] = result['challenge'];
   if (result['info'])
     signResult['info'] = result['info'];
   this.gnubbyCompleteCb_(signResult, moreExpected);
 };