Mojo JS bindings: change usb layout tests to use the new "bindings" module.

third_party/WebKit/LayoutTests/usb/resources/usb-helpers.js

 'use strict';
 
 function assertRejectsWithError(promise, name, message) {
   return promise.then(() => {
     assert_unreached('expected promise to reject with ' + name);
   }, error => {
     assert_equals(error.name, name);
     if (message !== undefined)
       assert_equals(error.message, message);
   });
@@ skipping 17 matching lines @@
   // Run gc() as a promise.
   return new Promise((resolve, reject) => {
     GCController.collect();
     setTimeout(resolve, 0);
   });
 }
 
 function usbMocks(mojo) {
   return define('USB Mocks', [
     'mojo/public/js/bindings',
-    'mojo/public/js/connection',
     'device/usb/public/interfaces/chooser_service.mojom',
     'device/usb/public/interfaces/device_manager.mojom',
     'device/usb/public/interfaces/device.mojom',
-  ], (bindings, connection, chooserService, deviceManager, device) => {
+  ], (bindings, chooserService, deviceManager, device) => {
     function assertDeviceInfoEquals(device, info) {
       assert_equals(device.usbVersionMajor, info.usb_version_major);
       assert_equals(device.usbVersionMinor, info.usb_version_minor);
       assert_equals(device.usbVersionSubminor, info.usb_version_subminor);
       assert_equals(device.deviceClass, info.class_code);
       assert_equals(device.deviceSubclass, info.subclass_code);
       assert_equals(device.deviceProtocol, info.protocol_code);
       assert_equals(device.vendorId, info.vendor_id);
       assert_equals(device.productId, info.product_id);
       assert_equals(device.deviceVersionMajor, info.device_version_major);
@@ skipping 263 matching lines @@
             transferred_length: packetLengths[i],
             status: device.TransferStatus.OK
           };
         }
         return Promise.resolve({ packets: packets });
       }
     };
 
     class MockDeviceManager {
       constructor() {
+        this.bindingSet = new bindings.BindingSet(deviceManager.DeviceManager);
+
         this.mockDevices_ = new Map();
         this.deviceCloseHandler_ = null;
         this.client_ = null;
       }
 
-      bindToPipe(pipe) {
-        this.stub_ = connection.bindHandleToStub(
-            pipe, deviceManager.DeviceManager);
-        bindings.StubBindings(this.stub_).delegate = this;
-      }
-
       reset() {
         this.mockDevices_.forEach(device => {
-          for (var stub of device.stubs)
-            bindings.StubBindings(stub).close();
+          for (var binding of device.bindingArray)
+            binding.close();
           this.client_.onDeviceRemoved(device.info);
         });
         this.mockDevices_.clear();
       }
 
       addMockDevice(info) {
         let device = {
           info: info,
-          stubs: []
+          bindingArray: []
         };
         this.mockDevices_.set(info.guid, device);
         if (this.client_)
           this.client_.onDeviceAdded(info);
       }
 
       removeMockDevice(info) {
         let device = this.mockDevices_.get(info.guid);
-        for (var stub of device.stubs)
-          bindings.StubBindings(stub).close();
+        for (var binding of device.bindingArray)
+          binding.close();
         this.mockDevices_.delete(info.guid);
         if (this.client_)
           this.client_.onDeviceRemoved(info);
       }
 
       setDeviceCloseHandler(handler) {
         this.deviceCloseHandler_ = handler;
       }
 
       getDevices(options) {
         let devices = [];
         this.mockDevices_.forEach(device => {
           devices.push(device.info);
         });
         return Promise.resolve({ results: devices });
       }
 
       getDevice(guid, request) {
         let deviceData = this.mockDevices_.get(guid);
         if (deviceData === undefined) {
           request.close();
         } else {
-          var stub = connection.bindHandleToStub(request.handle, device.Device);
-          var mock = new MockDevice(deviceData.info);
-          bindings.StubBindings(stub).delegate = mock;
-          bindings.StubBindings(stub).connectionErrorHandler = () => {
+          var binding = new bindings.Binding(
+              device.Device, new MockDevice(deviceData.info), request);
+          binding.setConnectionErrorHandler(() => {
             if (this.deviceCloseHandler_)
               this.deviceCloseHandler_(deviceData.info);
-          };
-          deviceData.stubs.push(stub);
+          });
+          deviceData.bindingArray.push(binding);
         }
       }
 
       setClient(client) {
         this.client_ = client;
       }
     }
 
     class MockChooserService {
       constructor() {
+        this.bindingSet = new bindings.BindingSet(
+            chooserService.ChooserService);
+
         this.chosenDevice_ = null;
       }
 
-      bindToPipe(pipe) {
-        this.stub_ = connection.bindHandleToStub(
-            pipe, chooserService.ChooserService);
-        bindings.StubBindings(this.stub_).delegate = this;
-      }
-
       setChosenDevice(deviceInfo) {
         this.chosenDeviceInfo_ = deviceInfo;
       }
 
       getPermission(deviceFilters) {
         return Promise.resolve({ result: this.chosenDeviceInfo_ });
       }
     }
 
     let mockDeviceManager = new MockDeviceManager;
     mojo.frameInterfaces.addInterfaceOverrideForTesting(
         deviceManager.DeviceManager.name,
-        pipe => {
-          mockDeviceManager.bindToPipe(pipe);
+        handle => {
+          mockDeviceManager.bindingSet.addBinding(mockDeviceManager, handle);
         });
 
     let mockChooserService = new MockChooserService;
     mojo.frameInterfaces.addInterfaceOverrideForTesting(
         chooserService.ChooserService.name,
-        pipe => {
-          mockChooserService.bindToPipe(pipe);
+        handle => {
+          mockChooserService.bindingSet.addBinding(mockChooserService, handle);
         });
 
     return fakeUsbDevices().then(fakeDevices => Promise.resolve({
       DeviceManager: deviceManager.DeviceManager,
       Device: device.Device,
       MockDeviceManager: MockDeviceManager,
       mockDeviceManager: mockDeviceManager,
       mockChooserService: mockChooserService,
       fakeDevices: fakeDevices,
       assertDeviceInfoEquals: assertDeviceInfoEquals,
       assertConfigurationInfoEquals: assertConfigurationInfoEquals,
     }));
   });
 }
 
 function usb_test(func, name, properties) {
   mojo_test(mojo => usbMocks(mojo).then(usb => {
     let result = Promise.resolve(func(usb));
     let cleanUp = () => usb.mockDeviceManager.reset();
     result.then(cleanUp, cleanUp);
     return result;
   }), name, properties);
 }