Update cryptotoken to 0.8.63

chrome/browser/resources/cryptotoken/hidgnubbydevice.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.hid.
  */
 'use strict';
 
 /**
@@ skipping 53 matching lines @@
 
   if (this.lockTID) {
     window.clearTimeout(this.lockTID);
     this.lockTID = null;
   }
 
   var dev = this.dev;
   this.dev = null;
 
   chrome.hid.disconnect(dev.connectionId, function() {
+    if (chrome.runtime.lastError) {
+      console.warn(UTIL_fmt('Device ' + dev.connectionId +
+          ' couldn\'t be disconnected:'));
+      console.warn(chrome.runtime.lastError);
+      return;
+    }
     console.log(UTIL_fmt('Device ' + dev.connectionId + ' closed'));
   });
 };
 
 /**
  * Push frame to all clients.
  * @param {ArrayBuffer} f Data to push
  * @private
  */
 HidGnubbyDevice.prototype.publishFrame_ = function(f) {
@@ skipping 122 matching lines @@
  * @param {number} cmd Request command
  * @return {boolean} true if not locked for this request.
  * @private
  */
 HidGnubbyDevice.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) {
-        // Anything but SYNC gets an immediate busy.
+      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]);
         // Log the synthetic busy too.
         console.log(UTIL_fmt('<' + UTIL_BytesToHex(busy)));
         this.publishFrame_(busy.buffer);
         return false;
       }
 
-      // SYNC gets to go to the device to flush OS tx/rx queues.
-      // The usb firmware always responds to SYNC, regardless of lock status.
+      // SYNC|INIT gets to go to the device to flush OS tx/rx queues.
+      // The usb firmware is to alway respond to SYNC/INIT,
+      // regardless of lock status.
     }
   }
   return true;
 };
 
 /**
  * Update or grab lock.
  * @param {number} cid Channel ID
  * @param {number} cmd Command
  * @param {number} arg Command argument
@@ skipping 160 matching lines @@
   var numEnumerated = 0;
   var allDevs = [];
 
   function enumerated(devs) {
     allDevs = allDevs.concat(devs);
     if (++numEnumerated == permittedDevs.length) {
       cb(allDevs);
     }
   }
 
-  GnubbyDevice.getPermittedUsbDevices(function(devs) {
-    permittedDevs = devs;
-    for (var i = 0; i < devs.length; i++) {
-      chrome.hid.getDevices(devs[i], enumerated);
-    }
-  });
+  try {
+    chrome.hid.getDevices({filters: [{usagePage: 0xf1d0}]}, cb);
+  } catch (e) {
+    console.log(e);
+    console.log(UTIL_fmt('falling back to vid/pid enumeration'));
+    GnubbyDevice.getPermittedUsbDevices(function(devs) {
+      permittedDevs = devs;
+      for (var i = 0; i < devs.length; i++) {
+        chrome.hid.getDevices(devs[i], enumerated);
+      }
+    });
+  }
 };
 
 /**
  * @param {Gnubbies} gnubbies The gnubbies instances this device is enumerated
  *     in.
  * @param {number} which The index of the device to open.
  * @param {!chrome.hid.HidDeviceInfo} dev The device to open.
  * @param {function(number, GnubbyDevice=)} cb Called back with the
  *     result of opening the device.
  */
@@ skipping 32 matching lines @@
  */
 HidGnubbyDevice.register = function(gnubbies) {
   var HID_GNUBBY_IMPL = {
     isSharedAccess: true,
     enumerate: HidGnubbyDevice.enumerate,
     deviceToDeviceId: HidGnubbyDevice.deviceToDeviceId,
     open: HidGnubbyDevice.open
   };
   gnubbies.registerNamespace(HidGnubbyDevice.NAMESPACE, HID_GNUBBY_IMPL);
 };