Consume Mojo services directly in Blink's WebUSB implementation.

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/Document.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 kDeviceUnavailable[] = "Device unavailable.";
 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.";
 
-
-
-String convertTransferStatus(const WebUSBTransferInfo::Status& status)
+DOMException* convertFatalTransferStatus(const device::usb::blink::TransferStatus& status)
 {
     switch (status) {
-    case WebUSBTransferInfo::Status::Ok:
+    case device::usb::blink::TransferStatus::TRANSFER_ERROR:
+        return DOMException::create(NetworkError, "A transfer error has occured.");
+    case device::usb::blink::TransferStatus::PERMISSION_DENIED:
+        return DOMException::create(SecurityError, "The transfer was not allowed.");
+    case device::usb::blink::TransferStatus::TIMEOUT:
+        return DOMException::create(TimeoutError, "The transfer timed out.");
+    case device::usb::blink::TransferStatus::CANCELLED:
+        return DOMException::create(AbortError, "The transfer was cancelled.");
+    case device::usb::blink::TransferStatus::DISCONNECT:
+        return DOMException::create(NotFoundError, kDeviceUnavailable);
+    case device::usb::blink::TransferStatus::COMPLETED:
+    case device::usb::blink::TransferStatus::STALLED:
+    case device::usb::blink::TransferStatus::BABBLE:
+    case device::usb::blink::TransferStatus::SHORT_PACKET:
+        return nullptr;
+    default:
+        ASSERT_NOT_REACHED();
+        return nullptr;
+    }
+}
+
+String convertTransferStatus(const device::usb::blink::TransferStatus& status)
+{
+    switch (status) {
+    case device::usb::blink::TransferStatus::COMPLETED:
+    case device::usb::blink::TransferStatus::SHORT_PACKET:
         return "ok";
-    case WebUSBTransferInfo::Status::Stall:
+    case device::usb::blink::TransferStatus::STALLED:
         return "stall";
-    case WebUSBTransferInfo::Status::Babble:
+    case device::usb::blink::TransferStatus::BABBLE:
         return "babble";
     default:
         ASSERT_NOT_REACHED();
         return "";
     }
 }
 
