Use the Mojo StubBindings interface correctly in WebUSB LayoutTests.

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 16 matching lines @@
 function runGarbageCollection() {
   // 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',
-  ], (chooserService, deviceManager, device) => {
+  ], (bindings, connection, chooserService, deviceManager, device) => {
     function assertDeviceInfoEquals(device, info) {
       assert_equals(device.guid, info.guid);
       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);
@@ skipping 68 matching lines @@
           type = 'isochronous';
           break;
       }
 
       assert_equals(endpoint.endpointNumber, info.endpoint_number);
       assert_equals(endpoint.direction, direction);
       assert_equals(endpoint.type, type);
       assert_equals(endpoint.packetSize, info.packet_size);
     }
 
-    class MockDevice extends device.Device.stubClass {
-      constructor(info, pipe, closeHandler) {
-        super();
+    class MockDevice {
+      constructor(info) {
         this.info_ = info;
-        this.pipe_ = pipe;
-        this.router_ = new mojo.router.Router(pipe);
-        this.router_.setIncomingReceiver(this);
-        this.router_.setErrorHandler(() => {
-          if (this.opened_)
-            this.close();
-        });
         this.opened_ = false;
         this.currentConfiguration_ = undefined;
         this.claimedInterfaces_ = new Map();
-        this.closeHandler_ = closeHandler;
       }
 
       getDeviceInfo() {
         return Promise.resolve({ info: this.info_ });
       }
 
       getConfiguration() {
         if (this.currentConfiguration_ === undefined) {
           return Promise.resolve({ value: 0 });
         } else {
           return Promise.resolve({
               value: this.currentConfiguration_.configuration_value });
         }
       }
 
       open() {
         assert_false(this.opened_);
         this.opened_ = true;
         return Promise.resolve({ error: device.OpenDeviceError.OK });
       }
 
       close() {
         assert_true(this.opened_);
         this.opened_ = false;
-        this.closeHandler_();
         return Promise.resolve({ error: device.OpenDeviceError.OK });
       }
 
       setConfiguration(value) {
         assert_true(this.opened_);
 
         let selected_configuration = this.info_.configurations.find(
             configuration => configuration.configuration_value == value);
         if (selected_configuration !== undefined) {
           this.currentConfiguration_ = selected_configuration;
@@ skipping 144 matching lines @@
           packets[i] = {
             length: packetLengths[i],
             transferred_length: packetLengths[i],
             status: device.TransferStatus.OK
           };
         }
         return Promise.resolve({ packets: packets });
       }
     };
 
-    class MockDeviceManager extends deviceManager.DeviceManager.stubClass {
+    class MockDeviceManager {
       constructor() {
-        super();
-        this.router_ = null;
         this.mockDevices_ = new Map();
         this.addedDevices_ = [];
         this.removedDevices_ = [];
         this.deviceChangePromiseResolvers_ = [];
         this.deviceCloseHandler_ = null;
       }
 
+      bindToPipe(pipe) {
+        this.stub_ = connection.bindHandleToStub(
+            pipe, deviceManager.DeviceManager);
+        bindings.StubBindings(this.stub_).delegate = this;
+      }
+
       reset() {
         this.mockDevices_.forEach(device => {
-          for (var handle of device.handles)
-            mojo.core.close(handle.pipe_);
+          for (var stub of device.stubs)
+            bindings.StubBindings(stub).close();
           this.removedDevices_.push(device.info);
         });
         this.mockDevices_.clear();
         this.maybeResolveDeviceChangePromise();
       }
 
       addMockDevice(info) {
         let device = {
           info: info,
-          handles: []
+          stubs: []
         };
         this.mockDevices_.set(info.guid, device);
         this.addedDevices_.push(info);
         this.maybeResolveDeviceChangePromise();
       }
 
       removeMockDevice(info) {
         let device = this.mockDevices_.get(info.guid);
-        for (var handle of device.handles)
-          mojo.core.close(handle.pipe_);
+        for (var stub of device.stubs)
+          bindings.StubBindings(stub).close();
         this.mockDevices_.delete(info.guid);
         this.removedDevices_.push(info);
         this.maybeResolveDeviceChangePromise();
       }
 
       setDeviceCloseHandler(handler) {
         this.deviceCloseHandler_ = handler;
       }
 
-      bindToPipe(pipe) {
-        assert_equals(this.router_, null);
-        this.router_ = new mojo.router.Router(pipe);
-        this.router_.setIncomingReceiver(this);
-      }
-
       getDevices(options) {
         let devices = [];
         this.mockDevices_.forEach(device => {
           devices.push(device.info);
         });
         return Promise.resolve({ results: devices });
       }
 
       getDeviceChanges() {
         let promise = new Promise((resolve, reject) => {
@@ skipping 16 matching lines @@
         resolve({
           changes: {
             devices_added: this.addedDevices_,
             devices_removed: this.removedDevices_
           }
         });
         this.addedDevices_ = [];
         this.removedDevices_ = [];
       }
 
-      getDevice(guid, pipe) {
+      getDevice(guid, stub) {
         let device = this.mockDevices_.get(guid);
         if (device === undefined) {
-          mojo.core.close(pipe);
+          bindings.StubBindings(stub).close();
         } else {
-          var mock = new MockDevice(device.info, pipe, () => {
+          var mock = new MockDevice(device.info);
+          bindings.StubBindings(stub).delegate = mock;
+          bindings.StubBindings(stub).connectionErrorHandler = () => {
             if (this.deviceCloseHandler_)
               this.deviceCloseHandler_(device.info);
-          });
-          device.handles.push(mock);
+          };
+          device.stubs.push(stub);
         }
       }
     }
 
-    class MockChooserService
-        extends chooserService.ChooserService.stubClass {
+    class MockChooserService {
       constructor() {
-        super();
-        this.router_ = null;
         this.chosenDevice_ = null;
       }
 
       bindToPipe(pipe) {
-        assert_equals(this.router_, null);
-        this.router_ = new mojo.router.Router(pipe);
-        this.router_.setIncomingReceiver(this);
+        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_ });
       }
     }
@@ skipping 26 matching lines @@
 }
 
 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);
 }