Mojo C++ binding: make device/usb mojom targets use STD string/vector types

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/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ToV8.h"
 #include "core/dom/DOMArrayBuffer.h"
@@ skipping 54 matching lines @@
     case usb::TransferStatus::STALLED:
         return "stall";
     case usb::TransferStatus::BABBLE:
         return "babble";
     default:
         ASSERT_NOT_REACHED();
         return "";
     }
 }
 
-mojo::WTFArray<uint8_t> convertBufferSource(const ArrayBufferOrArrayBufferView& buffer)
+Vector<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));
+    return vector;
 }
 
 } // namespace
 
 USBDevice::USBDevice(usb::DeviceInfoPtr deviceInfo, usb::DevicePtr device, ExecutionContext* context)
     : ContextLifecycleObserver(context)
     , m_deviceInfo(std::move(deviceInfo))
     , m_device(std::move(device))
     , m_opened(false)
     , m_deviceStateChangeInProgress(false)
@@ skipping 177 matching lines @@
 }
 
 ScriptPromise USBDevice::controlTransferOut(ScriptState* scriptState, const USBControlTransferParameters& setup)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureDeviceConfigured(resolver)) {
         auto parameters = convertControlTransferParameters(setup, resolver);
         if (parameters) {
             m_deviceRequests.add(resolver);
-            m_device->ControlTransferOut(std::move(parameters), mojo::WTFArray<uint8_t>(), 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncControlTransferOut, wrapPersistent(this), 0, wrapPersistent(resolver))));
+            m_device->ControlTransferOut(std::move(parameters), Vector<uint8_t>(), 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncControlTransferOut, wrapPersistent(this), 0, wrapPersistent(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)) {
         auto parameters = convertControlTransferParameters(setup, resolver);
         if (parameters) {
-            mojo::WTFArray<uint8_t> buffer = convertBufferSource(data);
+            Vector<uint8_t> buffer = convertBufferSource(data);
             unsigned transferLength = buffer.size();
             m_deviceRequests.add(resolver);
-            m_device->ControlTransferOut(std::move(parameters), std::move(buffer), 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncControlTransferOut, wrapPersistent(this), transferLength, wrapPersistent(resolver))));
+            m_device->ControlTransferOut(std::move(parameters), buffer, 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncControlTransferOut, wrapPersistent(this), transferLength, wrapPersistent(resolver))));
         }
     }
     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)) {
@@ skipping 12 matching lines @@
         m_device->GenericTransferIn(endpointNumber, length, 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncTransferIn, wrapPersistent(this), wrapPersistent(resolver))));
     }
     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)) {
-        mojo::WTFArray<uint8_t> buffer = convertBufferSource(data);
+        Vector<uint8_t> buffer = convertBufferSource(data);
         unsigned transferLength = buffer.size();
         m_deviceRequests.add(resolver);
-        m_device->GenericTransferOut(endpointNumber, std::move(buffer), 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncTransferOut, wrapPersistent(this), transferLength, wrapPersistent(resolver))));
+        m_device->GenericTransferOut(endpointNumber, buffer, 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncTransferOut, wrapPersistent(this), transferLength, wrapPersistent(resolver))));
     }
     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_deviceRequests.add(resolver);