-class OpenClosePromiseAdapter : public WebCallbacks<void, const WebUSBError&> {
-public:
-    OpenClosePromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, bool desiredState)
-        : m_device(device)
-        , m_resolver(resolver)
-        , m_desiredState(desiredState)
-    {
-    }
-
-    void onSuccess() override
-    {
-        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
-            return;
-
-        m_device->onDeviceOpenedOrClosed(m_desiredState);
-        if (m_device->page()->isPageVisible()) {
-            m_resolver->resolve();
-        } else {
-            m_device->pageVisibilityChanged();
-            m_resolver->reject(DOMException::create(SecurityError, kVisibiltyError));
-            return;
-        }
-    }
-
-    void onError(const WebUSBError& e) override
-    {
-        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
-            return;
-        m_device->onDeviceOpenedOrClosed(!m_desiredState);
-        m_resolver->reject(USBError::take(m_resolver, e));
-    }
-
-private:
-    Persistent<USBDevice> m_device;
-    Persistent<ScriptPromiseResolver> m_resolver;
-    bool m_desiredState; // true: open, false: closed
-};
-
-class SelectConfigurationPromiseAdapter : public WebCallbacks<void, const WebUSBError&> {
+mojo::WTFArray<uint8_t> convertBufferSource(const ArrayBufferOrArrayBufferView& buffer)
+{
+    ASSERT(!buffer.isNull());
+    Vector<uint8_t> vector;
+    if (buffer.isArrayBuffer())
+        vector.append(static_cast<uint8_t*>(buffer.getAsArrayBuffer()->data()), buffer.getAsArrayBuffer()->byteLength());
+    else
+        vector.append(static_cast<uint8_t*>(buffer.getAsArrayBufferView()->baseAddress()), buffer.getAsArrayBufferView()->byteLength());
+    return mojo::WTFArray<uint8_t>(std::move(vector));
+}
+
+template <typename Callback>
+class PromiseAdapterBase : public Callback::Runnable {
+    WTF_MAKE_NONCOPYABLE(PromiseAdapterBase);
+
+public:
+    PromiseAdapterBase(ScriptPromiseResolver* resolver) : m_resolver(resolver)
+    {
+    }
+
+    virtual ~PromiseAdapterBase()
+    {
+        if (active())
+            m_resolver->reject(DOMException::create(NotFoundError, kDeviceUnavailable));
+    }
+
+    void resolve(void) const
+    {
+        ASSERT(active());
+        m_resolver->resolve();
+        m_resolver = nullptr;
+    }
+
+    template <typename T>
+    void resolve(T value) const
+    {
+        ASSERT(active());
+        m_resolver->resolve(value);
+        m_resolver = nullptr;
+    }
+
+    template <typename T>
+    void reject(T value) const
+    {
+        ASSERT(active());
+        m_resolver->reject(value);
+        m_resolver = nullptr;
+    }
+
+    bool active() const
+    {
+        return m_resolver && m_resolver->getExecutionContext() && !m_resolver->getExecutionContext()->activeDOMObjectsAreStopped();
+    }
+
+    Callback callback()
+    {
+        return Callback(this);
+    }
+
+private:
+    // This field is mutable so that resolve() and reject() can be called from
+    // a mojo::Callback::Runnable's const Run() method.
+    mutable Persistent<ScriptPromiseResolver> m_resolver;
+};
+
+class OpenPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::OpenCallback> {
+    WTF_MAKE_NONCOPYABLE(OpenPromiseAdapter);
+
+public:
+    OpenPromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver)
+        : PromiseAdapterBase(resolver)
+        , m_device(device)
+    {
+    }
+
+    void Run(device::usb::blink::OpenDeviceError error) const override
+    {
+        if (active()) {
+            switch (error) {
+            case device::usb::blink::OpenDeviceError::ALREADY_OPEN:
+                ASSERT_NOT_REACHED();
+                // fall through
+            case device::usb::blink::OpenDeviceError::OK:

[esprehn, 2016/04/06 20:10:45]

The verbosity of the prefix makes all this code hard to read, can we do using
statements or something?

[Reilly Grant (use Gerrit), 2016/04/06 22:30:07]

Added "namespace usb = device::usb::blink;" to shorten the type names while
keeping them distinct from the IDL types.

+                m_device->onDeviceOpenedOrClosed(true);
+                if (m_device->page()->isPageVisible()) {
+                    resolve();
+                } else {
+                    m_device->pageVisibilityChanged();
+                    reject(DOMException::create(SecurityError, kVisibiltyError));
+                }
+                break;
+            case device::usb::blink::OpenDeviceError::ACCESS_DENIED:
+                m_device->onDeviceOpenedOrClosed(false);
+                reject(DOMException::create(SecurityError, "Access denied."));
+                break;
+            }
+        }
+    }
+
+private:
+    Persistent<USBDevice> m_device;
+};
+
+class ClosePromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::CloseCallback> {
+    WTF_MAKE_NONCOPYABLE(ClosePromiseAdapter);
+
+public:
+    ClosePromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver)
+        : PromiseAdapterBase(resolver)
+        , m_device(device)
+    {
+    }
+
+    void Run() const override
+    {
+        if (active()) {
+            m_device->onDeviceOpenedOrClosed(false);
+            resolve();
+        }
+    }
+
+private:
+    Persistent<USBDevice> m_device;
+};
+
+class SelectConfigurationPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::SetConfigurationCallback> {
+    WTF_MAKE_NONCOPYABLE(SelectConfigurationPromiseAdapter);
+
 public:
     SelectConfigurationPromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, size_t configurationIndex)
-        : m_device(device)
-        , m_resolver(resolver)
+        : PromiseAdapterBase(resolver)
+        , m_device(device)
         , m_configurationIndex(configurationIndex)
     {
     }
 
-    void onSuccess() override
-    {
-        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
-            return;
-        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;
-        m_device->onConfigurationSelected(false /* failure */, m_configurationIndex);
-        m_resolver->reject(USBError::take(m_resolver, e));
-    }
-
-private:
-    Persistent<USBDevice> m_device;
-    Persistent<ScriptPromiseResolver> m_resolver;
+    void Run(bool success) const override
+    {
+        if (active()) {
+            m_device->onConfigurationSelected(success, m_configurationIndex);
+            if (success)
+                resolve();
+            else
+                reject(DOMException::create(NetworkError, "Unable to set device configuration."));
+        }
+    }
+
+private:
+    Persistent<USBDevice> m_device;
     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)
+class ClaimInterfacePromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::ClaimInterfaceCallback> {
+    WTF_MAKE_NONCOPYABLE(ClaimInterfacePromiseAdapter);
+
+public:
+    ClaimInterfacePromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, size_t interfaceIndex)
+        : PromiseAdapterBase(resolver)
+        , m_device(device)
         , 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;
