5 files changed, 160 insertions, 68 deletions

diff --git a/src/gui/platform/wasm/qlocalfileapi.cpp b/src/gui/platform/wasm/qlocalfileapi.cpp
index b56490eba4..76b99361c4 100644
--- a/src/gui/platform/wasm/qlocalfileapi.cpp
+++ b/src/gui/platform/wasm/qlocalfileapi.cpp
@@ -8,29 +8,62 @@
 QT_BEGIN_NAMESPACE
 namespace LocalFileApi {
 namespace {
+std::string qtFilterListToFileInputAccept(const QStringList &filterList)
+{
+    QStringList transformed;
+    for (const auto &filter : filterList) {
+        const auto type = Type::fromQt(filter);
+        if (type && type->accept()) {
+            const auto &extensions = type->accept()->mimeType().extensions();
+            std::transform(extensions.begin(), extensions.end(), std::back_inserter(transformed),
+                           [](const Type::Accept::MimeType::Extension &extension) {
+                               return extension.value().toString();
+                           });
+        }
+    }
+    return transformed.join(QStringLiteral(",")).toStdString();
+}
+
 std::optional<emscripten::val> qtFilterListToTypes(const QStringList &filterList)
 {
     using namespace qstdweb;
     using namespace emscripten;
-
     auto types = emscripten::val::array();
 
     for (const auto &fileFilter : filterList) {
         auto type = Type::fromQt(fileFilter);
-        if (type)
-            types.call<void>("push", type->asVal());
+        if (type) {
+            auto jsType = emscripten::val::object();
+            jsType.set("description", type->description().toString().toStdString());
+            if (type->accept()) {
+                jsType.set("accept", ([&mimeType = type->accept()->mimeType()]() {
+                               val acceptDict = val::object();
+
+                               QList<emscripten::val> extensions;
+                               extensions.reserve(mimeType.extensions().size());
+                               std::transform(
+                                       mimeType.extensions().begin(), mimeType.extensions().end(),
+                                       std::back_inserter(extensions),
+                                       [](const Type::Accept::MimeType::Extension &extension) {
+                                           return val(extension.value().toString().toStdString());
+                                       });
+                               acceptDict.set("application/octet-stream",
+                                              emscripten::val::array(extensions.begin(),
+                                                                     extensions.end()));
+                               return acceptDict;
+                           })());
+            }
+            types.call<void>("push", std::move(jsType));
+        }
     }
 
     return types["length"].as<int>() == 0 ? std::optional<emscripten::val>() : types;
 }
-}
+} // namespace
 
 Type::Type(QStringView description, std::optional<Accept> accept)
-    : m_storage(emscripten::val::object())
+    : m_description(description.trimmed()), m_accept(std::move(accept))
 {
-    m_storage.set("description", description.trimmed().toString().toStdString());
-    if (accept)
-        m_storage.set("accept", accept->asVal());
 }
 
 Type::~Type() = default;
@@ -69,12 +102,7 @@ std::optional<Type> Type::fromQt(QStringView type)
     return Type(description, std::move(*accept));
 }
 
-emscripten::val Type::asVal() const
-{
-    return m_storage;
-}
-
-Type::Accept::Accept() : m_storage(emscripten::val::object()) { }
+Type::Accept::Accept() = default;
 
 Type::Accept::~Accept() = default;
 
@@ -100,39 +128,25 @@ std::optional<Type::Accept> Type::Accept::fromQt(QStringView qtRepresentation)
         internalMatch = internalRegex.matchView(qtRepresentation, internalMatch.capturedEnd());
     }
 
-    accept.addMimeType(mimeType);
+    accept.setMimeType(mimeType);
     return accept;
 }
 
-void Type::Accept::addMimeType(MimeType mimeType)
-{
-    // The mime type provided here does not seem to have any effect at the result at all.
-    m_storage.set("application/octet-stream", mimeType.asVal());
-}
-
-emscripten::val Type::Accept::asVal() const
+void Type::Accept::setMimeType(MimeType mimeType)
 {
-    return m_storage;
+    m_mimeType = std::move(mimeType);
 }
 
-Type::Accept::MimeType::MimeType() : m_storage(emscripten::val::array()) { }
+Type::Accept::MimeType::MimeType() = default;
 
 Type::Accept::MimeType::~MimeType() = default;
 
 void Type::Accept::MimeType::addExtension(Extension extension)
 {
-    m_storage.call<void>("push", extension.asVal());
+    m_extensions.push_back(std::move(extension));
 }
 
-emscripten::val Type::Accept::MimeType::asVal() const
-{
-    return m_storage;
-}
-
-Type::Accept::MimeType::Extension::Extension(QStringView extension)
-    : m_storage(extension.toString().toStdString())
-{
-}
+Type::Accept::MimeType::Extension::Extension(QStringView extension) : m_value(extension) { }
 
 Type::Accept::MimeType::Extension::~Extension() = default;
 
@@ -161,15 +175,10 @@ Type::Accept::MimeType::Extension::fromQt(QStringView qtRepresentation)
     return std::nullopt;
 }
 
-emscripten::val Type::Accept::MimeType::Extension::asVal() const
-{
-    return m_storage;
-}
-
 emscripten::val makeOpenFileOptions(const QStringList &filterList, bool acceptMultiple)
 {
     auto options = emscripten::val::object();
-    if (auto typeList = LocalFileApi::qtFilterListToTypes(filterList)) {
+    if (auto typeList = qtFilterListToTypes(filterList); typeList) {
         options.set("types", std::move(*typeList));
         options.set("excludeAcceptAllOption", true);
     }
@@ -186,12 +195,17 @@ emscripten::val makeSaveFileOptions(const QStringList &filterList, const std::st
     if (!suggestedName.empty())
         options.set("suggestedName", emscripten::val(suggestedName));
 
-    if (auto typeList = LocalFileApi::qtFilterListToTypes(filterList))
+    if (auto typeList = qtFilterListToTypes(filterList))
         options.set("types", emscripten::val(std::move(*typeList)));
 
     return options;
 }
 
-}  // namespace LocalFileApi
+std::string makeFileInputAccept(const QStringList &filterList)
+{
+    return qtFilterListToFileInputAccept(filterList);
+}
+
+} // namespace LocalFileApi
 
 QT_END_NAMESPACE
diff --git a/src/gui/platform/wasm/qlocalfileapi_p.h b/src/gui/platform/wasm/qlocalfileapi_p.h
index a8e7f666f9..1398d674d8 100644
--- a/src/gui/platform/wasm/qlocalfileapi_p.h
+++ b/src/gui/platform/wasm/qlocalfileapi_p.h
@@ -24,7 +24,8 @@
 QT_BEGIN_NAMESPACE
 
 namespace LocalFileApi {
-class Q_CORE_EXPORT Type {
+class Q_AUTOTEST_EXPORT Type
+{
 public:
     class Accept {
     public:
@@ -36,12 +37,12 @@ public:
 
                 ~Extension();
 
-                emscripten::val asVal() const;
+                const QStringView &value() const { return m_value; }
 
             private:
                 explicit Extension(QStringView extension);
 
-                emscripten::val m_storage;
+                QStringView m_value;
             };
 
             MimeType();
@@ -49,37 +50,43 @@ public:
 
             void addExtension(Extension type);
 
-            emscripten::val asVal() const;
+            const std::vector<Extension> &extensions() const { return m_extensions; }
 
         private:
-            emscripten::val m_storage;
+            std::vector<Extension> m_extensions;
         };
 
         static std::optional<Accept> fromQt(QStringView type);
 
         ~Accept();
 
-        void addMimeType(MimeType mimeType);
+        void setMimeType(MimeType mimeType);
 
-        emscripten::val asVal() const;
+        const MimeType &mimeType() const { return m_mimeType; }
 
     private:
         Accept();
-        emscripten::val m_storage;
+        MimeType m_mimeType;
     };
 
     Type(QStringView description, std::optional<Accept> accept);
     ~Type();
 
     static std::optional<Type> fromQt(QStringView type);
-    emscripten::val asVal() const;
+    const QStringView &description() const { return m_description; }
+    const std::optional<Accept> &accept() const { return m_accept; }
 
 private:
-    emscripten::val m_storage;
+    QStringView m_description;
+    std::optional<Accept> m_accept;
 };
 
-Q_CORE_EXPORT emscripten::val makeOpenFileOptions(const QStringList &filterList, bool acceptMultiple);
-Q_CORE_EXPORT emscripten::val makeSaveFileOptions(const QStringList &filterList, const std::string& suggestedName);
+Q_AUTOTEST_EXPORT emscripten::val makeOpenFileOptions(const QStringList &filterList,
+                                                      bool acceptMultiple);
+Q_AUTOTEST_EXPORT emscripten::val makeSaveFileOptions(const QStringList &filterList,
+                                                      const std::string &suggestedName);
+
+Q_AUTOTEST_EXPORT std::string makeFileInputAccept(const QStringList &filterList);
 
 }  // namespace LocalFileApi
 QT_END_NAMESPACE
diff --git a/src/gui/platform/wasm/qwasmlocalfileaccess.cpp b/src/gui/platform/wasm/qwasmlocalfileaccess.cpp
index 1b797be9fe..a946cda043 100644
--- a/src/gui/platform/wasm/qwasmlocalfileaccess.cpp
+++ b/src/gui/platform/wasm/qwasmlocalfileaccess.cpp
@@ -9,6 +9,8 @@
 #include <emscripten/html5.h>
 #include <emscripten/val.h>
 
+#include <QtCore/qregularexpression.h>
+
 QT_BEGIN_NAMESPACE
 
 namespace QWasmLocalFileAccess {
@@ -29,7 +31,7 @@ void showOpenViaHTMLPolyfill(const QStringList &accept, FileSelectMode fileSelec
     emscripten::val input = document.call<emscripten::val>("createElement", std::string("input"));
     input.set("type", "file");
     input.set("style", "display:none");
-    // input.set("accept", emscripten::val(accept));
+    input.set("accept", LocalFileApi::makeFileInputAccept(accept));
     Q_UNUSED(accept);
     input.set("multiple", emscripten::val(fileSelectMode == FileSelectMode::MultipleFiles));
 
@@ -124,7 +126,7 @@ void readFiles(const qstdweb::FileList &fileList,
         }
 
         // Read file data into caller-provided buffer
-        file.stream(buffer, [=]() {
+        file.stream(buffer, [readFile = readFile.get(), fileIndex, fileDataReady]() {
             fileDataReady();
             (*readFile)(fileIndex + 1);
         });
@@ -132,15 +134,28 @@ void readFiles(const qstdweb::FileList &fileList,
 
     (*readFile)(0);
 }
+
+QStringList makeFilterList(const std::string &qtAcceptList)
+{
+    // copy of qt_make_filter_list() from qfiledialog.cpp
+    auto filter = QString::fromStdString(qtAcceptList); 
+    if (filter.isEmpty())
+        return QStringList();
+    QString sep(";;");
+    if (!filter.contains(sep) && filter.contains(u'\n'))
+        sep = u'\n';
+
+    return filter.split(sep);
+}
 }
 
-void downloadDataAsFile(const QByteArray &data, const std::string &fileNameHint)
+void downloadDataAsFile(const char *content, size_t size, const std::string &fileNameHint)
 {
     // Save a file by creating programmatically clicking a download
     // link to an object url to a Blob containing a copy of the file
     // content. The copy is made so that the passed in content buffer
     // can be released as soon as this function returns.
-    qstdweb::Blob contentBlob = qstdweb::Blob::copyFrom(data.constData(), data.size());
+    qstdweb::Blob contentBlob = qstdweb::Blob::copyFrom(content, size);
     emscripten::val document = emscripten::val::global("document");
     emscripten::val window = qstdweb::window();
     emscripten::val contentUrl = window["URL"].call<emscripten::val>("createObjectURL", contentBlob.val());
@@ -157,12 +172,12 @@ void downloadDataAsFile(const QByteArray &data, const std::string &fileNameHint)
     window["URL"].call<emscripten::val>("revokeObjectURL", contentUrl);
 }
 
-void openFiles(const QStringList &accept, FileSelectMode fileSelectMode,
+void openFiles(const std::string &accept, FileSelectMode fileSelectMode,
     const std::function<void (int fileCount)> &fileDialogClosed,
     const std::function<char *(uint64_t size, const std::string& name)> &acceptFile,
     const std::function<void()> &fileDataReady)
 {
-    FileDialog::showOpen(accept, fileSelectMode, {
+    FileDialog::showOpen(makeFilterList(accept), fileSelectMode, {
         .thenFunc = [=](emscripten::val result) {
             auto files = qstdweb::FileList(result);
             fileDialogClosed(files.length());
@@ -174,7 +189,7 @@ void openFiles(const QStringList &accept, FileSelectMode fileSelectMode,
     });
 }
 
-void openFile(const QStringList &accept,
+void openFile(const std::string &accept,
     const std::function<void (bool fileSelected)> &fileDialogClosed,
     const std::function<char *(uint64_t size, const std::string& name)> &acceptFile,
     const std::function<void()> &fileDataReady)
@@ -195,6 +210,11 @@ void saveDataToFileInChunks(emscripten::val fileHandle, const QByteArray &data)
                 std::function<void(val result)> continuation;
             };
 
+            static constexpr size_t desiredChunkSize = 1024u;
+#if defined(__EMSCRIPTEN_SHARED_MEMORY__)
+            qstdweb::Uint8Array chunkArray(desiredChunkSize);
+#endif
+
             auto state = std::make_shared<State>();
             state->written = 0u;
             state->continuation = [=](val) mutable {
@@ -204,11 +224,30 @@ void saveDataToFileInChunks(emscripten::val fileHandle, const QByteArray &data)
                     state.reset();
                     return;
                 }
-                static constexpr size_t desiredChunkSize = 1024u;
+
                 const auto currentChunkSize = std::min(remaining, desiredChunkSize);
-                Promise::make(writable, QStringLiteral("write"), {
-                    .thenFunc = state->continuation,
-                }, val(typed_memory_view(currentChunkSize, data.constData() + state->written)));
+
+#if defined(__EMSCRIPTEN_SHARED_MEMORY__)
+                // If shared memory is used, WebAssembly.Memory is instantiated with the 'shared'
+                // option on. Passing a typed_memory_view to SharedArrayBuffer to
+                // FileSystemWritableFileStream.write is disallowed by security policies, so we
+                // need to make a copy of the data to a chunk array buffer.
+                Promise::make(
+                    writable, QStringLiteral("write"),
+                    {
+                        .thenFunc = state->continuation,
+                    },
+                    chunkArray.copyFrom(data.constData() + state->written, currentChunkSize)
+                        .val()
+                        .call<emscripten::val>("subarray", emscripten::val(0),
+                                               emscripten::val(currentChunkSize)));
+#else
+                Promise::make(writable, QStringLiteral("write"),
+                    {
+                        .thenFunc = state->continuation,
+                    },
+                    val(typed_memory_view(currentChunkSize, data.constData() + state->written)));
+#endif
                 state->written += currentChunkSize;
             };
 
@@ -220,7 +259,7 @@ void saveDataToFileInChunks(emscripten::val fileHandle, const QByteArray &data)
 void saveFile(const QByteArray &data, const std::string &fileNameHint)
 {
     if (!FileDialog::canShowSave()) {
-        downloadDataAsFile(data, fileNameHint);
+        downloadDataAsFile(data.constData(), data.size(), fileNameHint);
         return;
     }
 
@@ -231,6 +270,20 @@ void saveFile(const QByteArray &data, const std::string &fileNameHint)
     });
 }
 
+void saveFile(const char *content, size_t size, const std::string &fileNameHint)
+{
+    if (!FileDialog::canShowSave()) {
+        downloadDataAsFile(content, size, fileNameHint);
+        return;
+    }
+
+    FileDialog::showSave(fileNameHint, {
+        .thenFunc = [=](emscripten::val result) {
+            saveDataToFileInChunks(result, QByteArray(content, size));
+        },
+    });
+}
+
 } // namespace QWasmLocalFileAccess
 
 QT_END_NAMESPACE
diff --git a/src/gui/platform/wasm/qwasmlocalfileaccess_p.h b/src/gui/platform/wasm/qwasmlocalfileaccess_p.h
index 040fe3c47a..77b14577f7 100644
--- a/src/gui/platform/wasm/qwasmlocalfileaccess_p.h
+++ b/src/gui/platform/wasm/qwasmlocalfileaccess_p.h
@@ -25,17 +25,18 @@ namespace QWasmLocalFileAccess {
 
 enum class FileSelectMode { SingleFile, MultipleFiles };
 
-Q_CORE_EXPORT void openFiles(const QStringList &accept, FileSelectMode fileSelectMode,
+Q_CORE_EXPORT void openFiles(const std::string &accept, FileSelectMode fileSelectMode,
     const std::function<void (int fileCount)> &fileDialogClosed,
     const std::function<char *(uint64_t size, const std::string& name)> &acceptFile,
     const std::function<void()> &fileDataReady);
 
-Q_CORE_EXPORT void openFile(const QStringList &accept,
+Q_CORE_EXPORT void openFile(const std::string &accept,
     const std::function<void (bool fileSelected)> &fileDialogClosed,
     const std::function<char *(uint64_t size, const std::string& name)> &acceptFile,
     const std::function<void()> &fileDataReady);
 
 Q_CORE_EXPORT void saveFile(const QByteArray &data, const std::string &fileNameHint);
+Q_CORE_EXPORT void saveFile(const char *content, size_t size, const std::string &fileNameHint);
 
 } // namespace QWasmLocalFileAccess
 
diff --git a/src/gui/platform/wasm/qwasmnativeinterface.cpp b/src/gui/platform/wasm/qwasmnativeinterface.cpp
new file mode 100644
index 0000000000..7313629a8d
--- /dev/null
+++ b/src/gui/platform/wasm/qwasmnativeinterface.cpp
@@ -0,0 +1,17 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+
+
+#include <QtGui/private/qguiapplication_p.h>
+#include <qpa/qplatformintegration.h>
+#include <qpa/qplatformwindow_p.h>
+
+
+QT_BEGIN_NAMESPACE
+
+using namespace QNativeInterface::Private;
+
+QT_DEFINE_PRIVATE_NATIVE_INTERFACE(QWasmWindow);
+
+QT_END_NAMESPACE