Move classes in the device.usb Mojo namespace to device.mojom

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;
@@ skipping 106 matching lines @@
           interface_name: alternate.interfaceName,
           endpoints: []
         };
         alternate.endpoints.forEach(endpoint => {
           var endpointInfo = {
             endpoint_number: endpoint.endpointNumber,
             packet_size: endpoint.packetSize,
           };
           switch (endpoint.direction) {
           case "in":
-            endpointInfo.direction = mojo.device.TransferDirection.INBOUND;
+            endpointInfo.direction = mojo.device.UsbTransferDirection.INBOUND;
             break;
           case "out":
-            endpointInfo.direction = mojo.device.TransferDirection.OUTBOUND;
+            endpointInfo.direction = mojo.device.UsbTransferDirection.OUTBOUND;
             break;
           }
           switch (endpoint.type) {
           case "bulk":
-            endpointInfo.type = mojo.device.EndpointType.BULK;
+            endpointInfo.type = mojo.device.UsbEndpointType.BULK;
             break;
           case "interrupt":
-            endpointInfo.type = mojo.device.EndpointType.INTERRUPT;
+            endpointInfo.type = mojo.device.UsbEndpointType.INTERRUPT;
             break;
           case "isochronous":
-            endpointInfo.type = mojo.device.EndpointType.ISOCHRONOUS;
+            endpointInfo.type = mojo.device.UsbEndpointType.ISOCHRONOUS;
             break;
           }
           alternateInfo.endpoints.push(endpointInfo);
         });
         interfaceInfo.alternates.push(alternateInfo);
       });
       configInfo.interfaces.push(interfaceInfo);
     });
     deviceInfo.configurations.push(configInfo);
   });