+    {
+    }
+
+    void Run(bool success) const override
+    {
+        if (active()) {
+            m_device->onInterfaceClaimedOrUnclaimed(success, m_interfaceIndex);
+            if (success)
+                resolve();
+            else
+                reject(DOMException::create(NetworkError, "Unable to claim interface."));
+        }
+    }
+
+private:
+    Persistent<USBDevice> m_device;
     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)
+};
+
+class ReleaseInterfacePromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::ReleaseInterfaceCallback> {
+    WTF_MAKE_NONCOPYABLE(ReleaseInterfacePromiseAdapter);
+
+public:
+    ReleaseInterfacePromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, size_t interfaceIndex)
+        : PromiseAdapterBase(resolver)
+        , m_device(device)
+        , m_interfaceIndex(interfaceIndex)
+    {
+    }
+
+    void Run(bool success) const override
+    {
+        if (active()) {
+            m_device->onInterfaceClaimedOrUnclaimed(!success, m_interfaceIndex);
+            if (success)
+                resolve();
+            else
+                reject(DOMException::create(NetworkError, "Unable to release interface."));
+        }
+    }
+
+private:
+    Persistent<USBDevice> m_device;
+    size_t m_interfaceIndex;
+};
+
+class SetInterfacePromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::SetInterfaceAlternateSettingCallback> {
+    WTF_MAKE_NONCOPYABLE(SetInterfacePromiseAdapter);
+
+public:
+    SetInterfacePromiseAdapter(USBDevice* device, ScriptPromiseResolver* resolver, size_t interfaceIndex, size_t alternateIndex)
+        : PromiseAdapterBase(resolver)
+        , m_device(device)
         , 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;
+    void Run(bool success) const override
+    {
+        if (active()) {
+            m_device->onAlternateInterfaceSelected(success, m_interfaceIndex, m_alternateIndex);
+            if (success)
+                resolve();
+            else
+                reject(DOMException::create(NetworkError, "Unable to set device interface."));
+        }
+    }
+
+private:
+    Persistent<USBDevice> m_device;
     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);