-        m_device->IsochronousTransferIn(endpointNumber, mojo::WTFArray<uint32_t>(std::move(packetLengths)), 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncIsochronousTransferIn, wrapPersistent(this), wrapPersistent(resolver))));
+        m_device->IsochronousTransferIn(endpointNumber, packetLengths, 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncIsochronousTransferIn, wrapPersistent(this), wrapPersistent(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 (ensureEndpointAvailable(false /* out */, endpointNumber, resolver)) {
         m_deviceRequests.add(resolver);
-        m_device->IsochronousTransferOut(endpointNumber, convertBufferSource(data), mojo::WTFArray<uint32_t>(std::move(packetLengths)), 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncIsochronousTransferOut, wrapPersistent(this), wrapPersistent(resolver))));
+        m_device->IsochronousTransferOut(endpointNumber, convertBufferSource(data), packetLengths, 0, convertToBaseCallback(WTF::bind(&USBDevice::asyncIsochronousTransferOut, wrapPersistent(this), wrapPersistent(resolver))));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::reset(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
         if (!m_opened) {
@@ skipping 160 matching lines @@
     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.storage()) {
+    for (const auto& endpoint : alternate.endpoints) {
         uint8_t endpointNumber = endpoint->endpoint_number;
         if (endpointNumber == 0 || endpointNumber >= 16)
             continue; // Ignore endpoints with invalid indices.
         auto& bitVector = endpoint->direction == usb::TransferDirection::INBOUND ? m_inEndpoints : m_outEndpoints;
         if (set)
             bitVector.set(endpointNumber - 1);
         else
             bitVector.clear(endpointNumber - 1);
     }
 }
@@ skipping 107 matching lines @@
         m_selectedAlternates[interfaceIndex] = alternateIndex;
     setEndpointsForInterface(interfaceIndex, success);
     m_interfaceStateChangeInProgress.clear(interfaceIndex);
 
     if (success)
         resolver->resolve();
     else
         resolver->reject(DOMException::create(NetworkError, "Unable to set device interface."));
 }
 
-void USBDevice::asyncControlTransferIn(ScriptPromiseResolver* resolver, usb::TransferStatus status, mojo::WTFArray<uint8_t> data)
+void USBDevice::asyncControlTransferIn(ScriptPromiseResolver* resolver, usb::TransferStatus status, const Optional<Vector<uint8_t>>& data)
 {
     if (!markRequestComplete(resolver))
         return;
 
     DOMException* error = convertFatalTransferStatus(status);
     if (error)
         resolver->reject(error);
     else
-        resolver->resolve(USBInTransferResult::create(convertTransferStatus(status), data.PassStorage()));
+        resolver->resolve(USBInTransferResult::create(convertTransferStatus(status), data));
 }
 
 void USBDevice::asyncControlTransferOut(unsigned transferLength, ScriptPromiseResolver* resolver, usb::TransferStatus status)
 {
     if (!markRequestComplete(resolver))
         return;
 
     DOMException* error = convertFatalTransferStatus(status);
     if (error)
         resolver->reject(error);
     else
         resolver->resolve(USBOutTransferResult::create(convertTransferStatus(status), transferLength));
 }
 
 void USBDevice::asyncClearHalt(ScriptPromiseResolver* resolver, bool success)
 {
     if (!markRequestComplete(resolver))
         return;
 
     if (success)
         resolver->resolve();
     else
         resolver->reject(DOMException::create(NetworkError, "Unable to clear endpoint."));
 }
 
-void USBDevice::asyncTransferIn(ScriptPromiseResolver* resolver, usb::TransferStatus status, mojo::WTFArray<uint8_t> data)
+void USBDevice::asyncTransferIn(ScriptPromiseResolver* resolver, usb::TransferStatus status, const Optional<Vector<uint8_t>>& data)
 {
     if (!markRequestComplete(resolver))
         return;
 
     DOMException* error = convertFatalTransferStatus(status);
     if (error)
         resolver->reject(error);
     else
-        resolver->resolve(USBInTransferResult::create(convertTransferStatus(status), data.PassStorage()));
+        resolver->resolve(USBInTransferResult::create(convertTransferStatus(status), data));
 }
 
 void USBDevice::asyncTransferOut(unsigned transferLength, ScriptPromiseResolver* resolver, usb::TransferStatus status)
 {
     if (!markRequestComplete(resolver))
         return;
 
     DOMException* error = convertFatalTransferStatus(status);
     if (error)
         resolver->reject(error);
     else
         resolver->resolve(USBOutTransferResult::create(convertTransferStatus(status), transferLength));
 }
 
-void USBDevice::asyncIsochronousTransferIn(ScriptPromiseResolver* resolver, mojo::WTFArray<uint8_t> data, mojo::WTFArray<usb::IsochronousPacketPtr> mojoPackets)
+void USBDevice::asyncIsochronousTransferIn(ScriptPromiseResolver* resolver, const Optional<Vector<uint8_t>>& data, Vector<usb::IsochronousPacketPtr> mojoPackets)
 {
     if (!markRequestComplete(resolver))
         return;
 
-    DOMArrayBuffer* buffer = DOMArrayBuffer::create(data.storage().data(), data.storage().size());
+    DOMArrayBuffer* buffer = data ? DOMArrayBuffer::create(data->data(), data->size()) : nullptr;
     HeapVector<Member<USBIsochronousInTransferPacket>> packets;
     packets.reserveCapacity(mojoPackets.size());
     size_t byteOffset = 0;
-    for (const auto& packet : mojoPackets.storage()) {
+    for (const auto& packet : mojoPackets) {
         DOMException* error = convertFatalTransferStatus(packet->status);
         if (error) {
             resolver->reject(error);
             return;
         }
-        packets.append(USBIsochronousInTransferPacket::create(convertTransferStatus(packet->status), DOMDataView::create(buffer, byteOffset, packet->transferred_length)));
+        packets.append(USBIsochronousInTransferPacket::create(convertTransferStatus(packet->status), buffer ? DOMDataView::create(buffer, byteOffset, packet->transferred_length) : nullptr));
         byteOffset += packet->length;
     }
     resolver->resolve(USBIsochronousInTransferResult::create(buffer, packets));
 }
 
-void USBDevice::asyncIsochronousTransferOut(ScriptPromiseResolver* resolver, mojo::WTFArray<usb::IsochronousPacketPtr> mojoPackets)
+void USBDevice::asyncIsochronousTransferOut(ScriptPromiseResolver* resolver, Vector<usb::IsochronousPacketPtr> mojoPackets)
 {
     if (!markRequestComplete(resolver))
         return;
 
     HeapVector<Member<USBIsochronousOutTransferPacket>> packets;
     packets.reserveCapacity(mojoPackets.size());
-    for (const auto& packet : mojoPackets.storage()) {
+    for (const auto& packet : mojoPackets) {
         DOMException* error = convertFatalTransferStatus(packet->status);
         if (error) {
             resolver->reject(error);
             return;
         }
         packets.append(USBIsochronousOutTransferPacket::create(convertTransferStatus(packet->status), packet->transferred_length));
     }
     resolver->resolve(USBIsochronousOutTransferResult::create(packets));
 }
 
@@ skipping 20 matching lines @@
 bool USBDevice::markRequestComplete(ScriptPromiseResolver* resolver)
 {
     auto requestEntry = m_deviceRequests.find(resolver);
     if (requestEntry == m_deviceRequests.end())
         return false;
     m_deviceRequests.remove(requestEntry);
     return true;
 }
 
 } // namespace blink