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

chrome/browser/resources/cryptotoken/usbgnubbydevice.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 Implements a low-level gnubby driver based on chrome.usb.
  */
 'use strict';
 
 /**
  * Low level gnubby 'driver'. One per physical USB device.
  * @param {Gnubbies} gnubbies The gnubbies instances this device is enumerated
  *     in.
  * @param {!chrome.usb.ConnectionHandle} dev The device.
  * @param {number} id The device's id.
  * @param {number} inEndpoint The device's in endpoint.
  * @param {number} outEndpoint The device's out endpoint.
  * @constructor
  * @implements {GnubbyDevice}
  */
 function UsbGnubbyDevice(gnubbies, dev, id, inEndpoint, outEndpoint) {
   /** @private {Gnubbies} */
   this.gnubbies_ = gnubbies;
   this.dev = dev;
   this.id = id;
   this.inEndpoint = inEndpoint;
   this.outEndpoint = outEndpoint;
   this.txqueue = [];
   this.clients = [];
-  this.lockCID = 0;     // channel ID of client holding a lock, if != 0.
-  this.lockMillis = 0;  // current lock period.
-  this.lockTID = null;  // timer id of lock timeout.
-  this.closing = false;  // device to be closed by receive loop.
+  this.lockCID = 0;       // channel ID of client holding a lock, if != 0.
+  this.lockMillis = 0;    // current lock period.
+  this.lockTID = null;    // timer id of lock timeout.
+  this.closing = false;   // device to be closed by receive loop.
   this.updating = false;  // device firmware is in final stage of updating.
   this.inTransferPending = false;
   this.outTransferPending = false;
 }
 
 /**
  * Namespace for the UsbGnubbyDevice implementation.
  * @const
  */
 UsbGnubbyDevice.NAMESPACE = 'usb';
 
 /** Destroys this low-level device instance. */
 UsbGnubbyDevice.prototype.destroy = function() {
   function closeLowLevelDevice(dev) {
     chrome.usb.releaseInterface(dev, 0, function() {
       if (chrome.runtime.lastError) {
-        console.warn(UTIL_fmt('Device ' + dev.handle +
-            ' couldn\'t be released:'));
+        console.warn(
+            UTIL_fmt('Device ' + dev.handle + ' couldn\'t be released:'));
         console.warn(UTIL_fmt(chrome.runtime.lastError.message));
         return;
       }
       console.log(UTIL_fmt('Device ' + dev.handle + ' released'));
       chrome.usb.closeDevice(dev, function() {
         if (chrome.runtime.lastError) {
-          console.warn(UTIL_fmt('Device ' + dev.handle +
-              ' couldn\'t be closed:'));
+          console.warn(
+              UTIL_fmt('Device ' + dev.handle + ' couldn\'t be closed:'));
           console.warn(UTIL_fmt(chrome.runtime.lastError.message));
           return;
         }
         console.log(UTIL_fmt('Device ' + dev.handle + ' closed'));
       });
     });
   }
 
-  if (!this.dev) return;  // Already dead.
+  if (!this.dev)
+    return;  // Already dead.
 
   this.gnubbies_.removeOpenDevice(
       {namespace: UsbGnubbyDevice.NAMESPACE, device: this.id});
   this.closing = true;
 
   console.log(UTIL_fmt('UsbGnubbyDevice.destroy()'));
 
   // Synthesize a close error frame to alert all clients,
   // some of which might be in read state.
   //
   // Use magic CID 0 to address all.
   this.publishFrame_(new Uint8Array([
-        0, 0, 0, 0,  // broadcast CID
-        GnubbyDevice.CMD_ERROR,
-        0, 1,  // length
-        GnubbyDevice.GONE]).buffer);
+                       0, 0, 0, 0,                    // broadcast CID
+                       GnubbyDevice.CMD_ERROR, 0, 1,  // length
+                       GnubbyDevice.GONE
+                     ]).buffer);
 
   // Set all clients to closed status and remove them.
   while (this.clients.length != 0) {
     var client = this.clients.shift();
-    if (client) client.closed = true;
+    if (client)
+      client.closed = true;
   }
 
   if (this.lockTID) {
     window.clearTimeout(this.lockTID);
     this.lockTID = null;
   }
 
   var dev = this.dev;
   this.dev = null;
   var reallyCloseDevice = closeLowLevelDevice.bind(null, dev);
