Track USB device interface claim state in Blink.

third_party/WebKit/Source/modules/webusb/USBDevice.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef USBDevice_h
 #define USBDevice_h
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "bindings/modules/v8/UnionTypesModules.h"
 #include "core/dom/ContextLifecycleObserver.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/modules/webusb/WebUSBDevice.h"
 #include "public/platform/modules/webusb/WebUSBDeviceInfo.h"
+#include "wtf/BitVector.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class ScriptPromiseResolver;
 class ScriptState;
 class USBConfiguration;
 class USBControlTransferParameters;
 
 class USBDevice
@@ skipping 11 matching lines @@
     }
 
     static USBDevice* take(ScriptPromiseResolver*, PassOwnPtr<WebUSBDevice>);
 
     explicit USBDevice(PassOwnPtr<WebUSBDevice>, ExecutionContext*);
     virtual ~USBDevice() { }
 
     const WebUSBDeviceInfo& info() const { return m_device->info(); }
     void onDeviceOpenedOrClosed(bool);
     void onConfigurationSelected(bool success, int configurationIndex);
+    void onInterfaceClaimedOrUnclaimed(bool claimed, int interfaceIndex);

[juncai, 2016/03/17 01:21:12]

interfaceIndex is int type in this function, but is size_t in function
isInterfaceClaimed(). It is used as a parameter in WTF::BitVector::get(size_t
bit) and set(size_t bit).

[Reilly Grant (use Gerrit), 2016/03/17 17:07:01]

Fixed.

+    bool isInterfaceClaimed(size_t configurationIndex, size_t interfaceIndex) const;
 
     // IDL exposed interface:
     String guid() const { return info().guid; }
     uint8_t usbVersionMajor() { return info().usbVersionMajor; }
     uint8_t usbVersionMinor() { return info().usbVersionMinor; }
     uint8_t usbVersionSubminor() { return info().usbVersionSubminor; }
     uint8_t deviceClass() { return info().deviceClass; }
     uint8_t deviceSubclass() const { return info().deviceSubclass; }
     uint8_t deviceProtocol() const { return info().deviceProtocol; }
     uint16_t vendorId() const { return info().vendorID; }
@@ skipping 10 matching lines @@
 
     ScriptPromise open(ScriptState*);
     ScriptPromise close(ScriptState*);
     ScriptPromise selectConfiguration(ScriptState*, uint8_t configurationValue);
     ScriptPromise claimInterface(ScriptState*, uint8_t interfaceNumber);
     ScriptPromise releaseInterface(ScriptState*, uint8_t interfaceNumber);
     ScriptPromise setInterface(ScriptState*, uint8_t interfaceNumber, uint8_t alternateSetting);
     ScriptPromise controlTransferIn(ScriptState*, const USBControlTransferParameters& setup, unsigned length);
     ScriptPromise controlTransferOut(ScriptState*, const USBControlTransferParameters& setup);
     ScriptPromise controlTransferOut(ScriptState*, const USBControlTransferParameters& setup, const ArrayBufferOrArrayBufferView& data);
-    ScriptPromise clearHalt(ScriptState*, uint8_t endpointNumber);
+    ScriptPromise clearHalt(ScriptState*, String direction, uint8_t endpointNumber);
     ScriptPromise transferIn(ScriptState*, uint8_t endpointNumber, unsigned length);
     ScriptPromise transferOut(ScriptState*, uint8_t endpointNumber, const ArrayBufferOrArrayBufferView& data);
     ScriptPromise isochronousTransferIn(ScriptState*, uint8_t endpointNumber, Vector<unsigned> packetLengths);
     ScriptPromise isochronousTransferOut(ScriptState*, uint8_t endpointNumber, const ArrayBufferOrArrayBufferView& data, Vector<unsigned> packetLengths);
     ScriptPromise reset(ScriptState*);
 
     void contextDestroyed() override;
 
     DECLARE_TRACE();
 
 private:
     int findConfigurationIndex(uint8_t configurationValue) const;
+    int findInterfaceIndex(uint8_t interfaceNumber) const;
     bool ensureDeviceConfigured(ScriptPromiseResolver*) const;
+    bool ensureInterfaceClaimed(uint8_t interfaceNumber, ScriptPromiseResolver*) const;
+    bool ensureEndpointAvailable(bool inTransfer, uint8_t endpointNumber, ScriptPromiseResolver*) const;
+    bool anyInterfaceChangeInProgress() const;
 
     OwnPtr<WebUSBDevice> m_device;
     bool m_opened;
     bool m_deviceStateChangeInProgress;
     int m_configurationIndex;
+    WTF::BitVector m_claimedInterfaces;
+    WTF::BitVector m_interfaceStateChangeInProgress;
 };
 
 } // namespace blink
 
 #endif // USBDevice_h