-    }
-
-private:
-    InputTransferResult() = delete;
-};
-
-class OutputTransferResult {
-    WTF_MAKE_NONCOPYABLE(OutputTransferResult);
-public:
-    using WebType = OwnPtr<WebUSBTransferInfo>;
-
-    static USBOutTransferResult* take(ScriptPromiseResolver*, PassOwnPtr<WebUSBTransferInfo> webTransferInfo)
-    {
-        ASSERT(webTransferInfo->status.size() == 1);
-        ASSERT(webTransferInfo->bytesTransferred.size() == 1);
-        return USBOutTransferResult::create(convertTransferStatus(webTransferInfo->status[0]), webTransferInfo->bytesTransferred[0]);
-    }
-
-private:
-    OutputTransferResult() = delete;
-};
-
-class IsochronousInputTransferResult {
-    WTF_MAKE_NONCOPYABLE(IsochronousInputTransferResult);
-
-public:
-    using WebType = OwnPtr<WebUSBTransferInfo>;
-
-    static USBIsochronousInTransferResult* take(ScriptPromiseResolver*, PassOwnPtr<WebUSBTransferInfo> webTransferInfo)
-    {
-        ASSERT(webTransferInfo->status.size() == webTransferInfo->packetLength.size() && webTransferInfo->packetLength.size() == webTransferInfo->bytesTransferred.size());
-        RefPtr<DOMArrayBuffer> buffer = DOMArrayBuffer::create(webTransferInfo->data.data(), webTransferInfo->data.size());
-        HeapVector<Member<USBIsochronousInTransferPacket>> packets(webTransferInfo->status.size());
+class ControlTransferInPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::ControlTransferInCallback> {
+    WTF_MAKE_NONCOPYABLE(ControlTransferInPromiseAdapter);
+
+public:
+    ControlTransferInPromiseAdapter(ScriptPromiseResolver* resolver)
+        : PromiseAdapterBase(resolver)
+    {
+    }
+
+    void Run(device::usb::blink::TransferStatus status, mojo::WTFArray<uint8_t> data) const override
+    {
+        if (active()) {
+            DOMException* error = convertFatalTransferStatus(status);
+            if (error)
+                reject(error);
+            else
+                resolve(USBInTransferResult::create(convertTransferStatus(status), data.PassStorage()));
+        }
+    }
+};
+
+class ControlTransferOutPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::ControlTransferOutCallback> {
+    WTF_MAKE_NONCOPYABLE(ControlTransferOutPromiseAdapter);
+
+public:
+    ControlTransferOutPromiseAdapter(ScriptPromiseResolver* resolver, unsigned transferLength)
+        : PromiseAdapterBase(resolver)
+        , m_transferLength(transferLength)
+    {
+    }
+
+    void Run(device::usb::blink::TransferStatus status) const override
+    {
+        if (active()) {
+            DOMException* error = convertFatalTransferStatus(status);
+            if (error)
+                reject(error);
+            else
+                resolve(USBOutTransferResult::create(convertTransferStatus(status), m_transferLength));
+        }
+    }
+
+private:
+    unsigned m_transferLength;
+};
+
+class ClearHaltPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::ClearHaltCallback> {
+    WTF_MAKE_NONCOPYABLE(ClearHaltPromiseAdapter);
+
+public:
+    ClearHaltPromiseAdapter(ScriptPromiseResolver* resolver)
+        : PromiseAdapterBase(resolver)
+    {
+    }
+
+    void Run(bool success) const override
+    {
+        if (active()) {
+            if (success)
+                resolve();
+            else
+                reject(DOMException::create(NetworkError, "Unable to clear endpoint."));
+        }
+    }
+};
+
+class GenericTransferInPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::GenericTransferInCallback> {
+    WTF_MAKE_NONCOPYABLE(GenericTransferInPromiseAdapter);
+
+public:
+    GenericTransferInPromiseAdapter(ScriptPromiseResolver* resolver)
+        : PromiseAdapterBase(resolver)
+    {
+    }
+
+    void Run(device::usb::blink::TransferStatus status, mojo::WTFArray<uint8_t> data) const override
+    {
+        if (active()) {
+            DOMException* error = convertFatalTransferStatus(status);
+            if (error)
+                reject(error);
+            else
+                resolve(USBInTransferResult::create(convertTransferStatus(status), data.PassStorage()));
+        }
+    }
+};
+
+class GenericTransferOutPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::GenericTransferOutCallback> {
+    WTF_MAKE_NONCOPYABLE(GenericTransferOutPromiseAdapter);
+
+public:
+    GenericTransferOutPromiseAdapter(ScriptPromiseResolver* resolver, unsigned transferLength)
+        : PromiseAdapterBase(resolver)
+        , m_transferLength(transferLength)
+    {
+    }
+
+    void Run(device::usb::blink::TransferStatus status) const override
+    {
+        if (active()) {
+            DOMException* error = convertFatalTransferStatus(status);
+            if (error)
+                reject(error);
+            else
+                resolve(USBOutTransferResult::create(convertTransferStatus(status), m_transferLength));
+        }
+    }
+
+private:
+    unsigned m_transferLength;
+};
+
+class IsochronousTransferInPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::IsochronousTransferInCallback> {
+    WTF_MAKE_NONCOPYABLE(IsochronousTransferInPromiseAdapter);
+
+public:
+    IsochronousTransferInPromiseAdapter(ScriptPromiseResolver* resolver)
+        : PromiseAdapterBase(resolver)
+    {
+    }
+
+    void Run(mojo::WTFArray<uint8_t> data, mojo::WTFArray<device::usb::blink::IsochronousPacketPtr> mojoPackets) const override
+    {
+        RefPtr<DOMArrayBuffer> buffer = DOMArrayBuffer::create(data.storage().data(), data.storage().size());
+        HeapVector<Member<USBIsochronousInTransferPacket>> packets(mojoPackets.size());
         size_t byteOffset = 0;
-        for (size_t i = 0; i < webTransferInfo->status.size(); ++i) {
-            packets[i] = USBIsochronousInTransferPacket::create(convertTransferStatus(webTransferInfo->status[i]), DOMDataView::create(buffer, byteOffset, webTransferInfo->bytesTransferred[i]));
-            byteOffset += webTransferInfo->packetLength[i];
-        }
-        return USBIsochronousInTransferResult::create(buffer, packets);
-    }
-};
-
-class IsochronousOutputTransferResult {
-    WTF_MAKE_NONCOPYABLE(IsochronousOutputTransferResult);
-
-public:
-    using WebType = OwnPtr<WebUSBTransferInfo>;
-
-    static USBIsochronousOutTransferResult* take(ScriptPromiseResolver*, PassOwnPtr<WebUSBTransferInfo> webTransferInfo)
-    {
-        ASSERT(webTransferInfo->status.size() == webTransferInfo->bytesTransferred.size());
-        HeapVector<Member<USBIsochronousOutTransferPacket>> packets(webTransferInfo->status.size());
-        for (size_t i = 0; i < webTransferInfo->status.size(); ++i)
-            packets[i] = USBIsochronousOutTransferPacket::create(convertTransferStatus(webTransferInfo->status[i]), webTransferInfo->bytesTransferred[i]);
-        return USBIsochronousOutTransferResult::create(packets);
-    }
-};
-
-class BufferSource {
-    WTF_MAKE_NONCOPYABLE(BufferSource);
-public:
-    BufferSource(const ArrayBufferOrArrayBufferView& buffer) : m_buffer(buffer)
-    {
-        ASSERT(!m_buffer.isNull());
-    }
-
-    uint8_t* data() const
-    {
-        if (m_buffer.isArrayBuffer())
-            return static_cast<uint8_t*>(m_buffer.getAsArrayBuffer()->data());
-        return static_cast<uint8_t*>(m_buffer.getAsArrayBufferView()->baseAddress());
-    }
-
-    unsigned size() const
-    {
-        if (m_buffer.isArrayBuffer())
-            return m_buffer.getAsArrayBuffer()->byteLength();
-        return m_buffer.getAsArrayBufferView()->byteLength();
-    }
-
-private:
-    const ArrayBufferOrArrayBufferView& m_buffer;
+        for (size_t i = 0; i < mojoPackets.size(); ++i) {
+            DOMException* error = convertFatalTransferStatus(mojoPackets[i]->status);
+            if (error) {
+                reject(error);
+                return;
+            }
+            packets[i] = USBIsochronousInTransferPacket::create(convertTransferStatus(mojoPackets[i]->status), DOMDataView::create(buffer, byteOffset, mojoPackets[i]->transferred_length));
+            byteOffset += mojoPackets[i]->length;
+        }
+        resolve(USBIsochronousInTransferResult::create(buffer, packets));
+    }
+};
+
+class IsochronousTransferOutPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::IsochronousTransferOutCallback> {
+    WTF_MAKE_NONCOPYABLE(IsochronousTransferOutPromiseAdapter);
+
+public:
+    IsochronousTransferOutPromiseAdapter(ScriptPromiseResolver* resolver)
+        : PromiseAdapterBase(resolver)
+    {
+    }
+
+    void Run(mojo::WTFArray<device::usb::blink::IsochronousPacketPtr> mojoPackets) const override
+    {
+        HeapVector<Member<USBIsochronousOutTransferPacket>> packets(mojoPackets.size());
+        for (size_t i = 0; i < mojoPackets.size(); ++i) {

[esprehn, 2016/04/06 20:10:45]

range loop?

[Reilly Grant (use Gerrit), 2016/04/06 22:30:07]

Done.

+            DOMException* error = convertFatalTransferStatus(mojoPackets[i]->status);
+            if (error) {
+                reject(error);
+                return;
+            }
+            packets[i] = USBIsochronousOutTransferPacket::create(convertTransferStatus(mojoPackets[i]->status), mojoPackets[i]->transferred_length);
+        }
+        resolve(USBIsochronousOutTransferResult::create(packets));
+    }
+};
+
+class ResetPromiseAdapter : public PromiseAdapterBase<device::usb::blink::Device::ResetCallback> {
+    WTF_MAKE_NONCOPYABLE(ResetPromiseAdapter);
+
+public:
+    ResetPromiseAdapter(ScriptPromiseResolver* resolver)
+        : PromiseAdapterBase(resolver)
+    {
+    }
+
+    void Run(bool success) const override
+    {
+        if (active()) {
+            if (success)
+                resolve();
+            else
+                reject(DOMException::create(NetworkError, "Unable to reset the device."));
+        }
+    }
 };
 
 } // namespace
 
-// static
-USBDevice* USBDevice::take(ScriptPromiseResolver* resolver, PassOwnPtr<WebUSBDevice> device)
-{
-    return USBDevice::create(device, resolver->getExecutionContext());
-}
-
-USBDevice::USBDevice(PassOwnPtr<WebUSBDevice> device, ExecutionContext* context)
+USBDevice::USBDevice(device::usb::blink::DeviceInfoPtr deviceInfo, device::usb::blink::DevicePtr device, ExecutionContext* context)
     : ContextLifecycleObserver(context)
     , PageLifecycleObserver(toDocument(context)->page())
-    , m_device(device)
+    , m_deviceInfo(std::move(deviceInfo))
+    , m_device(std::move(device))
     , m_opened(false)
     , m_deviceStateChangeInProgress(false)
     , m_configurationIndex(-1)
-    , m_inEndpoints(15)
-    , m_outEndpoints(15)
 {
-    int configurationIndex = findConfigurationIndex(info().activeConfiguration);
+    if (m_device) {
+        m_device.set_connection_error_handler([this]() {
+            m_device = nullptr;
+            m_opened = false;
+        });
+    }
+    int configurationIndex = findConfigurationIndex(info().active_configuration);
     if (configurationIndex != -1)
         onConfigurationSelected(true /* success */, configurationIndex);
 }
 
+USBDevice::~USBDevice()
+{
+}
+
 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();
+        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;
@@ skipping 47 matching lines @@
 
 ScriptPromise USBDevice::open(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
         if (m_opened) {
             resolver->resolve();
         } else {
             m_deviceStateChangeInProgress = true;
-            m_device->open(new OpenClosePromiseAdapter(this, resolver, true /* open */));
+            auto adapter = new OpenPromiseAdapter(this, resolver);
+            m_device->Open(adapter->callback());
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::close(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
         if (!m_opened) {
             resolver->resolve();
         } else {
             m_deviceStateChangeInProgress = true;
-            m_device->close(new OpenClosePromiseAdapter(this, resolver, false /* closed */));
+            auto adapter = new ClosePromiseAdapter(this, resolver);
+            m_device->Close(adapter->callback());
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::selectConfiguration(ScriptState* scriptState, uint8_t configurationValue)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
         if (!m_opened) {
             resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
         } 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();
             } else {
                 m_deviceStateChangeInProgress = true;
-                m_device->setConfiguration(configurationValue, new SelectConfigurationPromiseAdapter(this, resolver, configurationIndex));
+                auto adapter = new SelectConfigurationPromiseAdapter(this, resolver, configurationIndex);
+                m_device->SetConfiguration(configurationValue, adapter->callback());
             }
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::claimInterface(ScriptState* scriptState, uint8_t interfaceNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     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 */));
+            auto adapter = new ClaimInterfacePromiseAdapter(this, resolver, interfaceIndex);
+            m_device->ClaimInterface(interfaceNumber, adapter->callback());
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::releaseInterface(ScriptState* scriptState, uint8_t interfaceNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     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 */));
+            auto adapter = new ReleaseInterfacePromiseAdapter(this, resolver, interfaceIndex);
+            m_device->ReleaseInterface(interfaceNumber, adapter->callback());
         }
     }
     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));
+            auto adapter = new SetInterfacePromiseAdapter(this, resolver, interfaceIndex, alternateIndex);
+            m_device->SetInterfaceAlternateSetting(interfaceNumber, alternateSetting, adapter->callback());
         }
     }
     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;
-        if (convertControlTransferParameters(WebUSBDevice::TransferDirection::In, setup, &parameters, resolver))
-            m_device->controlTransfer(parameters, nullptr, length, 0, new CallbackPromiseAdapter<InputTransferResult, USBError>(resolver));
+        auto parameters = convertControlTransferParameters(setup, resolver);
+        if (parameters) {
+            auto adapter = new ControlTransferInPromiseAdapter(resolver);
+            m_device->ControlTransferIn(std::move(parameters), length, 0, adapter->callback());
+        }
     }
     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;
-        if (convertControlTransferParameters(WebUSBDevice::TransferDirection::Out, setup, &parameters, resolver))
-            m_device->controlTransfer(parameters, nullptr, 0, 0, new CallbackPromiseAdapter<OutputTransferResult, USBError>(resolver));
+        auto parameters = convertControlTransferParameters(setup, resolver);
+        if (parameters) {
+            auto adapter = new ControlTransferOutPromiseAdapter(resolver, 0);
+            m_device->ControlTransferOut(std::move(parameters), mojo::WTFArray<uint8_t>(), 0, adapter->callback());
+        }
     }
     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;
-        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));
+        auto parameters = convertControlTransferParameters(setup, resolver);
+        if (parameters) {
+            mojo::WTFArray<uint8_t> buffer = convertBufferSource(data);
+            auto adapter = new ControlTransferOutPromiseAdapter(resolver, buffer.size());
+            m_device->ControlTransferOut(std::move(parameters), std::move(buffer), 0, adapter->callback());
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::clearHalt(ScriptState* scriptState, String direction, uint8_t endpointNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureEndpointAvailable(direction == "in", endpointNumber, resolver))
-        m_device->clearHalt(endpointNumber, new CallbackPromiseAdapter<void, USBError>(resolver));
+    if (ensureEndpointAvailable(direction == "in", endpointNumber, resolver)) {
+        auto adapter = new ClearHaltPromiseAdapter(resolver);
+        m_device->ClearHalt(endpointNumber, adapter->callback());
+    }
     return promise;
 }
 
 ScriptPromise USBDevice::transferIn(ScriptState* scriptState, uint8_t endpointNumber, unsigned length)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver))
