Add support for isochronous transfers in WebUSB.

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 {
 
 DOMException* convertControlTransferParameters(
     WebUSBDevice::TransferDirection direction,
     const USBControlTransferParameters& parameters,
     WebUSBDevice::ControlTransferParameters* webParameters)
 {
@@ skipping 63 matching lines @@
     Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 class InputTransferResult {
     WTF_MAKE_NONCOPYABLE(InputTransferResult);
 public:
     using WebType = OwnPtr<WebUSBTransferInfo>;
 
     static USBInTransferResult* take(ScriptPromiseResolver*, PassOwnPtr<WebUSBTransferInfo> webTransferInfo)
     {
-        return USBInTransferResult::create(convertTransferStatus(webTransferInfo->status), webTransferInfo->data);
+        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)
     {
-        return USBOutTransferResult::create(convertTransferStatus(webTransferInfo->status), webTransferInfo->bytesWritten);
+        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());
+        size_t byteOffset = 0;
+        for (size_t i = 0; i < webTransferInfo->status.size(); ++i) {
+            packets.append(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.append(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
     {
@@ skipping 140 matching lines @@
 
 ScriptPromise USBDevice::transferOut(ScriptState* scriptState, uint8_t endpointNumber, const ArrayBufferOrArrayBufferView& data)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     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();
+    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();
+    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();
     m_device->reset(new CallbackPromiseAdapter<void, USBError>(resolver));
     return promise;
 }
 
 void USBDevice::contextDestroyed()
 {
     m_device->close(new WebUSBDeviceCloseCallbacks());
 }
 
 DEFINE_TRACE(USBDevice)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink