Ensure tests don't depend on fake devices being added synchronously

third_party/WebKit/LayoutTests/usb/resources/webusb-test.js

 'use strict';
 
 // This polyfil library implements the following WebIDL:
 //
 // partial interface USB {
 //   [SameObject] readonly attribute USBTest test;
 // }
 //
 // interface USBTest {
 //   attribute EventHandler ondeviceclose;
-//   attribute DOMString? chosenDevice;
+//   attribute FakeUSBDevice? chosenDevice;
 //   attribute FrozenArray<USBDeviceFilter>? lastFilters;
 //
 //   Promise<void> initialize();
 //   Promise<void> attachToWindow(Window window);
-//   DOMString addFakeDevice(FakeUSBDeviceInit deviceInit);
-//   void removeFakeDevice(DOMString);
+//   FakeUSBDevice addFakeDevice(FakeUSBDeviceInit deviceInit);
 //   void reset();
 // };
 //
+// interface FakeUSBDevice {
+//   void disconnect();
+// };
+//
 // dictionary FakeUSBDeviceInit {
 //   octet usbVersionMajor;
 //   octet usbVersionMinor;
 //   octet usbVersionSubminor;
 //   octet deviceClass;
 //   octet deviceSubclass;
 //   octet deviceProtocol;
 //   unsigned short vendorId;
 //   unsigned short productId;
 //   octet deviceVersionMajor;
@@ skipping 38 matching lines @@
 // The global mojo object contains the Mojo JS binding modules loaded during
 // initialization.
 let mojo = null;
 
 // These variables are logically members of the USBTest class but are defined
 // here to hide them from being visible as fields of navigator.usb.test.
 let g_initializePromise = null;
 let g_chooserService = null;
 let g_deviceManager = null;
 let g_closeListener = null;