@@ skipping 29 matching lines @@
 
   var remaining = [];
   var changes = false;
   for (var i = 0; i < old.length; ++i) {
     var client = old[i];
     if (client.receivedFrame(f)) {
       // Client still alive; keep on list.
       remaining.push(client);
     } else {
       changes = true;
-      console.log(UTIL_fmt(
-          '[' + Gnubby.hexCid(client.cid) + '] left?'));
+      console.log(UTIL_fmt('[' + Gnubby.hexCid(client.cid) + '] left?'));
     }
   }
-  if (changes) this.clients = remaining;
+  if (changes)
+    this.clients = remaining;
 };
 
 /**
  * @return {boolean} whether this device is open and ready to use.
  * @private
  */
 UsbGnubbyDevice.prototype.readyToUse_ = function() {
-  if (this.closing) return false;
-  if (!this.dev) return false;
+  if (this.closing)
+    return false;
+  if (!this.dev)
+    return false;
 
   return true;
 };
 
 /**
  * Reads one reply from the low-level device.
  * @private
  */
 UsbGnubbyDevice.prototype.readOneReply_ = function() {
-  if (!this.readyToUse_()) return;  // No point in continuing.
-  if (this.updating) return;  // Do not bother waiting for final update reply.
+  if (!this.readyToUse_())
+    return;  // No point in continuing.
+  if (this.updating)
+    return;  // Do not bother waiting for final update reply.
 
   var self = this;
 
   function inTransferComplete(x) {
     self.inTransferPending = false;
 
-    if (!self.readyToUse_()) return;  // No point in continuing.
+    if (!self.readyToUse_())
+      return;  // No point in continuing.
 
     if (chrome.runtime.lastError) {
       console.warn(UTIL_fmt('in bulkTransfer got lastError: '));
       console.warn(UTIL_fmt(chrome.runtime.lastError.message));
-      window.setTimeout(function() { self.destroy(); }, 0);
+      window.setTimeout(function() {
+        self.destroy();
+      }, 0);
       return;
     }
 
     if (x.data) {
       var u8 = new Uint8Array(x.data);
       console.log(UTIL_fmt('<' + UTIL_BytesToHex(u8)));
 
       self.publishFrame_(x.data);
 
       // Write another pending request, if any.
-      window.setTimeout(
-          function() {
-            self.txqueue.shift();  // Drop sent frame from queue.
-            self.writeOneRequest_();
-          },
-          0);
+      window.setTimeout(function() {
+        self.txqueue.shift();  // Drop sent frame from queue.
+        self.writeOneRequest_();
+      }, 0);
     } else {
       console.log(UTIL_fmt('no x.data!'));
       console.log(x);
-      window.setTimeout(function() { self.destroy(); }, 0);
+      window.setTimeout(function() {
+        self.destroy();
+      }, 0);
     }
   }
 
   if (this.inTransferPending == false) {
     this.inTransferPending = true;
     chrome.usb.bulkTransfer(
-      /** @type {!chrome.usb.ConnectionHandle} */(this.dev),
-      { direction: 'in', endpoint: this.inEndpoint, length: 2048 },
-      inTransferComplete);
+        /** @type {!chrome.usb.ConnectionHandle} */ (this.dev),
+        {direction: 'in', endpoint: this.inEndpoint, length: 2048},
+        inTransferComplete);
   } else {
     throw 'inTransferPending!';
   }
 };
 
 /**
  * Register a client for this gnubby.
  * @param {*} who The client.
  */
 UsbGnubbyDevice.prototype.registerClient = function(who) {
   for (var i = 0; i < this.clients.length; ++i) {
-    if (this.clients[i] === who) return;  // Already registered.
+    if (this.clients[i] === who)
+      return;  // Already registered.
   }
   this.clients.push(who);
 };
 
 /**
  * De-register a client.
  * @param {*} who The client.
  * @return {number} The number of remaining listeners for this device, or -1
  * Returns number of remaining listeners for this device.
  *     if this had no clients to start with.
  */
 UsbGnubbyDevice.prototype.deregisterClient = function(who) {
   var current = this.clients;
-  if (current.length == 0) return -1;
+  if (current.length == 0)
+    return -1;
   this.clients = [];
   for (var i = 0; i < current.length; ++i) {
     var client = current[i];
-    if (client !== who) this.clients.push(client);
+    if (client !== who)
+      this.clients.push(client);
   }
   return this.clients.length;
 };
 
 /**
  * @param {*} who The client.
  * @return {boolean} Whether this device has who as a client.
  */
 UsbGnubbyDevice.prototype.hasClient = function(who) {
-  if (this.clients.length == 0) return false;
+  if (this.clients.length == 0)
+    return false;
   for (var i = 0; i < this.clients.length; ++i) {
     if (who === this.clients[i])
       return true;
   }
   return false;
 };
 
 /**
  * Stuff queued frames from txqueue[] to device, one by one.
  * @private
  */
 UsbGnubbyDevice.prototype.writeOneRequest_ = function() {
-  if (!this.readyToUse_()) return;  // No point in continuing.
+  if (!this.readyToUse_())
+    return;  // No point in continuing.
 
-  if (this.txqueue.length == 0) return;  // Nothing to send.
+  if (this.txqueue.length == 0)
+    return;  // Nothing to send.
 
   var frame = this.txqueue[0];
 
   var self = this;
   function OutTransferComplete(x) {
     self.outTransferPending = false;
 
-    if (!self.readyToUse_()) return;  // No point in continuing.
+    if (!self.readyToUse_())
+      return;  // No point in continuing.
 
     if (chrome.runtime.lastError) {
       console.warn(UTIL_fmt('out bulkTransfer lastError: '));
       console.warn(UTIL_fmt(chrome.runtime.lastError.message));
-      window.setTimeout(function() { self.destroy(); }, 0);
+      window.setTimeout(function() {
+        self.destroy();
+      }, 0);
       return;
     }
 
-    window.setTimeout(function() { self.readOneReply_(); }, 0);
+    window.setTimeout(function() {
+      self.readOneReply_();
+    }, 0);
   }
 
   var u8 = new Uint8Array(frame);
 
   // See whether this requires scrubbing before logging.
   var alternateLog = Gnubby.hasOwnProperty('redactRequestLog') &&
-                     Gnubby['redactRequestLog'](u8);
+      Gnubby['redactRequestLog'](u8);
   if (alternateLog) {
     console.log(UTIL_fmt('>' + alternateLog));
   } else {
     console.log(UTIL_fmt('>' + UTIL_BytesToHex(u8)));
   }
 
   if (this.outTransferPending == false) {
     this.outTransferPending = true;
     chrome.usb.bulkTransfer(
-        /** @type {!chrome.usb.ConnectionHandle} */(this.dev),
-        { direction: 'out', endpoint: this.outEndpoint, data: frame },
+        /** @type {!chrome.usb.ConnectionHandle} */ (this.dev),
+        {direction: 'out', endpoint: this.outEndpoint, data: frame},
         OutTransferComplete);
   } else {
     throw 'outTransferPending!';
   }
 };
 
 /**
  * Check whether channel is locked for this request or not.
  * @param {number} cid Channel id
  * @param {number} cmd Command to be sent
  * @return {boolean} true if not locked for this request.
  * @private
  */
 UsbGnubbyDevice.prototype.checkLock_ = function(cid, cmd) {
   if (this.lockCID) {
     // We have an active lock.
     if (this.lockCID != cid) {
       // Some other channel has active lock.
 
-      if (cmd != GnubbyDevice.CMD_SYNC &&
-          cmd != GnubbyDevice.CMD_INIT) {
+      if (cmd != GnubbyDevice.CMD_SYNC && cmd != GnubbyDevice.CMD_INIT) {
         // Anything but SYNC|INIT gets an immediate busy.
-        var busy = new Uint8Array(
-            [(cid >> 24) & 255,
-             (cid >> 16) & 255,
-             (cid >> 8) & 255,
-             cid & 255,
-             GnubbyDevice.CMD_ERROR,
-             0, 1,  // length
-             GnubbyDevice.BUSY]);
+        var busy = new Uint8Array([
+          (cid >> 24) & 255, (cid >> 16) & 255, (cid >> 8) & 255, cid & 255,
+          GnubbyDevice.CMD_ERROR, 0, 1,  // length
+          GnubbyDevice.BUSY
+        ]);
         // Log the synthetic busy too.
         console.log(UTIL_fmt('<' + UTIL_BytesToHex(busy)));
         this.publishFrame_(busy.buffer);
         return false;
       }
 
       // SYNC|INIT get to go to the device to flush OS tx/rx queues.
       // The usb firmware is to always respond to SYNC|INIT,
       // regardless of lock status.
     }
@@ skipping 24 matching lines @@
         this.lockMillis = nseconds * 1000 + 100;
       } else {
         // Releasing lock voluntarily.
         this.lockCID = 0;
       }
     }
 
     // (re)set the lock timeout if we still hold it.
     if (this.lockCID) {
       var self = this;
-      this.lockTID = window.setTimeout(
-          function() {
-            console.warn(UTIL_fmt(
-                'lock for CID ' + Gnubby.hexCid(cid) + ' expired!'));
-            self.lockTID = null;
-            self.lockCID = 0;
-          },
-          this.lockMillis);
+      this.lockTID = window.setTimeout(function() {
+        console.warn(
+            UTIL_fmt('lock for CID ' + Gnubby.hexCid(cid) + ' expired!'));
+        self.lockTID = null;
+        self.lockCID = 0;
+      }, this.lockMillis);
     }
   }
 };
 
 /**
  * Queue command to be sent.
  * If queue was empty, initiate the write.
  * @param {number} cid The client's channel ID.
  * @param {number} cmd The command to send.
  * @param {ArrayBuffer|Uint8Array} data Command argument data
  */
 UsbGnubbyDevice.prototype.queueCommand = function(cid, cmd, data) {
-  if (!this.dev) return;
-  if (!this.checkLock_(cid, cmd)) return;
+  if (!this.dev)
+    return;
+  if (!this.checkLock_(cid, cmd))
+    return;
 
   var u8 = new Uint8Array(data);
   var frame = new Uint8Array(u8.length + 7);
 
   frame[0] = cid >>> 24;
   frame[1] = cid >>> 16;
   frame[2] = cid >>> 8;
   frame[3] = cid;
   frame[4] = cmd;
   frame[5] = (u8.length >> 8);
   frame[6] = (u8.length & 255);
 
   frame.set(u8, 7);
 
   var lockArg = (u8.length > 0) ? u8[0] : 0;
   this.updateLock_(cid, cmd, lockArg);
 
   var wasEmpty = (this.txqueue.length == 0);
   this.txqueue.push(frame.buffer);
-  if (wasEmpty) this.writeOneRequest_();
+  if (wasEmpty)
+    this.writeOneRequest_();
 };
 
 /**
  * @const
  */
 UsbGnubbyDevice.WINUSB_VID_PIDS = [
-  {'vendorId': 4176, 'productId': 529}   // Yubico WinUSB
+  {'vendorId': 4176, 'productId': 529}  // Yubico WinUSB
 ];
 
 /**
  * @param {function(Array)} cb Enumerate callback
  * @param {GnubbyEnumerationTypes=} opt_type Which type of enumeration to do.
  */
 UsbGnubbyDevice.enumerate = function(cb, opt_type) {
   // UsbGnubbyDevices are all non-FIDO devices, so return an empty list if
   // FIDO is what's wanted.
   if (opt_type == GnubbyEnumerationTypes.FIDO_U2F) {
@@ skipping 103 matching lines @@
           console.warn(UTIL_fmt('failed to claim interface. busy?'));
           // Claim failed? Let the callers know and bail out.
           chrome.usb.closeDevice(nonNullHandle);
           cb(-GnubbyDevice.BUSY);
           return;
         }
         // Restore the enumeratedBy value, if we had it.
         if (enumeratedBy) {
           dev.enumeratedBy = enumeratedBy;
         }
-        var gnubby = new UsbGnubbyDevice(gnubbies, nonNullHandle, which,
-            inEndpoint, outEndpoint);
+        var gnubby = new UsbGnubbyDevice(
+            gnubbies, nonNullHandle, which, inEndpoint, outEndpoint);
         cb(-GnubbyDevice.OK, gnubby);
       });
     });
   }
 
   var enumeratedBy = dev.enumeratedBy;
 
   if (UsbGnubbyDevice.runningOnCrOS === undefined) {
     UsbGnubbyDevice.runningOnCrOS =
         (window.navigator.appVersion.indexOf('; CrOS ') != -1);
@@ skipping 36 matching lines @@
  */
 UsbGnubbyDevice.register = function(gnubbies) {
   var USB_GNUBBY_IMPL = {
     isSharedAccess: false,
     enumerate: UsbGnubbyDevice.enumerate,
     deviceToDeviceId: UsbGnubbyDevice.deviceToDeviceId,
     open: UsbGnubbyDevice.open
   };
   gnubbies.registerNamespace(UsbGnubbyDevice.NAMESPACE, USB_GNUBBY_IMPL);
 };