wasm: add native QByteArray conversion functions

Add functions which converts to and from JavaScript
data arrays:

  static QByteArray::fromUint8Array(emscripten::val array)
  emscripten::val QByteArray::toUint8Array() const

with corresponding internal qstdweb API:

  static Uint8Array Uint8Array::copyFrom(const QByteArray &buffer)
  QByteArray Uint8Array::copyToQByteArray() const

Both functions will make a copy of the data, i.e. there
is no shared reference counting. They take and return
Uint8Array typed array views, via emscripten::val JavaScript
object references.

Unlike other native conversion functions, these have
the special property that the data referenced by the
native Uint8Array exists outside the heap memory area.

This means we can’t e.g. memcpy the data. However, the
heap is itself a JavaScript ArrayBuffer, and we can
create a Uint8Array view to the buffer owned by the
QByteArray, and then use JavaScript API to copy. See
the qstdweb::Uint8Array::copy() implementation.

That also means that a fromRawUint8Array() variant
(which does not copy) is not possible to implement,
since we can’t create a pointer to the source data.

The inverse toRawUint8Array() is implementable - it
would return a Uint8Array view which references the
heap’s ArrayBuffer. However, this may turn out to be
ill-advised, since Emscripten will create a new ArrayBuffer
if/when it resizes the heap. In any case this left for
a future expansion.

Change-Id: Icaf48fd17ea8686bf04cb523cc1eb581ce63ed34
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>

2 files changed, 21 insertions, 0 deletions

diff --git a/src/corelib/platform/wasm/qstdweb.cpp b/src/corelib/platform/wasm/qstdweb.cpp
index 363a21ee8d..69ed8fe34f 100644
--- a/src/corelib/platform/wasm/qstdweb.cpp
+++ b/src/corelib/platform/wasm/qstdweb.cpp
@@ -573,6 +573,18 @@ void Uint8Array::copyTo(char *destination) const
     Uint8Array(destination, length()).set(*this);
 }
 
+// Copies the Uint8Array content to a destination QByteArray
+QByteArray Uint8Array::copyToQByteArray() const
+{
+    if (length() > std::numeric_limits<qsizetype>::max())
+        return QByteArray();
+
+    QByteArray destinationArray;
+    destinationArray.resize(length());
+    copyTo(destinationArray.data());
+    return destinationArray;
+}
+
 // Copies the Uint8Array content to a destination on the heap
 void Uint8Array::copy(char *destination, const Uint8Array &source)
 {
@@ -587,6 +599,12 @@ Uint8Array Uint8Array::copyFrom(const char *buffer, uint32_t size)
     return contentCopy;
 }
 
+// Copies content from a QByteArray to a new Uint8Array object
+Uint8Array Uint8Array::copyFrom(const QByteArray &buffer)
+{
+    return copyFrom(buffer.constData(), buffer.size());
+}
+
 emscripten::val Uint8Array::val()
 {
     return m_uint8Array;
diff --git a/src/corelib/platform/wasm/qstdweb_p.h b/src/corelib/platform/wasm/qstdweb_p.h
index badca5d402..b3fc8a95f7 100644
--- a/src/corelib/platform/wasm/qstdweb_p.h
+++ b/src/corelib/platform/wasm/qstdweb_p.h
@@ -128,8 +128,11 @@ namespace qstdweb {
         void set(const Uint8Array &source);
 
         void copyTo(char *destination) const;
+        QByteArray copyToQByteArray() const;
+
         static void copy(char *destination, const Uint8Array &source);
         static Uint8Array copyFrom(const char *buffer, uint32_t size);
+        static Uint8Array copyFrom(const QByteArray &buffer);
         emscripten::val val();
 
     private: