Track USB endpoint 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 14 matching lines @@
 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.";
 const char kVisibiltyError[] = "Connection is only allowed while the page is visible. This is a temporary measure until we are able to effectively communicate to the user that the page is connected to a device.";
 
-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.");
-
-    webParameters->request = parameters.request();
-    webParameters->value = parameters.value();
-    webParameters->index = parameters.index();
-    return nullptr;
-}
 
 String convertTransferStatus(const WebUSBTransferInfo::Status& status)
 {
     switch (status) {
     case WebUSBTransferInfo::Status::Ok:
         return "ok";
     case WebUSBTransferInfo::Status::Stall:
         return "stall";
     case WebUSBTransferInfo::Status::Babble:
         return "babble";
@@ skipping 239 matching lines @@
     return USBDevice::create(device, resolver->getExecutionContext());
 }
 
 USBDevice::USBDevice(PassOwnPtr<WebUSBDevice> device, ExecutionContext* context)
     : ContextLifecycleObserver(context)
     , PageLifecycleObserver(toDocument(context)->page())
     , m_device(device)
     , m_opened(false)
     , m_deviceStateChangeInProgress(false)
     , m_configurationIndex(-1)
+    , m_inEndpoints(15)
+    , m_outEndpoints(15)
 {
     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, 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_inEndpoints.clearAll();
+        m_outEndpoints.clearAll();
     }
     m_deviceStateChangeInProgress = false;
 }
 
 void USBDevice::onInterfaceClaimedOrUnclaimed(bool claimed, size_t interfaceIndex)
 {
-    if (claimed)
+    if (claimed) {
         m_claimedInterfaces.set(interfaceIndex);
-    else
+    } else {
         m_claimedInterfaces.clear(interfaceIndex);
+        m_selectedAlternates[interfaceIndex] = 0;
+    }
+    setEndpointsForInterface(interfaceIndex, claimed);
     m_interfaceStateChangeInProgress.clear(interfaceIndex);
 }
 
 void USBDevice::onAlternateInterfaceSelected(bool success, size_t interfaceIndex, size_t alternateIndex)
 {
     if (success)
         m_selectedAlternates[interfaceIndex] = alternateIndex;
+    setEndpointsForInterface(interfaceIndex, success);
     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
 {
@@ skipping 94 matching lines @@
     ScriptPromise promise = resolver->promise();
     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 {
+            // Mark this interface's endpoints unavailable while its state is
+            // changing.
+            setEndpointsForInterface(interfaceIndex, false);
             m_interfaceStateChangeInProgress.set(interfaceIndex);
             m_device->releaseInterface(interfaceNumber, new ClaimInterfacePromiseAdapter(this, resolver, interfaceIndex, false /* release */));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::selectAlternateInterface(ScriptState* scriptState, uint8_t interfaceNumber, uint8_t alternateSetting)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     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 {
+            // Mark this old alternate interface's endpoints unavailable while
+            // the change is in progress.
+            setEndpointsForInterface(interfaceIndex, false);
             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);
-        if (error)
-            resolver->reject(error);
-        else
+        if (convertControlTransferParameters(WebUSBDevice::TransferDirection::In, setup, &parameters, resolver))
             m_device->controlTransfer(parameters, nullptr, length, 0, new CallbackPromiseAdapter<InputTransferResult, USBError>(resolver));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::controlTransferOut(ScriptState* scriptState, const USBControlTransferParameters& setup)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureDeviceConfigured(resolver)) {
         WebUSBDevice::ControlTransferParameters parameters;
-        DOMException* error = convertControlTransferParameters(WebUSBDevice::TransferDirection::Out, setup, &parameters);
-        if (error)
-            resolver->reject(error);
-        else
+        if (convertControlTransferParameters(WebUSBDevice::TransferDirection::Out, setup, &parameters, resolver))
             m_device->controlTransfer(parameters, nullptr, 0, 0, new CallbackPromiseAdapter<OutputTransferResult, USBError>(resolver));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::controlTransferOut(ScriptState* scriptState, const USBControlTransferParameters& setup, const ArrayBufferOrArrayBufferView& data)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureDeviceConfigured(resolver)) {
         WebUSBDevice::ControlTransferParameters parameters;
-        DOMException* error = convertControlTransferParameters(WebUSBDevice::TransferDirection::Out, setup, &parameters);
-        if (error) {
-            resolver->reject(error);
-        } else {
+        if (convertControlTransferParameters(WebUSBDevice::TransferDirection::Out, setup, &parameters, resolver)) {
             BufferSource buffer(data);
             m_device->controlTransfer(parameters, buffer.data(), buffer.size(), 0, new CallbackPromiseAdapter<OutputTransferResult, USBError>(resolver));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::clearHalt(ScriptState* scriptState, String direction, uint8_t endpointNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
@@ skipping 158 matching lines @@
         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);
+    if (!ensureDeviceConfigured(resolver))
+        return false;
+    if (endpointNumber == 0 || endpointNumber >= 16) {
+        resolver->reject(DOMException::create(IndexSizeError, "The specified endpoint number is out of range."));
+        return false;
+    }
+    auto& bitVector = inTransfer ? m_inEndpoints : m_outEndpoints;
+    if (!bitVector.get(endpointNumber - 1)) {
+        resolver->reject(DOMException::create(NotFoundError, "The specified endpoint is not part of a claimed and selected alternate interface."));
+        return false;
+    }
+    return true;
 }
 
 bool USBDevice::anyInterfaceChangeInProgress() const
 {
     for (size_t i = 0; i < m_interfaceStateChangeInProgress.size(); ++i) {
         if (m_interfaceStateChangeInProgress.quickGet(i))
             return true;
     }
     return false;
 }
 
+bool USBDevice::convertControlTransferParameters(
+    WebUSBDevice::TransferDirection direction,
+    const USBControlTransferParameters& parameters,
+    WebUSBDevice::ControlTransferParameters* webParameters,
+    ScriptPromiseResolver* resolver) const
+{
+    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 {
+        resolver->reject(DOMException::create(TypeMismatchError, "The control transfer requestType parameter is invalid."));
+        return false;
+    }
+
+    if (parameters.recipient() == "device") {
+        webParameters->recipient = WebUSBDevice::RequestRecipient::Device;
+    } else if (parameters.recipient() == "interface") {
+        size_t interfaceNumber = parameters.index() & 0xff;
+        if (!ensureInterfaceClaimed(interfaceNumber, resolver))
+            return false;
+        webParameters->recipient = WebUSBDevice::RequestRecipient::Interface;
+    } else if (parameters.recipient() == "endpoint") {
+        bool inTransfer = parameters.index() & 0x80;
+        size_t endpointNumber = parameters.index() & 0x0f;
+        if (!ensureEndpointAvailable(inTransfer, endpointNumber, resolver))
+            return false;
+        webParameters->recipient = WebUSBDevice::RequestRecipient::Endpoint;
+    } else if (parameters.recipient() == "other") {
+        webParameters->recipient = WebUSBDevice::RequestRecipient::Other;
+    } else {
+        resolver->reject(DOMException::create(TypeMismatchError, "The control transfer recipient parameter is invalid."));
+        return false;
+    }
+
+    webParameters->request = parameters.request();
+    webParameters->value = parameters.value();
+    webParameters->index = parameters.index();
+    return true;
+}
+
+void USBDevice::setEndpointsForInterface(size_t interfaceIndex, bool set)
+{
+    const auto& configuration = info().configurations[m_configurationIndex];
+    const auto& interface = configuration.interfaces[interfaceIndex];
+    const auto& alternate = interface.alternates[m_selectedAlternates[interfaceIndex]];
+    for (const auto& endpoint : alternate.endpoints) {
+        if (endpoint.endpointNumber == 0 || endpoint.endpointNumber >= 16)
+            continue; // Ignore endpoints with invalid indices.
+        auto& bitVector = endpoint.direction == WebUSBDevice::TransferDirection::In ? m_inEndpoints : m_outEndpoints;
+        if (set)
+            bitVector.set(endpoint.endpointNumber - 1);
+        else
+            bitVector.clear(endpoint.endpointNumber - 1);
+    }
+}
+
 } // namespace blink