+let g_nextGuid = 0;
 
 function fakeDeviceInitToDeviceInfo(guid, init) {
   let deviceInfo = {
     guid: guid + "",
     usb_version_major: init.usbVersionMajor,
     usb_version_minor: init.usbVersionMinor,
     usb_version_subminor: init.usbVersionSubminor,
     class_code: init.deviceClass,
     subclass_code: init.deviceSubclass,
     protocol_code: init.deviceProtocol,
@@ skipping 251 matching lines @@
     }
     return Promise.resolve({ packets: packets });
   }
 }
 
 class FakeDeviceManager {
   constructor() {
     this.bindingSet_ =
         new mojo.bindings.BindingSet(mojo.deviceManager.DeviceManager);
     this.devices_ = new Map();
+    this.devicesByGuid_ = new Map();
     this.client_ = null;
+    this.nextGuid_ = 0;
   }
 
   addBinding(handle) {
     this.bindingSet_.addBinding(this, handle);
   }
 
-  addDevice(info) {
+  addDevice(fakeDevice, info) {
     let device = {
-      guid: this.nextGuid_++ + "",
+      fakeDevice: fakeDevice,
+      guid: (this.nextGuid_++).toString(),
       info: info,
       bindingArray: []
     };
-    this.devices_.set(device.guid, device);
+    this.devices_.set(fakeDevice, device);
+    this.devicesByGuid_.set(device.guid, device);
     if (this.client_)
       this.client_.onDeviceAdded(fakeDeviceInitToDeviceInfo(device.guid, info));
-    return device.guid;
   }
 
-  removeDevice(guid) {
-    let device = this.devices_.get(guid);
+  removeDevice(fakeDevice) {
+    let device = this.devices_.get(fakeDevice);
+    if (!device)
+      throw new Error('Cannot remove unknown device.');
+
     for (var binding of device.bindingArray)
       binding.close();
-    this.devices_.delete(guid);
+    this.devices_.delete(device.fakeDevice);
+    this.devicesByGuid_.delete(device.guid);
     if (this.client_) {
       this.client_.onDeviceRemoved(
-          fakeDeviceInitToDeviceInfo(guid, device.info));
+          fakeDeviceInitToDeviceInfo(device.guid, device.info));
     }
   }
 
   removeAllDevices() {
     this.devices_.forEach(device => {
       for (var binding of device.bindingArray)
         binding.close();
       this.client_.onDeviceRemoved(
           fakeDeviceInitToDeviceInfo(device.guid, device.info));
     });
     this.devices_.clear();
+    this.devicesByGuid_.clear();
   }
 
   getDevices(options) {
     let devices = [];
     this.devices_.forEach(device => {
       devices.push(fakeDeviceInitToDeviceInfo(device.guid, device.info));
     });
     return Promise.resolve({ results: devices });
   }
 
   getDevice(guid, request) {
-    let device = this.devices_.get(guid);
+    let device = this.devicesByGuid_.get(guid);
     if (device) {
       let binding = new mojo.bindings.Binding(
           mojo.device.Device, new FakeDevice(device.info), request);
       binding.setConnectionErrorHandler(() => {
         if (g_closeListener)
-          g_closeListener(guid);
+          g_closeListener(device.fakeDevice);
       });
       device.bindingArray.push(binding);
     } else {
       request.close();
     }
   }
 
   setClient(client) {
     this.client_ = client;
   }
 }
 
 class FakeChooserService {
   constructor() {
     this.bindingSet_ = new mojo.bindings.BindingSet(
         mojo.chooserService.ChooserService);
     this.chosenDevice_ = null;
     this.lastFilters_ = null;
   }
 
   addBinding(handle) {
     this.bindingSet_.addBinding(this, handle);
   }
 
-  setChosenDevice(guid) {
-    this.chosenDeviceGuid_ = guid;
+  setChosenDevice(fakeDevice) {
+    this.chosenDevice_ = fakeDevice;
   }
 
   getPermission(deviceFilters) {
     this.lastFilters_ = convertMojoDeviceFilters(deviceFilters);
-    let device = g_deviceManager.devices_.get(this.chosenDeviceGuid_);
+    let device = g_deviceManager.devices_.get(this.chosenDevice_);
     if (device) {
       return Promise.resolve({
         result: fakeDeviceInitToDeviceInfo(device.guid, device.info)
       });
     } else {
       return Promise.resolve({ result: null });
     }
   }
 }
 
+// Unlike FakeDevice this class is exported to callers of USBTest.addFakeDevice.
+class FakeUSBDevice {
+  disconnect() {
+    setTimeout(() => g_deviceManager.removeDevice(this), 0);
+  }
+}
+
 class USBTest {
   constructor() {}
 
   initialize() {
     if (!g_initializePromise) {
       g_initializePromise = new Promise(resolve => {
         window.define = gin.define;  // Mojo modules expect this.
 
         gin.define('WebUSB Test Mocks', [
             'content/public/renderer/frame_interfaces',
@@ skipping 58 matching lines @@
             handle => g_chooserService.addBinding(handle));
         resolve();
       });
     });
   }
 
   addFakeDevice(deviceInit) {
     if (!g_deviceManager)
       throw new Error('Call initialize() before addFakeDevice().');
 
-    return g_deviceManager.addDevice(deviceInit);
-  }
-
-  removeFakeDevice(guid) {
-    if (!g_deviceManager)
-      throw new Error('Call initialize() before removeFakeDevice().');
-
-    return g_deviceManager.removeDevice(guid);
+    // |addDevice| and |removeDevice| are called in a setTimeout callback so
+    // that tests do not rely on the device being immediately available which
+    // may not be true for all implementations of this test API.
+    let fakeDevice = new FakeUSBDevice();
+    setTimeout(() => g_deviceManager.addDevice(fakeDevice, deviceInit), 0);
+    return fakeDevice;
   }
 
   set ondeviceclose(func) {
     g_closeListener = func;
   }
 
-  set chosenDevice(guid) {
+  set chosenDevice(fakeDevice) {
     if (!g_chooserService)
       throw new Error('Call initialize() before setting chosenDevice.');
 
-    g_chooserService.setChosenDevice(guid);
+    g_chooserService.setChosenDevice(fakeDevice);
   }
 
   get lastFilters() {
     if (!g_chooserService)
       throw new Error('Call initialize() before getting lastFilters.');
 
     return g_chooserService.lastFilters_;
   }
 
   reset() {
     if (!g_deviceManager || !g_chooserService)
       throw new Error('Call initialize() before reset().');
 
     g_deviceManager.removeAllDevices();
     g_chooserService.setChosenDevice(null);
     g_closeListener = null;
   }
 }
 
 navigator.usb.test = new USBTest();
 
 })();