Track USB device interface claim state in Blink.

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

 // 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.
 
 #include "modules/webusb/USBDevice.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ToV8.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/webusb/USBConfiguration.h"
 #include "modules/webusb/USBControlTransferParameters.h"
 #include "modules/webusb/USBError.h"
 #include "modules/webusb/USBInTransferResult.h"
 #include "modules/webusb/USBIsochronousInTransferResult.h"
 #include "modules/webusb/USBIsochronousOutTransferResult.h"
 #include "modules/webusb/USBOutTransferResult.h"
 #include "public/platform/modules/webusb/WebUSBTransferInfo.h"
 #include "wtf/Assertions.h"
 
 namespace blink {
 
 namespace {
 
 const char kDeviceStateChangeInProgress[] = "An operation that changes the device state is in progress.";
+const char kInterfaceNotFound[] = "The interface number provided is not supported by the device in its current configuration.";
+const char kInterfaceStateChangeInProgress[] = "An operation that changes interface state is in progress.";
 const char kOpenRequired[] = "The device must be opened first.";
 
 DOMException* convertControlTransferParameters(
     WebUSBDevice::TransferDirection direction,
     const USBControlTransferParameters& parameters,
     WebUSBDevice::ControlTransferParameters* webParameters)
 {
     webParameters->direction = direction;
 
     if (parameters.requestType() == "standard")
         webParameters->type = WebUSBDevice::RequestType::Standard;
     else if (parameters.requestType() == "class")
         webParameters->type = WebUSBDevice::RequestType::Class;
     else if (parameters.requestType() == "vendor")
         webParameters->type = WebUSBDevice::RequestType::Vendor;
     else
         return DOMException::create(TypeMismatchError, "The control transfer requestType parameter is invalid.");
 
+    // TODO(reillyg): Check for interface and endpoint availability if that is
+    // the control transfer target.
     if (parameters.recipient() == "device")
         webParameters->recipient = WebUSBDevice::RequestRecipient::Device;
     else if (parameters.recipient() == "interface")
         webParameters->recipient = WebUSBDevice::RequestRecipient::Interface;
     else if (parameters.recipient() == "endpoint")
         webParameters->recipient = WebUSBDevice::RequestRecipient::Endpoint;
     else if (parameters.recipient() == "other")
         webParameters->recipient = WebUSBDevice::RequestRecipient::Other;
     else
         return DOMException::create(TypeMismatchError, "The control transfer recipient parameter is invalid.");
@@ skipping 25 matching lines @@
         : m_device(device)
         , m_resolver(resolver)
         , m_desiredState(desiredState)
     {
     }
 
     void onSuccess() override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
-        if (m_device)
-            m_device->onDeviceOpenedOrClosed(m_desiredState);
+        m_device->onDeviceOpenedOrClosed(m_desiredState);
         m_resolver->resolve();
     }
 
     void onError(const WebUSBError& e) override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
-        if (m_device)
-            m_device->onDeviceOpenedOrClosed(!m_desiredState);
+        m_device->onDeviceOpenedOrClosed(!m_desiredState);
         m_resolver->reject(USBError::take(m_resolver, e));
     }
 
 private:
-    WeakPersistent<USBDevice> m_device;
+    Persistent<USBDevice> m_device;
     Persistent<ScriptPromiseResolver> m_resolver;
     bool m_desiredState; // true: open, false: closed
 };
 
 class SelectConfigurationPromiseAdapter : public WebCallbacks<void, const WebUSBError&> {
 public:
-    SelectConfigurationPromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, int configurationIndex)
+    SelectConfigurationPromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, size_t configurationIndex)
         : m_device(device)
         , m_resolver(resolver)
         , m_configurationIndex(configurationIndex)
     {
     }
 
     void onSuccess() override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
-        if (m_device)
-            m_device->onConfigurationSelected(true /* success */, m_configurationIndex);
+        m_device->onConfigurationSelected(true /* success */, m_configurationIndex);
         m_resolver->resolve();
     }
 
     void onError(const WebUSBError& e) override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
