Track USBDevice open state in Blink.

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

 'use strict';
 
 // TODO(reillyg): Remove when jyasskin upstreams this to testharness.js:
 // https://crbug.com/509058.
 function callWithKeyDown(functionCalledOnKeyPress) {
   return new Promise(resolve => {
     function onKeyPress() {
       document.removeEventListener('keypress', onKeyPress, false);
       resolve(functionCalledOnKeyPress());
     }
@@ skipping 116 matching lines @@
       getConfiguration() {
         if (this.currentConfiguration_ === undefined) {
           return Promise.resolve({ value: 0 });
         } else {
           return Promise.resolve({
               value: this.currentConfiguration_.configuration_value });
         }
       }
 
       open() {
-        // TODO(reillyg): Check if the device is opened and return
-        // OpenDeviceError.ALREADY_OPEN.
+        assert_false(this.opened_);
         this.opened_ = true;
         return Promise.resolve({ error: device.OpenDeviceError.OK });
       }
 
       close() {
+        assert_true(this.opened_);
         this.opened_ = false;
-        return Promise.resolve({});
+        return Promise.resolve({ error: device.OpenDeviceError.OK });
       }
 
       setConfiguration(value) {
-        if (!this.opened_)
-          return Promise.resolve({ success: false });
+        assert_true(this.opened_);
 
         let selected_configuration = this.info_.configurations.find(
             configuration => configuration.configuration_value == value);
         if (selected_configuration !== undefined) {
           this.currentConfiguration_ = selected_configuration;
           return Promise.resolve({ success: true });
         } else {
           return Promise.resolve({ success: false });
         }
       }
 
       claimInterface(interfaceNumber) {
-        if (!this.opened_)
-          return Promise.resolve({ success: false });
+        assert_true(this.opened_);
 
         if (this.currentConfiguration_ === undefined)
           return Promise.resolve({ success: false });
 
         if (this.claimedInterfaces_.has(interfaceNumber))
           return Promise.resolve({ success: false });
 
         if (this.currentConfiguration_.interfaces.some(
                 iface => iface.interface_number == interfaceNumber)) {
           this.claimedInterfaces_.set(interfaceNumber, 0);
           return Promise.resolve({ success: true });
         } else {
           return Promise.resolve({ success: false });
         }
       }
 
       releaseInterface(interfaceNumber) {
-        if (!this.opened_)
-          return Promise.resolve({ success: false });
+        assert_true(this.opened_);
 
         if (this.currentConfiguration_ === undefined)
           return Promise.resolve({ success: false });
 
         if (this.claimedInterfaces_.has(interfaceNumber)) {
           this.claimedInterfaces_.delete(interfaceNumber);
           return Promise.resolve({ success: true });
         } else {
           return Promise.resolve({ success: false });
         }
       }
 
       setInterfaceAlternateSetting(interfaceNumber, alternateSetting) {
-        if (!this.opened_ || this.currentConfiguration_ === undefined)
+        assert_true(this.opened_);
+
+        if (this.currentConfiguration_ === undefined)
           return Promise.resolve({ success: false });
 
         if (!this.claimedInterfaces_.has(interfaceNumber))
           return Promise.resolve({ success: false });
 
         let iface = this.currentConfiguration_.interfaces.find(
             iface => iface.interface_number == interfaceNumber);
         if (iface === undefined)
           return Promise.resolve({ success: false });
 
         if (iface.alternates.some(
                x => x.alternate_setting == alternateSetting)) {
           this.claimedInterfaces_.set(interfaceNumber, alternateSetting);
           return Promise.resolve({ success: true });
         } else {
           return Promise.resolve({ success: false });
         }
       }
 
       reset() {
-        return Promise.resolve({ success: this.opened_ });
+        assert_true(this.opened_);
+        return Promise.resolve({ success: true });
       }
 
       clearHalt(endpoint) {
+        assert_true(this.opened_);
         // TODO(reillyg): Check that endpoint is valid.
-        return Promise.resolve({ success: this.opened_ });
+        return Promise.resolve({ success: true });
       }
 
       controlTransferIn(params, length, timeout) {
+        assert_true(this.opened_);
         return Promise.resolve({
           status: device.TransferStatus.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_);
         return Promise.resolve({
           status: device.TransferStatus.OK,
           bytesWritten: data.byteLength
         });
       }
 
       genericTransferIn(endpointNumber, length, timeout) {
+        assert_true(this.opened_);
         // TODO(reillyg): Check that endpoint is valid.
         let data = new Array(length);
         for (let i = 0; i < length; ++i)
           data[i] = i & 0xff;
         return Promise.resolve({
           status: device.TransferStatus.OK,
           data: data
         });
       }
 
       genericTransferOut(endpointNumber, data, timeout) {
+        assert_true(this.opened_);
         // TODO(reillyg): Check that endpoint is valid.
         return Promise.resolve({
           status: device.TransferStatus.OK,
           bytesWritten: data.byteLength
         });
       }
 
       isochronousTransferIn(endpointNumber, packetLengths, timeout) {
+        assert_true(this.opened_);
         // TODO(reillyg): Check 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: device.TransferStatus.OK
           };
         }
         return Promise.resolve({ data: data, packets: packets });
       }
 
       isochronousTransferOut(endpointNumber, data, packetLengths, timeout) {
+        assert_true(this.opened_);
         // TODO(reillyg): Check 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: device.TransferStatus.OK
           };
         }
         return Promise.resolve({ packets: packets });
@@ skipping 142 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);
 }