LibWebView: Implement register_process for Qt Windows event loop

Qt does not use IOCP's in their underlying Windows event loop
implementation; however, QWinEventNotifier allows us to register a wait
on a process handle that has SYNCHRONIZE access rights. This means an
event will be signalled when that process terminates which emits the
QWinEventNotifier::activated signal.

Author: ayeteadoe

Libraries/LibWebView/EventLoop/EventLoopImplementationQt.cpp

@@ -24,6 +24,10 @@
 #include <QSocketNotifier>
 #include <QThread>
 #include <QTimer>
+#if defined(AK_OS_WINDOWS)
+#    include <AK/Windows.h>
+#    include <QWinEventNotifier>
+#endif
 
 namespace WebView {
 
@@ -60,6 +64,9 @@ struct ThreadData {
 
     Threading::Mutex mutex;
     HashMap<Core::Notifier*, NonnullOwnPtr<QSocketNotifier>> notifiers;
+#if defined(AK_OS_WINDOWS)
+    HashMap<pid_t, QWinEventNotifier*> processes;
+#endif
 };
 
 class QtEventLoopManagerEvent final : public QEvent {
@@ -382,6 +389,44 @@ void EventLoopManagerQt::unregister_signal(int handler_id)
         info.signal_handlers.remove(remove_signal_number);
 }
 
+#if defined(AK_OS_WINDOWS)
+
+void EventLoopManagerQt::register_process(pid_t pid, ESCAPING Function<void(pid_t)> handler)
+{
+    HANDLE process_handle = OpenProcess(SYNCHRONIZE, FALSE, pid);
+    VERIFY(process_handle);
+
+    auto* process = new QWinEventNotifier(process_handle);
+    QObject::connect(process, &QWinEventNotifier::activated, [registered_process_id = pid, registered_process_handler = move(handler), registered_process_handle = process_handle](HANDLE terminated_process_handle) {
+        if (registered_process_handle == terminated_process_handle) {
+            registered_process_handler(registered_process_id);
+        }
+    });
+
+    {
+        auto& thread_data = ThreadData::the();
+        Threading::MutexLocker locker(thread_data.mutex);
+        thread_data.processes.set(pid, process);
+    }
+}
+
+void EventLoopManagerQt::unregister_process(pid_t pid)
+{
+    {
+        auto& thread_data = ThreadData::the();
+        Threading::MutexLocker locker(thread_data.mutex);
+        auto maybe_process = thread_data.processes.take(pid);
+        if (!maybe_process.has_value())
+            return;
+        if (auto* process = maybe_process.release_value()) {
+            CloseHandle(process->handle());
+            delete process;
+        }
+    }
+}
+
+#endif
+
 void EventLoopManagerQt::did_post_event()
 {
     QCoreApplication::postEvent(m_main_thread_event_target.ptr(), new QtEventLoopManagerEvent(QtEventLoopManagerEvent::process_event_queue_event_type()));

Libraries/LibWebView/EventLoop/EventLoopImplementationQt.h

@@ -37,6 +37,11 @@ class EventLoopManagerQt final : public Core::EventLoopManager {
     virtual int register_signal(int, Function<void(int)>) override;
     virtual void unregister_signal(int) override;
 
+#if defined(AK_OS_WINDOWS)
+    virtual void register_process(pid_t, ESCAPING Function<void(pid_t)> handler) override;
+    virtual void unregister_process(pid_t pid) override;
+#endif
+
     void set_main_loop_signal_notifiers(Badge<EventLoopImplementationQt>);
 
 private: