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

chrome/browser/resources/cryptotoken/gnubbies.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 class for managing all enumerated gnubby devices.
  */
 'use strict';
 
 /**
@@ skipping 12 matching lines @@
  *   device: number
  * }}
  */
 var GnubbyDeviceId;
 
 /**
  * Ways in which gnubby devices are enumerated.
  * @const
  * @enum {number}
  */
-var GnubbyEnumerationTypes = {
-  ANY: 0,
-  VID_PID: 1,
-  FIDO_U2F: 2
-};
+var GnubbyEnumerationTypes = {ANY: 0, VID_PID: 1, FIDO_U2F: 2};
 
 /**
  * @typedef {{
  *   isSharedAccess: boolean,
  *   enumerate: function(function(Array), GnubbyEnumerationTypes=),
  *   deviceToDeviceId: function(*): GnubbyDeviceId,
  *   open: function(Gnubbies, number, *, function(number, GnubbyDevice=)),
  *   cancelOpen: (undefined|function(Gnubbies, number, *))
  * }}
  */
@@ skipping 32 matching lines @@
     this.namespaces_.push(namespace);
   }
   this.impl_[namespace] = impl;
 };
 
 /**
  * @param {GnubbyDeviceId} id The device id.
  * @return {boolean} Whether the device is a shared access device.
  */
 Gnubbies.prototype.isSharedAccess = function(id) {
-  if (!this.impl_.hasOwnProperty(id.namespace)) return false;
+  if (!this.impl_.hasOwnProperty(id.namespace))
+    return false;
   return this.impl_[id.namespace].isSharedAccess;
 };
 
 /**
  * @param {GnubbyDeviceId} which The device to remove.
  */
 Gnubbies.prototype.removeOpenDevice = function(which) {
   if (this.openDevs_[which.namespace] &&
       this.openDevs_[which.namespace].hasOwnProperty(which.device)) {
     delete this.openDevs_[which.namespace][which.device];
@@ skipping 139 matching lines @@
 Gnubbies.SYS_TIMER_ = new WindowTimer();
 
 /**
  * @param {number|undefined} opt_timeoutMillis Timeout in milliseconds
  */
 Gnubbies.prototype.resetInactivityTimer = function(opt_timeoutMillis) {
   var millis = opt_timeoutMillis ?
       opt_timeoutMillis + Gnubbies.INACTIVITY_TIMEOUT_MARGIN_MILLIS :
       Gnubbies.INACTIVITY_TIMEOUT_MARGIN_MILLIS;
   if (!this.inactivityTimer) {
-    this.inactivityTimer =
-        new CountdownTimer(
-            Gnubbies.SYS_TIMER_, millis, this.inactivityTimeout_.bind(this));
+    this.inactivityTimer = new CountdownTimer(
+        Gnubbies.SYS_TIMER_, millis, this.inactivityTimeout_.bind(this));
   } else if (millis > this.inactivityTimer.millisecondsUntilExpired()) {
     this.inactivityTimer.clearTimeout();
     this.inactivityTimer.setTimeout(millis, this.inactivityTimeout_.bind(this));
   }
 };
 
 /**
  * Called when the inactivity timeout expires.
  * @private
  */
 Gnubbies.prototype.inactivityTimeout_ = function() {
   this.inactivityTimer = undefined;
   for (var namespace in this.openDevs_) {
     for (var dev in this.openDevs_[namespace]) {
       var deviceId = Number(dev);
-      console.warn(namespace + ' device ' + deviceId +
+      console.warn(
+          namespace + ' device ' + deviceId +
           ' still open after inactivity, closing');
       this.openDevs_[namespace][deviceId].destroy();
     }
   }
 };
 
 /**
  * Opens and adds a new client of the specified device.
  * @param {GnubbyDeviceId} which Which device to open.
  * @param {*} who Client of the device.
  * @param {function(number, GnubbyDevice=)} cb Called back with the result of
  *     opening the device.
  */
 Gnubbies.prototype.addClient = function(which, who, cb) {
   this.resetInactivityTimer();
 
   var self = this;
 
   function opened(gnubby, who, cb) {
     if (gnubby.closing) {
       // Device is closing or already closed.
       self.removeClient(gnubby, who);
-      if (cb) { cb(-GnubbyDevice.NODEVICE); }
+      if (cb) {
+        cb(-GnubbyDevice.NODEVICE);
+      }
     } else {
       gnubby.registerClient(who);
-      if (cb) { cb(-GnubbyDevice.OK, gnubby); }
+      if (cb) {
+        cb(-GnubbyDevice.OK, gnubby);
+      }
     }
   }
 
   function notifyOpenResult(rc) {
     if (self.pendingOpens_[which.namespace]) {
       while (self.pendingOpens_[which.namespace][which.device].length != 0) {
         var client = self.pendingOpens_[which.namespace][which.device].shift();
         client.cb(rc);
       }
       delete self.pendingOpens_[which.namespace][which.device];
     }
   }
 
   var dev = null;
   var deviceToDeviceId = this.getDeviceToDeviceId_(which.namespace);
   if (this.devs_[which.namespace]) {
     for (var i = 0; i < this.devs_[which.namespace].length; i++) {
       var device = this.devs_[which.namespace][i];
       if (deviceToDeviceId(device).device == which.device) {
         dev = device;
         break;
       }
     }
   }
   if (!dev) {
     // Index out of bounds. Device does not exist in current enumeration.
     this.removeClient(null, who);
-    if (cb) { cb(-GnubbyDevice.NODEVICE); }
+    if (cb) {
+      cb(-GnubbyDevice.NODEVICE);
+    }
     return;
   }
 
   function openCb(rc, opt_gnubby) {
     if (rc) {
       notifyOpenResult(rc);
       return;
     }
     if (!opt_gnubby) {
       notifyOpenResult(-GnubbyDevice.NODEVICE);
@@ skipping 80 matching lines @@
         if (whichDev && dev != whichDev) {
           console.warn('Gnubby attached to more than one device!?');
         }
         if (!dev.deregisterClient(who)) {
           dev.destroy();
         }
       }
     }
   }
 };