-        if (m_device)
-            m_device->onConfigurationSelected(false /* failure */, m_configurationIndex);
+        m_device->onConfigurationSelected(false /* failure */, m_configurationIndex);
         m_resolver->reject(USBError::take(m_resolver, e));
     }
 
 private:
-    WeakPersistent<USBDevice> m_device;
+    Persistent<USBDevice> m_device;
     Persistent<ScriptPromiseResolver> m_resolver;
-    int m_configurationIndex;
+    size_t m_configurationIndex;
+};
+
+class ClaimInterfacePromiseAdapter : public WebCallbacks<void, const WebUSBError&> {
+public:
+    ClaimInterfacePromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, size_t interfaceIndex, bool desiredState)
+        : m_device(device)
+        , m_resolver(resolver)
+        , m_interfaceIndex(interfaceIndex)
+        , m_desiredState(desiredState)
+    {
+    }
+
+    void onSuccess() override
+    {
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+            return;
+        m_device->onInterfaceClaimedOrUnclaimed(m_desiredState, m_interfaceIndex);
+        m_resolver->resolve();
+    }
+
+    void onError(const WebUSBError& e) override
+    {
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+            return;
+        m_device->onInterfaceClaimedOrUnclaimed(!m_desiredState, m_interfaceIndex);
+        m_resolver->reject(USBError::take(m_resolver, e));
+    }
+
+private:
+    Persistent<USBDevice> m_device;
+    Persistent<ScriptPromiseResolver> m_resolver;
+    size_t m_interfaceIndex;
+    bool m_desiredState; // true: claimed, false: unclaimed
 };
 
 class InputTransferResult {
     WTF_MAKE_NONCOPYABLE(InputTransferResult);
 public:
     using WebType = OwnPtr<WebUSBTransferInfo>;
 
     static USBInTransferResult* take(ScriptPromiseResolver*, PassOwnPtr<WebUSBTransferInfo> webTransferInfo)
     {
         ASSERT(webTransferInfo->status.size() == 1);
@@ skipping 88 matching lines @@
 USBDevice* USBDevice::take(ScriptPromiseResolver* resolver, PassOwnPtr<WebUSBDevice> device)
 {
     return USBDevice::create(device, resolver->getExecutionContext());
 }
 
 USBDevice::USBDevice(PassOwnPtr<WebUSBDevice> device, ExecutionContext* context)
     : ContextLifecycleObserver(context)
     , m_device(device)
     , m_opened(false)
     , m_deviceStateChangeInProgress(false)
+    , m_configurationIndex(-1)
 {
-    m_configurationIndex = findConfigurationIndex(info().activeConfiguration);
+    int configurationIndex = findConfigurationIndex(info().activeConfiguration);
+    if (configurationIndex != -1)
+        onConfigurationSelected(true /* success */, configurationIndex);
 }
 
 void USBDevice::onDeviceOpenedOrClosed(bool opened)
 {
     m_opened = opened;
     m_deviceStateChangeInProgress = false;
 }
 
-void USBDevice::onConfigurationSelected(bool success, int configurationIndex)
+void USBDevice::onConfigurationSelected(bool success, size_t configurationIndex)
 {
-    if (success)
+    if (success) {
         m_configurationIndex = configurationIndex;
+        size_t numInterfaces = info().configurations[m_configurationIndex].interfaces.size();
+        m_claimedInterfaces.clearAll();
+        m_claimedInterfaces.resize(numInterfaces);
+        m_interfaceStateChangeInProgress.clearAll();
+        m_interfaceStateChangeInProgress.resize(numInterfaces);
+    }
     m_deviceStateChangeInProgress = false;
 }
 
+void USBDevice::onInterfaceClaimedOrUnclaimed(bool claimed, size_t interfaceIndex)
+{
+    if (claimed)
+        m_claimedInterfaces.set(interfaceIndex);
+    else
+        m_claimedInterfaces.clear(interfaceIndex);
+    m_interfaceStateChangeInProgress.clear(interfaceIndex);
+}
+
+bool USBDevice::isInterfaceClaimed(size_t configurationIndex, size_t interfaceIndex) const
+{
+    return m_configurationIndex != -1 && static_cast<size_t>(m_configurationIndex) == configurationIndex && m_claimedInterfaces.get(interfaceIndex);
+}
+
 USBConfiguration* USBDevice::configuration() const
 {
     if (m_configurationIndex != -1)
         return USBConfiguration::create(this, m_configurationIndex);
     return nullptr;
 }
 
 HeapVector<Member<USBConfiguration>> USBDevice::configurations() const
 {
     HeapVector<Member<USBConfiguration>> configurations;
     size_t numConfigurations = info().configurations.size();
     for (size_t i = 0; i < numConfigurations; ++i)
         configurations.append(USBConfiguration::create(this, i));
     return configurations;
 }
 
 ScriptPromise USBDevice::open(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (m_deviceStateChangeInProgress) {
-        resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
-    } else if (m_opened) {
-        resolver->resolve();
-    } else {
-        m_deviceStateChangeInProgress = true;
-        m_device->open(new OpenClosePromiseAdapter(this, resolver, true /* open */));
+    if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
+        if (m_opened) {
+            resolver->resolve();
+        } else {
+            m_deviceStateChangeInProgress = true;
+            m_device->open(new OpenClosePromiseAdapter(this, resolver, true /* open */));
+        }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::close(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (m_deviceStateChangeInProgress) {
-        resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
-    } else if (!m_opened) {
-        resolver->resolve();
-    } else {
-        m_deviceStateChangeInProgress = true;
-        m_device->close(new OpenClosePromiseAdapter(this, resolver, false /* closed */));
+    if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
+        if (!m_opened) {
+            resolver->resolve();
+        } else {
+            m_deviceStateChangeInProgress = true;
+            m_device->close(new OpenClosePromiseAdapter(this, resolver, false /* closed */));
+        }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::selectConfiguration(ScriptState* scriptState, uint8_t configurationValue)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (!m_opened) {
-        resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
-    } else if (m_deviceStateChangeInProgress) {
-        resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
-    } else {
-        int configurationIndex = findConfigurationIndex(configurationValue);
-        if (configurationIndex == -1) {
-            resolver->reject(DOMException::create(NotFoundError, "The configuration value provided is not supported by the device."));
-        } else if (m_configurationIndex == configurationIndex) {
-            resolver->resolve();
+    if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
+        if (!m_opened) {
+            resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
         } else {
-            m_deviceStateChangeInProgress = true;
-            m_device->setConfiguration(configurationValue, new SelectConfigurationPromiseAdapter(this, resolver, configurationIndex));
+            int configurationIndex = findConfigurationIndex(configurationValue);
+            if (configurationIndex == -1) {
+                resolver->reject(DOMException::create(NotFoundError, "The configuration value provided is not supported by the device."));
+            } else if (m_configurationIndex == configurationIndex) {
+                resolver->resolve();
+            } else {
+                m_deviceStateChangeInProgress = true;
+                m_device->setConfiguration(configurationValue, new SelectConfigurationPromiseAdapter(this, resolver, configurationIndex));
+            }
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::claimInterface(ScriptState* scriptState, uint8_t interfaceNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureDeviceConfigured(resolver))
-        m_device->claimInterface(interfaceNumber, new CallbackPromiseAdapter<void, USBError>(resolver));
+    if (ensureDeviceConfigured(resolver)) {
+        int interfaceIndex = findInterfaceIndex(interfaceNumber);
+        if (interfaceIndex == -1) {
+            resolver->reject(DOMException::create(NotFoundError, kInterfaceNotFound));
+        } else if (m_interfaceStateChangeInProgress.get(interfaceIndex)) {
+            resolver->reject(DOMException::create(InvalidStateError, kInterfaceStateChangeInProgress));
+        } else if (m_claimedInterfaces.get(interfaceIndex)) {
+            resolver->resolve();
+        } else {
+            m_interfaceStateChangeInProgress.set(interfaceIndex);
+            m_device->claimInterface(interfaceNumber, new ClaimInterfacePromiseAdapter(this, resolver, interfaceIndex, true /* claim */));
+        }
+    }
     return promise;
 }
 
 ScriptPromise USBDevice::releaseInterface(ScriptState* scriptState, uint8_t interfaceNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureDeviceConfigured(resolver))
-        m_device->releaseInterface(interfaceNumber, new CallbackPromiseAdapter<void, USBError>(resolver));
+    if (ensureDeviceConfigured(resolver)) {
+        int interfaceIndex = findInterfaceIndex(interfaceNumber);
+        if (interfaceIndex == -1) {
+            resolver->reject(DOMException::create(NotFoundError, "The interface number provided is not supported by the device in its current configuration."));
+        } else if (m_interfaceStateChangeInProgress.get(interfaceIndex)) {
+            resolver->reject(DOMException::create(InvalidStateError, kInterfaceStateChangeInProgress));
+        } else if (!m_claimedInterfaces.get(interfaceIndex)) {
+            resolver->resolve();
+        } else {
+            m_interfaceStateChangeInProgress.set(interfaceIndex);
+            m_device->releaseInterface(interfaceNumber, new ClaimInterfacePromiseAdapter(this, resolver, interfaceIndex, false /* release */));
+        }
+    }
     return promise;
 }
 
 ScriptPromise USBDevice::setInterface(ScriptState* scriptState, uint8_t interfaceNumber, uint8_t alternateSetting)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureDeviceConfigured(resolver))
+    if (ensureInterfaceClaimed(interfaceNumber, resolver))
         m_device->setInterface(interfaceNumber, alternateSetting, new CallbackPromiseAdapter<void, USBError>(resolver));
     return promise;
 }
 
 ScriptPromise USBDevice::controlTransferIn(ScriptState* scriptState, const USBControlTransferParameters& setup, unsigned length)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureDeviceConfigured(resolver)) {
         WebUSBDevice::ControlTransferParameters parameters;
@@ skipping 31 matching lines @@
         if (error) {
             resolver->reject(error);
         } else {
             BufferSource buffer(data);
             m_device->controlTransfer(parameters, buffer.data(), buffer.size(), 0, new CallbackPromiseAdapter<OutputTransferResult, USBError>(resolver));
         }
     }
     return promise;
 }
 
-ScriptPromise USBDevice::clearHalt(ScriptState* scriptState, uint8_t endpointNumber)
+ScriptPromise USBDevice::clearHalt(ScriptState* scriptState, String direction, uint8_t endpointNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureDeviceConfigured(resolver))
+    if (ensureEndpointAvailable(direction == "in", endpointNumber, resolver))
         m_device->clearHalt(endpointNumber, new CallbackPromiseAdapter<void, USBError>(resolver));
     return promise;
 }
 
 ScriptPromise USBDevice::transferIn(ScriptState* scriptState, uint8_t endpointNumber, unsigned length)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureDeviceConfigured(resolver))
+    if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver))
         m_device->transfer(WebUSBDevice::TransferDirection::In, endpointNumber, nullptr, length, 0, new CallbackPromiseAdapter<InputTransferResult, USBError>(resolver));
     return promise;
 }
 
 ScriptPromise USBDevice::transferOut(ScriptState* scriptState, uint8_t endpointNumber, const ArrayBufferOrArrayBufferView& data)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureDeviceConfigured(resolver)) {
+    if (ensureEndpointAvailable(false /* out */, endpointNumber, resolver)) {
         BufferSource buffer(data);
         m_device->transfer(WebUSBDevice::TransferDirection::Out, endpointNumber, buffer.data(), buffer.size(), 0, new CallbackPromiseAdapter<OutputTransferResult, USBError>(resolver));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::isochronousTransferIn(ScriptState* scriptState, uint8_t endpointNumber, Vector<unsigned> packetLengths)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureDeviceConfigured(resolver))
+    if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver))
         m_device->isochronousTransfer(WebUSBDevice::TransferDirection::In, endpointNumber, nullptr, 0, packetLengths, 0, new CallbackPromiseAdapter<IsochronousInputTransferResult, USBError>(resolver));
     return promise;
 }
 
 ScriptPromise USBDevice::isochronousTransferOut(ScriptState* scriptState, uint8_t endpointNumber, const ArrayBufferOrArrayBufferView& data, Vector<unsigned> packetLengths)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureDeviceConfigured(resolver)) {
+    if (ensureEndpointAvailable(false /* out */, endpointNumber, resolver)) {
         BufferSource buffer(data);
         m_device->isochronousTransfer(WebUSBDevice::TransferDirection::Out, endpointNumber, buffer.data(), buffer.size(), packetLengths, 0, new CallbackPromiseAdapter<IsochronousOutputTransferResult, USBError>(resolver));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::reset(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (!m_opened)
-        resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
-    else if (m_deviceStateChangeInProgress)
-        resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
-    else
-        m_device->reset(new CallbackPromiseAdapter<void, USBError>(resolver));
+    if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
+        if (!m_opened)
+            resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
+        else
+            m_device->reset(new CallbackPromiseAdapter<void, USBError>(resolver));
+    }
     return promise;
 }
 
 void USBDevice::contextDestroyed()
 {
     if (m_opened)
         m_device->close(new WebUSBDeviceCloseCallbacks());
 }
 
 DEFINE_TRACE(USBDevice)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 int USBDevice::findConfigurationIndex(uint8_t configurationValue) const
 {
     const auto& configurations = info().configurations;
     for (size_t i = 0; i < configurations.size(); ++i) {
         if (configurations[i].configurationValue == configurationValue)
             return i;
     }
     return -1;
 }
 
+int USBDevice::findInterfaceIndex(uint8_t interfaceNumber) const
+{
+    ASSERT(m_configurationIndex != -1);
+    const auto& interfaces = info().configurations[m_configurationIndex].interfaces;
+    for (size_t i = 0; i < interfaces.size(); ++i) {
+        if (interfaces[i].interfaceNumber == interfaceNumber)
+            return i;
+    }
+    return -1;
+}
+
+bool USBDevice::ensureNoDeviceOrInterfaceChangeInProgress(ScriptPromiseResolver* resolver) const
+{
+    if (m_deviceStateChangeInProgress) {
+        resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
+    } else if (anyInterfaceChangeInProgress()) {
+        resolver->reject(DOMException::create(InvalidStateError, kInterfaceStateChangeInProgress));
+    } else {
+        return true;
+    }
+    return false;
+}
+
 bool USBDevice::ensureDeviceConfigured(ScriptPromiseResolver* resolver) const
 {
     if (!m_opened) {
         resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
     } else if (m_deviceStateChangeInProgress) {
         resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
     } else if (m_configurationIndex == -1) {
         resolver->reject(DOMException::create(InvalidStateError, "The device must have a configuration selected."));
     } else {
         return true;
     }
     return false;
 }
 
+bool USBDevice::ensureInterfaceClaimed(uint8_t interfaceNumber, ScriptPromiseResolver* resolver) const
+{
+    if (!ensureDeviceConfigured(resolver))
+        return false;
+    int interfaceIndex = findInterfaceIndex(interfaceNumber);
+    if (interfaceIndex == -1) {
+        resolver->reject(DOMException::create(NotFoundError, kInterfaceNotFound));
+    } else if (m_interfaceStateChangeInProgress.get(interfaceIndex)) {
+        resolver->reject(DOMException::create(InvalidStateError, kInterfaceStateChangeInProgress));
+    } else if (!m_claimedInterfaces.get(interfaceIndex)) {
+        resolver->reject(DOMException::create(InvalidStateError, "The specified interface has not been claimed."));
+    } else {
+        return true;
+    }
+    return false;
+}
+
+bool USBDevice::ensureEndpointAvailable(bool inTransfer, uint8_t endpointNumber, ScriptPromiseResolver* resolver) const
+{
+    // TODO(reillyg): Check endpoint availability once Blink is tracking which
+    // alternate interfaces are selected.
+    return ensureDeviceConfigured(resolver);
+}
+
+bool USBDevice::anyInterfaceChangeInProgress() const
+{
+    for (size_t i = 0; i < m_interfaceStateChangeInProgress.size(); ++i) {
+        if (m_interfaceStateChangeInProgress.quickGet(i))
+            return true;
+    }
+    return false;
+}
+
 } // namespace blink