-        m_device->transfer(WebUSBDevice::TransferDirection::In, endpointNumber, nullptr, length, 0, new CallbackPromiseAdapter<InputTransferResult, USBError>(resolver));
+    if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver)) {
+        auto adapter = new GenericTransferInPromiseAdapter(resolver);
+        m_device->GenericTransferIn(endpointNumber, length, 0, adapter->callback());
+    }
     return promise;
 }
 
 ScriptPromise USBDevice::transferOut(ScriptState* scriptState, uint8_t endpointNumber, const ArrayBufferOrArrayBufferView& data)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     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));
+        mojo::WTFArray<uint8_t> buffer = convertBufferSource(data);
+        auto adapter = new GenericTransferOutPromiseAdapter(resolver, buffer.size());
+        m_device->GenericTransferOut(endpointNumber, std::move(buffer), 0, adapter->callback());
     }
     return promise;
 }
 
 ScriptPromise USBDevice::isochronousTransferIn(ScriptState* scriptState, uint8_t endpointNumber, Vector<unsigned> packetLengths)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver))
-        m_device->isochronousTransfer(WebUSBDevice::TransferDirection::In, endpointNumber, nullptr, 0, packetLengths, 0, new CallbackPromiseAdapter<IsochronousInputTransferResult, USBError>(resolver));
+    if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver)) {
+        auto adapter = new IsochronousTransferInPromiseAdapter(resolver);
+        m_device->IsochronousTransferIn(endpointNumber, mojo::WTFArray<uint32_t>(std::move(packetLengths)), 0, adapter->callback());
+    }
     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 (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));
+        auto adapter = new IsochronousTransferOutPromiseAdapter(resolver);
+        m_device->IsochronousTransferOut(endpointNumber, convertBufferSource(data), mojo::WTFArray<uint32_t>(std::move(packetLengths)), 0, adapter->callback());
     }
     return promise;
 }
 
 ScriptPromise USBDevice::reset(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
-        if (!m_opened)
+        if (!m_opened) {
             resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
-        else
-            m_device->reset(new CallbackPromiseAdapter<void, USBError>(resolver));
+        } else {
+            auto adapter = new ResetPromiseAdapter(resolver);
+            m_device->Reset(adapter->callback());
+        }
     }
     return promise;
 }
 
 void USBDevice::contextDestroyed()
 {
-    if (m_opened) {
-        m_device->close(new WebUSBDeviceCloseCallbacks());
-        m_opened = false;
-    }
+    m_device.reset();
 }
 
 void USBDevice::pageVisibilityChanged()
 {
     if (!page()->isPageVisible() && m_opened) {
-        m_device->close(new WebUSBDeviceCloseCallbacks());
+        m_device->Close(device::usb::blink::Device::CloseCallback());
         m_opened = false;
     }
 }
 
 DEFINE_TRACE(USBDevice)
 {
     ContextLifecycleObserver::trace(visitor);
     PageLifecycleObserver::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)
