wasm: add qstdweb private API

qstdweb provides a C++ API covering parts of the DOM API
useful for implementing Qt. This currently includes
ArrayBuffer, Blob, File, FileReader, and Uint8Array.

The implementation uses emscripten::val, which currently
proxies via JavaScript, but should at some point be
able to acccess the DOM directly, once WebAssembly
gains such access.

This API should be easier to use than the string-and-casting
emscripten::val API. It is currently private, and can
be changed and extended as needed.

Change-Id: I95a2ad735e511c8da61f3cc21357fbffe3b05d8e
Reviewed-by: Lorn Potter <lorn.potter@gmail.com>

5 files changed, 410 insertions, 0 deletions

diff --git a/src/corelib/corelib.pro b/src/corelib/corelib.pro
index 181780c475..4b758532e6 100644
--- a/src/corelib/corelib.pro
+++ b/src/corelib/corelib.pro
@@ -44,6 +44,7 @@ include(codecs/codecs.pri)
 include(serialization/serialization.pri)
 include(statemachine/statemachine.pri)
 include(mimetypes/mimetypes.pri)
+include(platform/platform.pri)
 
 win32 {
     LIBS_PRIVATE += -lws2_32
diff --git a/src/corelib/platform/platform.pri b/src/corelib/platform/platform.pri
new file mode 100644
index 0000000000..1fe2db81b0
--- /dev/null
+++ b/src/corelib/platform/platform.pri
@@ -0,0 +1 @@
+wasm:include(wasm/wasm.pri)
diff --git a/src/corelib/platform/wasm/qstdweb.cpp b/src/corelib/platform/wasm/qstdweb.cpp
new file mode 100644
index 0000000000..1afd91d860
--- /dev/null
+++ b/src/corelib/platform/wasm/qstdweb.cpp
@@ -0,0 +1,236 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qstdweb_p.h"
+
+#include <emscripten/bind.h>
+#include <cstdint>
+#include <iostream>
+
+QT_BEGIN_NAMESPACE
+
+namespace qstdweb {
+
+typedef double uint53_t; // see Number.MAX_SAFE_INTEGER
+
+ArrayBuffer::ArrayBuffer(const emscripten::val &arrayBuffer)
+    :m_arrayBuffer(arrayBuffer)
+{
+
+}
+
+uint32_t ArrayBuffer::byteLength() const
+{
+    if (m_arrayBuffer.isUndefined() || m_arrayBuffer.isNull())
+        return 0;
+
+    return m_arrayBuffer["byteLength"].as<uint32_t>();
+}
+
+Blob::Blob(const emscripten::val &blob)
+    :m_blob(blob)
+{
+
+}
+
+uint32_t Blob::size() const
+{
+    return m_blob["size"].as<uint32_t>();
+}
+
+File::File(const emscripten::val &file)
+:m_file(file)
+{
+
+}
+
+Blob File::slice(uint64_t begin, uint64_t end) const
+{
+    return Blob(m_file.call<emscripten::val>("slice", uint53_t(begin), uint53_t(end)));
+}
+
+std::string File::name() const
+{
+    return m_file["name"].as<std::string>();
+}
+
+uint64_t File::size() const
+{
+    return uint64_t(m_file["size"].as<uint53_t>());
+}
+
+FileList::FileList(const emscripten::val &fileList)
+    :m_fileList(fileList)
+{
+
+}
+
+int FileList::length() const
+{
+    return m_fileList["length"].as<int>();
+}
+
+File FileList::item(int index) const
+{
+    return File(m_fileList[index]);
+}
+
+File FileList::operator[](int index) const
+{
+    return item(index);
+}
+
+ArrayBuffer FileReader::result() const
+{
+    return ArrayBuffer(m_fileReader["result"]);
+}
+
+void FileReader::readAsArrayBuffer(const Blob &blob) const
+{
+    m_fileReader.call<void>("readAsArrayBuffer", blob.m_blob);
+}
+
+void FileReader::onLoad(const std::function<void ()> &onLoad)
+{
+    m_onLoad.reset(new EventCallback(m_fileReader, "load", onLoad));
+}
+
+void FileReader::onError(const std::function<void ()> &onError)
+{
+    m_onError.reset(new EventCallback(m_fileReader, "error", onError));
+}
+
+void FileReader::onAbort(const std::function<void ()> &onAbort)
+{
+    m_onAbort.reset(new EventCallback(m_fileReader, "abort", onAbort));
+}
+
+Uint8Array Uint8Array::heap()
+{
+    return Uint8Array(heap_());
+}
+
+Uint8Array::Uint8Array(const emscripten::val &uint8Array)
+: m_uint8Array(uint8Array)
+{
+
+}
+
+Uint8Array::Uint8Array(const ArrayBuffer &buffer)
+: m_uint8Array(Uint8Array::constructor_().new_(buffer.m_arrayBuffer))
+{
+
+}
+
+Uint8Array::Uint8Array(const ArrayBuffer &buffer, uint32_t offset, uint32_t length)
+: m_uint8Array(Uint8Array::constructor_().new_(buffer.m_arrayBuffer, offset, length))
+{
+
+}
+
+Uint8Array::Uint8Array(char *buffer, uint32_t size)
+:m_uint8Array(Uint8Array::constructor_().new_(Uint8Array::heap().buffer().m_arrayBuffer, uint32_t(buffer), size))
+{
+
+}
+
+ArrayBuffer Uint8Array::buffer() const
+{
+    return ArrayBuffer(m_uint8Array["buffer"]);
+}
+
+uint32_t Uint8Array::length() const
+{
+    return m_uint8Array["length"].as<uint32_t>();
+}
+
+void Uint8Array::set(const Uint8Array &source)
+{
+    m_uint8Array.call<void>("set", source.m_uint8Array); // copies source content
+}
+
+void Uint8Array::copyTo(char *destination) const
+{
+    Uint8Array(destination, length()).set(*this);
+}
+
+void Uint8Array::copy(char *destination, const Uint8Array &source)
+{
+    Uint8Array(destination, source.length()).set(source);
+}
+
+emscripten::val Uint8Array::heap_()
+{
+    return emscripten::val::module_property("HEAPU8");
+}
+
+emscripten::val Uint8Array::constructor_()
+{
+    return emscripten::val::global("Uint8Array");
+}
+
+// Registers a callback function for a named event on the given element. The event
+// name must be the name as returned by the Event.type property: e.g. "load", "error".
+EventCallback::EventCallback(emscripten::val element, const std::string &name, const std::function<void ()> &fn)
+:m_fn(fn)
+{
+    element.set(contextPropertyName(name).c_str(), emscripten::val(intptr_t(this)));
+    element.set((std::string("on") + name).c_str(), emscripten::val::module_property("qtStdWebEventCallbackActivate"));
+}
+
+void EventCallback::activate(emscripten::val event)
+{
+    emscripten::val target = event["target"];
+    std::string eventName = event["type"].as<std::string>();
+    EventCallback *that = reinterpret_cast<EventCallback *>(target[contextPropertyName(eventName).c_str()].as<intptr_t>());
+    that->m_fn();
+}
+
+std::string EventCallback::contextPropertyName(const std::string &eventName)
+{
+    return std::string("data-qtEventCallbackContext") + eventName;
+}
+
+EMSCRIPTEN_BINDINGS(QtStdwebCalback) {
+    emscripten::function("qtStdWebEventCallbackActivate", &EventCallback::activate);
+}
+
+} // namespace qstdweb
+
+QT_END_NAMESPACE
diff --git a/src/corelib/platform/wasm/qstdweb_p.h b/src/corelib/platform/wasm/qstdweb_p.h
new file mode 100644
index 0000000000..75c2ec34b1
--- /dev/null
+++ b/src/corelib/platform/wasm/qstdweb_p.h
@@ -0,0 +1,169 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTDWEB_P_H
+#define QSTDWEB_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qglobal.h>
+#include <emscripten/val.h>
+#include <cstdint>
+#include <functional>
+
+QT_BEGIN_NAMESPACE
+
+namespace qstdweb {
+
+    // DOM API in C++, implemented using emscripten val.h and bind.h.
+    // This is private API and can be extened and changed as needed.
+
+    class ArrayBuffer;
+    class Blob;
+    class File;
+    class FileList;
+    class FileReader;
+    class Uint8Array;
+    class EventCallback;
+
+    class ArrayBuffer {
+    public:
+        explicit ArrayBuffer(const emscripten::val &arrayBuffer);
+        uint32_t byteLength() const;
+
+    private:
+        friend class Uint8Array;
+        emscripten::val m_arrayBuffer = emscripten::val::undefined();
+    };
+
+    class Blob {
+    public:
+        explicit Blob(const emscripten::val &blob);
+        uint32_t size() const;
+
+    private:
+        friend class FileReader;
+        emscripten::val m_blob = emscripten::val::undefined();
+    };
+
+    class File {
+    public:
+        File() = default;
+        explicit File(const emscripten::val &file);
+
+        Blob slice(uint64_t begin, uint64_t end) const;
+        std::string name() const;
+        uint64_t size() const;
+
+    private:
+        emscripten::val m_file = emscripten::val::undefined();
+    };
+
+    class FileList {
+    public:
+        FileList() = default;
+        explicit FileList(const emscripten::val &fileList);
+
+        int length() const;
+        File item(int index) const;
+        File operator[](int index) const;
+
+    private:
+        emscripten::val m_fileList = emscripten::val::undefined();
+    };
+
+    class FileReader {
+    public:
+        ArrayBuffer result() const;
+        void readAsArrayBuffer(const Blob &blob) const;
+
+        void onLoad(const std::function<void ()> &onLoad);
+        void onError(const std::function<void ()> &onError);
+        void onAbort(const std::function<void ()> &onAbort);
+
+    private:
+        emscripten::val m_fileReader = emscripten::val::global("FileReader").new_();
+        std::unique_ptr<EventCallback> m_onLoad;
+        std::unique_ptr<EventCallback> m_onError;
+        std::unique_ptr<EventCallback> m_onAbort;
+    };
+
+    class Uint8Array {
+    public:
+        static Uint8Array heap();
+        explicit Uint8Array(const emscripten::val &uint8Array);
+        explicit Uint8Array(const ArrayBuffer &buffer);
+        Uint8Array(const ArrayBuffer &buffer, uint32_t offset, uint32_t length);
+        Uint8Array(char *buffer, uint32_t size);
+
+        ArrayBuffer buffer() const;
+        uint32_t length() const;
+        void set(const Uint8Array &source);
+
+        void copyTo(char *destination) const;
+        static void copy(char *destination, const Uint8Array &source);
+    private:
+        static emscripten::val heap_();
+        static emscripten::val constructor_();
+        emscripten::val m_uint8Array = emscripten::val::undefined();
+    };
+
+    class EventCallback
+    {
+    public:
+        EventCallback(emscripten::val element, const std::string &name, const std::function<void ()> &fn);
+        static void activate(emscripten::val event);
+    private:
+        static std::string contextPropertyName(const std::string &eventName);
+        std::function<void ()> m_fn;
+    };
+}
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/platform/wasm/wasm.pri b/src/corelib/platform/wasm/wasm.pri
new file mode 100644
index 0000000000..73447030fb
--- /dev/null
+++ b/src/corelib/platform/wasm/wasm.pri
@@ -0,0 +1,3 @@
+INCLUDEDIR += $$PWD
+HEADERS += $$PWD/qstdweb_p.h
+SOURCES += $$PWD/qstdweb.cpp