Support filter list for file input when opening a file on WASM

The polyfill for file input on WASM now makes use of the supplied
filter list.
Some changes were introduced in the abstraction for filters so that
they are usable both for the new file API and the legacy file input.

Change-Id: Id6341be4d6a1647e17382d13da7be42491cfaf80
Reviewed-by: Morten Johan Sørvig <morten.sorvig@qt.io>

3 files changed, 81 insertions, 51 deletions

diff --git a/src/gui/platform/wasm/qlocalfileapi.cpp b/src/gui/platform/wasm/qlocalfileapi.cpp
index b56490eba4..bfcb5a5866 100644
--- a/src/gui/platform/wasm/qlocalfileapi.cpp
+++ b/src/gui/platform/wasm/qlocalfileapi.cpp
@@ -8,6 +8,33 @@
 QT_BEGIN_NAMESPACE
 namespace LocalFileApi {
 namespace {
+std::string qtFilterListToFileInputAccept(const QStringList &filterList)
+{
+    QStringList transformed;
+    for (const auto &filter : filterList) {
+
+        emscripten::val::global("console").call<void>("log", filter.toStdString());
+
+        const auto type = Type::fromQt(filter);
+        if (type && type->accept()) {
+            const auto &extensions = type->accept()->mimeType().extensions();
+            for (const auto &ext : extensions) {
+                emscripten::val::global("console").call<void>("log",
+                                                              ext.value().toString().toStdString());
+            }
+
+            std::transform(extensions.begin(), extensions.end(), std::back_inserter(transformed),
+                           [](const Type::Accept::MimeType::Extension &extension) {
+                               return extension.value().toString();
+                           });
+        }
+    }
+    for (const QString &tran : transformed) {
+        emscripten::val::global("console").call<void>("log", tran.toStdString());
+    }
+    return transformed.join(QStringLiteral(",")).toStdString();
+}
+
 std::optional<emscripten::val> qtFilterListToTypes(const QStringList &filterList)
 {
     using namespace qstdweb;
@@ -17,20 +44,38 @@ std::optional<emscripten::val> qtFilterListToTypes(const QStringList &filterList
 
     for (const auto &fileFilter : filterList) {
         auto type = Type::fromQt(fileFilter);
-        if (type)
-            types.call<void>("push", type->asVal());
+        if (type) {
+            auto jsType = 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 +114,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 +140,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 +187,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)) {
         options.set("types", std::move(*typeList));
         options.set("excludeAcceptAllOption", true);
     }
@@ -186,12 +207,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..b8fa6adb99 100644
--- a/src/gui/platform/wasm/qlocalfileapi_p.h
+++ b/src/gui/platform/wasm/qlocalfileapi_p.h
@@ -36,12 +36,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,38 +49,42 @@ 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 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 72f1dcc339..762d5e1a40 100644
--- a/src/gui/platform/wasm/qwasmlocalfileaccess.cpp
+++ b/src/gui/platform/wasm/qwasmlocalfileaccess.cpp
@@ -31,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));