+        if (configurations[i]->configuration_value == configurationValue)
             return i;
     }
     return -1;
 }
 
 int USBDevice::findInterfaceIndex(uint8_t interfaceNumber) const
 {
     ASSERT(m_configurationIndex != -1);
-    const auto& interfaces = info().configurations[m_configurationIndex].interfaces;
+    const auto& interfaces = info().configurations[m_configurationIndex]->interfaces;
     for (size_t i = 0; i < interfaces.size(); ++i) {
-        if (interfaces[i].interfaceNumber == interfaceNumber)
+        if (interfaces[i]->interface_number == 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;
+    const auto& alternates = info().configurations[m_configurationIndex]->interfaces[interfaceIndex]->alternates;
     for (size_t i = 0; i < alternates.size(); ++i) {
-        if (alternates[i].alternateSetting == alternateSetting)
+        if (alternates[i]->alternate_setting == alternateSetting)
             return i;
     }
     return -1;
 }
 
 bool USBDevice::ensurePageVisible(ScriptPromiseResolver* resolver) const
 {
     if (!page()->isPageVisible()) {
         resolver->reject(DOMException::create(SecurityError, kVisibiltyError));
         return false;
     }
     return true;
 }
 
 bool USBDevice::ensureNoDeviceOrInterfaceChangeInProgress(ScriptPromiseResolver* resolver) const
 {
     if (!ensurePageVisible(resolver))
         return false;
-    if (m_deviceStateChangeInProgress)
+    if (!m_device)
+        resolver->reject(DOMException::create(NotFoundError, kDeviceUnavailable));
+    else 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 (!ensurePageVisible(resolver))
         return false;
-    if (m_deviceStateChangeInProgress)
+    if (!m_device)
+        resolver->reject(DOMException::create(NotFoundError, kDeviceUnavailable));
+    else if (m_deviceStateChangeInProgress)
         resolver->reject(DOMException::create(InvalidStateError, kDeviceStateChangeInProgress));
     else if (!m_opened)
         resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
     else if (m_configurationIndex == -1)
         resolver->reject(DOMException::create(InvalidStateError, "The device must have a configuration selected."));
     else
         return true;
     return false;
 }
 
@@ skipping 31 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;
 }
 
-bool USBDevice::convertControlTransferParameters(
-    WebUSBDevice::TransferDirection direction,
+device::usb::blink::ControlTransferParamsPtr USBDevice::convertControlTransferParameters(
     const USBControlTransferParameters& parameters,
-    WebUSBDevice::ControlTransferParameters* webParameters,
     ScriptPromiseResolver* resolver) const
 {
-    webParameters->direction = direction;
+    auto mojoParameters = device::usb::blink::ControlTransferParams::New();
 
     if (parameters.requestType() == "standard") {
-        webParameters->type = WebUSBDevice::RequestType::Standard;
+        mojoParameters->type = device::usb::blink::ControlTransferType::STANDARD;
     } else if (parameters.requestType() == "class") {
-        webParameters->type = WebUSBDevice::RequestType::Class;
+        mojoParameters->type = device::usb::blink::ControlTransferType::CLASS;
     } else if (parameters.requestType() == "vendor") {
-        webParameters->type = WebUSBDevice::RequestType::Vendor;
+        mojoParameters->type = device::usb::blink::ControlTransferType::VENDOR;
     } else {
         resolver->reject(DOMException::create(TypeMismatchError, "The control transfer requestType parameter is invalid."));
-        return false;
+        return nullptr;
     }
 
     if (parameters.recipient() == "device") {
-        webParameters->recipient = WebUSBDevice::RequestRecipient::Device;
+        mojoParameters->recipient = device::usb::blink::ControlTransferRecipient::DEVICE;
     } else if (parameters.recipient() == "interface") {
         size_t interfaceNumber = parameters.index() & 0xff;
         if (!ensureInterfaceClaimed(interfaceNumber, resolver))
-            return false;
-        webParameters->recipient = WebUSBDevice::RequestRecipient::Interface;
+            return nullptr;
+        mojoParameters->recipient = device::usb::blink::ControlTransferRecipient::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;
+            return nullptr;
+        mojoParameters->recipient = device::usb::blink::ControlTransferRecipient::ENDPOINT;
     } else if (parameters.recipient() == "other") {
-        webParameters->recipient = WebUSBDevice::RequestRecipient::Other;
+        mojoParameters->recipient = device::usb::blink::ControlTransferRecipient::OTHER;
     } else {
         resolver->reject(DOMException::create(TypeMismatchError, "The control transfer recipient parameter is invalid."));
-        return false;
+        return nullptr;
     }
 
-    webParameters->request = parameters.request();
-    webParameters->value = parameters.value();
-    webParameters->index = parameters.index();
-    return true;
+    mojoParameters->request = parameters.request();
+    mojoParameters->value = parameters.value();
+    mojoParameters->index = parameters.index();
+    return mojoParameters;
 }
 
 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)
+    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.storage()) {
+        uint8_t endpointNumber = endpoint->endpoint_number;
+        if (endpointNumber == 0 || endpointNumber >= 16)
             continue; // Ignore endpoints with invalid indices.
-        auto& bitVector = endpoint.direction == WebUSBDevice::TransferDirection::In ? m_inEndpoints : m_outEndpoints;
+        auto& bitVector = endpoint->direction == device::usb::blink::TransferDirection::INBOUND ? m_inEndpoints : m_outEndpoints;
         if (set)
-            bitVector.set(endpoint.endpointNumber - 1);
+            bitVector.set(endpointNumber - 1);
         else
-            bitVector.clear(endpoint.endpointNumber - 1);
+            bitVector.clear(endpointNumber - 1);
     }
 }
 
 } // namespace blink