1 files changed, 52 insertions, 17 deletions

diff --git a/src/corelib/kernel/qeventdispatcher_wasm_p.h b/src/corelib/kernel/qeventdispatcher_wasm_p.h
index d1520eda4d..7b257e02ad 100644
--- a/src/corelib/kernel/qeventdispatcher_wasm_p.h
+++ b/src/corelib/kernel/qeventdispatcher_wasm_p.h
@@ -20,16 +20,19 @@
 #include <QtCore/qloggingcategory.h>
 #include <QtCore/qwaitcondition.h>
 
+#include <chrono>
 #include <mutex>
 #include <optional>
 #include <tuple>
 
+#include <emscripten/proxying.h>
+
 QT_BEGIN_NAMESPACE
 
 Q_DECLARE_LOGGING_CATEGORY(lcEventDispatcher);
 Q_DECLARE_LOGGING_CATEGORY(lcEventDispatcherTimers)
 
-class Q_CORE_EXPORT QEventDispatcherWasm : public QAbstractEventDispatcher
+class Q_CORE_EXPORT QEventDispatcherWasm : public QAbstractEventDispatcherV2
 {
     Q_OBJECT
 public:
@@ -41,34 +44,45 @@ public:
     void registerSocketNotifier(QSocketNotifier *notifier) override;
     void unregisterSocketNotifier(QSocketNotifier *notifier) override;
 
-    void registerTimer(int timerId, qint64 interval, Qt::TimerType timerType, QObject *object)  override;
-    bool unregisterTimer(int timerId) override;
-    bool unregisterTimers(QObject *object) override;
-    QList<QAbstractEventDispatcher::TimerInfo> registeredTimers(QObject *object) const override;
-    int remainingTime(int timerId) override;
+    void registerTimer(Qt::TimerId timerId, Duration interval, Qt::TimerType timerType,
+                       QObject *object) override final;
+    bool unregisterTimer(Qt::TimerId timerId) override final;
+    bool unregisterTimers(QObject *object) override final;
+    QList<TimerInfoV2> timersForObject(QObject *object) const override final;
+    Duration remainingTime(Qt::TimerId timerId) const override final;
 
     void interrupt() override;
     void wakeUp() override;
 
+    static void runOnMainThread(std::function<void(void)> fn);
+    static void socketSelect(int timeout, int socket, bool waitForRead, bool waitForWrite,
+                            bool *selectForRead, bool *selectForWrite, bool *socketDisconnect);
+
+    static void registerStartupTask();
+    static void completeStarupTask();
+    static void callOnLoadedIfRequired();
+    virtual void onLoaded();
+
 protected:
-    virtual void processWindowSystemEvents(QEventLoop::ProcessEventsFlags flags);
+    virtual bool processPostedEvents();
 
 private:
     bool isMainThreadEventDispatcher();
     bool isSecondaryThreadEventDispatcher();
+    static bool isValidEventDispatcherPointer(QEventDispatcherWasm *eventDispatcher);
 
     void handleApplicationExec();
     void handleDialogExec();
-    void pollForNativeEvents();
-    bool waitForForEvents();
-    static void callProcessEvents(void *eventDispatcher);
+    bool wait(int timeout = -1);
+    bool wakeEventDispatcherThread();
+    static void callProcessPostedEvents(void *eventDispatcher);
 
     void processTimers();
     void updateNativeTimer();
     static void callProcessTimers(void *eventDispatcher);
 
-    void setEmscriptenSocketCallbacks();
-    void clearEmscriptenSocketCallbacks();
+    static void setEmscriptenSocketCallbacks();
+    static void clearEmscriptenSocketCallbacks();
     static void socketError(int fd, int err, const char* msg, void *context);
     static void socketOpen(int fd, void *context);
     static void socketListen(int fd, void *context);
@@ -76,9 +90,14 @@ private:
     static void socketMessage(int fd, void *context);
     static void socketClose(int fd, void *context);
 
-#if QT_CONFIG(thread)
-    void runOnMainThread(std::function<void(void)> fn);
-#endif
+    static void setSocketState(int socket, bool setReadyRead, bool setReadyWrite);
+    static void clearSocketState(int socket);
+    void waitForSocketState(int timeout, int socket, bool checkRead, bool checkWrite,
+                            bool *selectForRead, bool *selectForWrite, bool *socketDisconnect);
+
+    static void run(std::function<void(void)> fn);
+    static void runAsync(std::function<void(void)> fn);
+    static void runOnMainThreadAsync(std::function<void(void)> fn);
 
     static QEventDispatcherWasm *g_mainThreadEventDispatcher;
 
@@ -88,7 +107,7 @@ private:
 
     QTimerInfoList *m_timerInfo = new QTimerInfoList();
     long m_timerId = 0;
-    uint64_t m_timerTargetTime = 0;
+    std::chrono::milliseconds m_timerTargetTime{};
 
 #if QT_CONFIG(thread)
     std::mutex m_mutex;
@@ -96,9 +115,25 @@ private:
     std::condition_variable m_moreEvents;
 
     static QVector<QEventDispatcherWasm *> g_secondaryThreadEventDispatchers;
-    static std::mutex g_secondaryThreadEventDispatchersMutex;
+    static std::mutex g_staticDataMutex;
+    static emscripten::ProxyingQueue g_proxyingQueue;
+    static pthread_t g_mainThread;
+
+    // Note on mutex usage: the global g_staticDataMutex protects the global (g_ prefixed) data,
+    // while the per eventdispatcher m_mutex protects the state accociated with blocking and waking
+    // that eventdispatcher thread. The locking order is g_staticDataMutex first, then m_mutex.
 #endif
+
     static std::multimap<int, QSocketNotifier *> g_socketNotifiers;
+
+    struct SocketReadyState {
+        QEventDispatcherWasm *waiter = nullptr;
+        bool waitForReadyRead = false;
+        bool waitForReadyWrite = false;
+        bool readyRead = false;
+        bool readyWrite = false;
+    };
+    static std::map<int, SocketReadyState> g_socketState;
 };
 
 #endif // QEVENTDISPATCHER_WASM_P_H