Track USB alternate interface 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"
@@ skipping 158 matching lines @@
         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 SelectAlternateInterfacePromiseAdapter : public WebCallbacks<void, const WebUSBError&> {
+public:
+    SelectAlternateInterfacePromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, size_t interfaceIndex, size_t alternateIndex)
+        : m_device(device)
+        , m_resolver(resolver)
+        , m_interfaceIndex(interfaceIndex)
+        , m_alternateIndex(alternateIndex)
+    {
+    }
+
+    void onSuccess() override
+    {
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+            return;
+        m_device->onAlternateInterfaceSelected(true /* success */, m_interfaceIndex, m_alternateIndex);
+        m_resolver->resolve();
+    }
+
+    void onError(const WebUSBError& e) override
+    {
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+            return;
+        m_device->onAlternateInterfaceSelected(false /* failure */, m_interfaceIndex, m_alternateIndex);
+        m_resolver->reject(USBError::take(m_resolver, e));
+    }
+
+private:
+    Persistent<USBDevice> m_device;
+    Persistent<ScriptPromiseResolver> m_resolver;
+    size_t m_interfaceIndex;
+    size_t m_alternateIndex;
+};
+
 class InputTransferResult {
     WTF_MAKE_NONCOPYABLE(InputTransferResult);
 public:
     using WebType = OwnPtr<WebUSBTransferInfo>;
 
     static USBInTransferResult* take(ScriptPromiseResolver*, PassOwnPtr<WebUSBTransferInfo> webTransferInfo)
     {
         ASSERT(webTransferInfo->status.size() == 1);
         return USBInTransferResult::create(convertTransferStatus(webTransferInfo->status[0]), webTransferInfo->data);
     }
@@ skipping 108 matching lines @@
 
 void USBDevice::onConfigurationSelected(bool success, size_t configurationIndex)
 {
     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_selectedAlternates.resize(numInterfaces);
+        m_selectedAlternates.fill(0);
     }
     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);
 }
 
+void USBDevice::onAlternateInterfaceSelected(bool success, size_t interfaceIndex, size_t alternateIndex)
+{
+    if (success)
+        m_selectedAlternates[interfaceIndex] = alternateIndex;
+    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);
 }
 
+size_t USBDevice::selectedAlternateInterface(size_t interfaceIndex) const
+{
+    return m_selectedAlternates[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;
@@ skipping 88 matching lines @@
         } 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)
+ScriptPromise USBDevice::selectAlternateInterface(ScriptState* scriptState, uint8_t interfaceNumber, uint8_t alternateSetting)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureInterfaceClaimed(interfaceNumber, resolver))
-        m_device->setInterface(interfaceNumber, alternateSetting, new CallbackPromiseAdapter<void, USBError>(resolver));
+    if (ensureInterfaceClaimed(interfaceNumber, resolver)) {
+        // TODO(reillyg): This is duplicated work.
+        int interfaceIndex = findInterfaceIndex(interfaceNumber);
+        ASSERT(interfaceIndex != -1);
+        int alternateIndex = findAlternateIndex(interfaceIndex, alternateSetting);
+        if (alternateIndex == -1) {
+            resolver->reject(DOMException::create(NotFoundError, "The alternate setting provided is not supported by the device in its current configuration."));
+        } else {
+            m_interfaceStateChangeInProgress.set(interfaceIndex);
+            m_device->setInterface(interfaceNumber, alternateSetting, new SelectAlternateInterfacePromiseAdapter(this, resolver, interfaceIndex, alternateIndex));
+        }
+    }
     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;
         DOMException* error = convertControlTransferParameters(WebUSBDevice::TransferDirection::In, setup, &parameters);
@@ skipping 124 matching lines @@
 {
     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;
 }
 
+int USBDevice::findAlternateIndex(size_t interfaceIndex, uint8_t alternateSetting) const
+{
+    ASSERT(m_configurationIndex != -1);
+    const auto& alternates = info().configurations[m_configurationIndex].interfaces[interfaceIndex].alternates;
+    for (size_t i = 0; i < alternates.size(); ++i) {
+        if (alternates[i].alternateSetting == alternateSetting)
+            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;
@@ skipping 40 matching lines @@
 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