@@ skipping 38 matching lines @@
       return Promise.resolve({
           value: this.currentConfiguration_.configuration_value });
     } else {
       return Promise.resolve({ value: 0 });
     }
   }
 
   open() {
     assert_false(this.opened_);
     this.opened_ = true;
-    return Promise.resolve({ error: mojo.device.OpenDeviceError.OK });
+    return Promise.resolve({ error: mojo.device.UsbOpenDeviceError.OK });
   }
 
   close() {
     assert_true(this.opened_);
     this.opened_ = false;
     return Promise.resolve();
   }
 
   setConfiguration(value) {
     assert_true(this.opened_);
@@ skipping 51 matching lines @@
     assert_true(this.opened_);
     assert_false(this.currentConfiguration_ == null, 'device configured');
     // TODO(reillyg): Assert that endpoint is valid.
     return Promise.resolve({ success: true });
   }
 
   controlTransferIn(params, length, timeout) {
     assert_true(this.opened_);
     assert_false(this.currentConfiguration_ == null, 'device configured');
     return Promise.resolve({
-      status: mojo.device.TransferStatus.OK,
+      status: mojo.device.UsbTransferStatus.OK,
       data: [length >> 8, length & 0xff, params.request, params.value >> 8,
              params.value & 0xff, params.index >> 8, params.index & 0xff]
     });
   }
 
   controlTransferOut(params, data, timeout) {
     assert_true(this.opened_);
     assert_false(this.currentConfiguration_ == null, 'device configured');
     return Promise.resolve({
-      status: mojo.device.TransferStatus.OK,
+      status: mojo.device.UsbTransferStatus.OK,
       bytesWritten: data.byteLength
     });
   }
 
   genericTransferIn(endpointNumber, length, timeout) {
     assert_true(this.opened_);
     assert_false(this.currentConfiguration_ == null, 'device configured');
     // TODO(reillyg): Assert that endpoint is valid.
     let data = new Array(length);
     for (let i = 0; i < length; ++i)
       data[i] = i & 0xff;
     return Promise.resolve({
-      status: mojo.device.TransferStatus.OK,
+      status: mojo.device.UsbTransferStatus.OK,
       data: data
     });
   }
 
   genericTransferOut(endpointNumber, data, timeout) {
     assert_true(this.opened_);
     assert_false(this.currentConfiguration_ == null, 'device configured');
     // TODO(reillyg): Assert that endpoint is valid.
     return Promise.resolve({
-      status: mojo.device.TransferStatus.OK,
+      status: mojo.device.UsbTransferStatus.OK,
       bytesWritten: data.byteLength
     });
   }
 
   isochronousTransferIn(endpointNumber, packetLengths, timeout) {
     assert_true(this.opened_);
     assert_false(this.currentConfiguration_ == null, 'device configured');
     // TODO(reillyg): Assert that endpoint is valid.
     let data = new Array(packetLengths.reduce((a, b) => a + b, 0));
     let dataOffset = 0;
     let packets = new Array(packetLengths.length);
     for (let i = 0; i < packetLengths.length; ++i) {
       for (let j = 0; j < packetLengths[i]; ++j)
         data[dataOffset++] = j & 0xff;
       packets[i] = {
         length: packetLengths[i],
         transferred_length: packetLengths[i],
-        status: mojo.device.TransferStatus.OK
+        status: mojo.device.UsbTransferStatus.OK
       };
     }
     return Promise.resolve({ data: data, packets: packets });
   }
 
   isochronousTransferOut(endpointNumber, data, packetLengths, timeout) {
     assert_true(this.opened_);
     assert_false(this.currentConfiguration_ == null, 'device configured');
     // TODO(reillyg): Assert that endpoint is valid.
     let packets = new Array(packetLengths.length);
     for (let i = 0; i < packetLengths.length; ++i) {
       packets[i] = {
         length: packetLengths[i],
         transferred_length: packetLengths[i],
-        status: mojo.device.TransferStatus.OK
+        status: mojo.device.UsbTransferStatus.OK
       };
     }
     return Promise.resolve({ packets: packets });
   }
 }
 
 class FakeDeviceManager {
   constructor() {
     this.bindingSet_ =
-        new mojo.bindings.BindingSet(mojo.deviceManager.DeviceManager);
+        new mojo.bindings.BindingSet(mojo.deviceManager.UsbDeviceManager);
     this.devices_ = new Map();
     this.client_ = null;
   }
 
   addBinding(handle) {
     this.bindingSet_.addBinding(this, handle);
   }
 
   addDevice(info) {
     let device = {
@@ skipping 33 matching lines @@
     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);
     if (device) {
       let binding = new mojo.bindings.Binding(
-          mojo.device.Device, new FakeDevice(device.info), request);
+          mojo.device.UsbDevice, new FakeDevice(device.info), request);
       binding.setConnectionErrorHandler(() => {
         if (g_closeListener)
           g_closeListener(guid);
       });
       device.bindingArray.push(binding);
     } else {
       request.close();
     }
   }
 
   setClient(client) {
     this.client_ = client;
   }
 }
 
 class FakeChooserService {
   constructor() {
     this.bindingSet_ = new mojo.bindings.BindingSet(
-        mojo.chooserService.ChooserService);
+        mojo.chooserService.UsbChooserService);
     this.chosenDevice_ = null;
     this.lastFilters_ = null;
   }
 
   addBinding(handle) {
     this.bindingSet_.addBinding(this, handle);
   }
 
   setChosenDevice(guid) {
     this.chosenDeviceGuid_ = guid;
@@ skipping 39 matching lines @@
             deviceManager: deviceManager,
             device: device,
             bindings: bindings,
             core: core,
             router: router,
             support: support
           };
 
           g_deviceManager = new FakeDeviceManager();
           mojo.frameInterfaces.addInterfaceOverrideForTesting(
-              mojo.deviceManager.DeviceManager.name,
+              mojo.deviceManager.UsbDeviceManager.name,
               handle => g_deviceManager.addBinding(handle));
 
           g_chooserService = new FakeChooserService();
           mojo.frameInterfaces.addInterfaceOverrideForTesting(
-              mojo.chooserService.ChooserService.name,
+              mojo.chooserService.UsbChooserService.name,
               handle => g_chooserService.addBinding(handle));
 
           addEventListener('unload', () => {
             mojo.frameInterfaces.clearInterfaceOverridesForTesting();
           });
 
           resolve();
         });
       });
     }
 
     return g_initializePromise;
   }
 
   attachToWindow(otherWindow) {
     if (!g_deviceManager || !g_chooserService)
       throw new Error('Call initialize() before attachToWindow().');
 
     return new Promise(resolve => {
       otherWindow.gin.define(
       'WebUSB Test Frame Attach', [
         'content/public/renderer/frame_interfaces'
       ], frameInterfaces => {
         frameInterfaces.addInterfaceOverrideForTesting(
-            mojo.deviceManager.DeviceManager.name,
+            mojo.deviceManager.UsbDeviceManager.name,
             handle => g_deviceManager.addBinding(handle));
         frameInterfaces.addInterfaceOverrideForTesting(
-            mojo.chooserService.ChooserService.name,
+            mojo.chooserService.UsbChooserService.name,
             handle => g_chooserService.addBinding(handle));
         resolve();
       });
     });
   }
 
   addFakeDevice(deviceInit) {
     if (!g_deviceManager)
       throw new Error('Call initialize() before addFakeDevice().');
 
@@ skipping 31 matching lines @@
 
     g_deviceManager.removeAllDevices();
     g_chooserService.setChosenDevice(null);
     g_closeListener = null;
   }
 }
 
 navigator.usb.test = new USBTest();
 
 })();