LibCore+LibWeb: Remove the dummy EventReceiver from deferred_invoke()

The DeferredInvocationContext only existed to satisfy the requirement
in ThreadEventQueue that each event has an EventReceiver. However,
deferred_invoke() was not even using the EventReceiver to call its
callback. Therefore, we don't need to allocate one for every deferred
invocation.

This also prevents WeakPtr::strong_ref() from racing and leaking the
context object when invoking a function across threads.

Author: Zaggy1024

Libraries/LibCore/DeferredInvocationContext.h

@@ -11,7 +11,6 @@
 #include <AK/Function.h>
 #include <AK/Types.h>
 #include <AK/WeakPtr.h>
-#include <LibCore/DeferredInvocationContext.h>
 #include <LibCore/Forward.h>
 
 namespace Core {
@@ -49,15 +48,13 @@ class DeferredInvocationEvent : public Event {
     friend class ThreadEventQueue;
 
 public:
-    DeferredInvocationEvent(NonnullRefPtr<DeferredInvocationContext> context, Function<void()> invokee)
+    DeferredInvocationEvent(Function<void()>&& invokee)
         : Event(Event::Type::DeferredInvoke)
-        , m_context(move(context))
         , m_invokee(move(invokee))
     {
     }
 
 private:
-    NonnullRefPtr<DeferredInvocationContext> m_context;
     Function<void()> m_invokee;
 };
 

Libraries/LibCore/Event.h

@@ -104,7 +104,7 @@ size_t EventLoop::pump(WaitMode mode)
 
 void EventLoop::post_event(EventReceiver& receiver, NonnullOwnPtr<Event>&& event)
 {
-    m_impl->post_event(receiver, move(event));
+    m_impl->post_event(&receiver, move(event));
 }
 
 void EventLoop::add_job(NonnullRefPtr<Promise<NonnullRefPtr<EventReceiver>>> job_promise)
@@ -149,8 +149,7 @@ void EventLoop::wake()
 
 void EventLoop::deferred_invoke(Function<void()> invokee)
 {
-    auto context = DeferredInvocationContext::construct();
-    post_event(context, make<Core::DeferredInvocationEvent>(context, move(invokee)));
+    m_impl->post_event(nullptr, make<Core::DeferredInvocationEvent>(move(invokee)));
 }
 
 void deferred_invoke(Function<void()> invokee)

Libraries/LibCore/EventLoop.cpp

@@ -54,7 +54,7 @@ class EventLoopImplementation {
     virtual void wake() = 0;
     virtual bool was_exit_requested() const = 0;
 
-    virtual void post_event(EventReceiver& receiver, NonnullOwnPtr<Event>&&) = 0;
+    virtual void post_event(EventReceiver*, NonnullOwnPtr<Event>&&) = 0;
 
 protected:
     EventLoopImplementation();

Libraries/LibCore/EventLoopImplementation.h

@@ -210,7 +210,7 @@ class EventLoopTimer final : public EventLoopTimeout {
             }
         }
 
-        ThreadEventQueue::current().post_event(*strong_owner, make<TimerEvent>());
+        ThreadEventQueue::current().post_event(strong_owner, make<TimerEvent>());
     }
 
     AK::Duration interval;
@@ -314,7 +314,7 @@ void EventLoopImplementationUnix::quit(int code)
     m_exit_code = code;
 }
 
-void EventLoopImplementationUnix::post_event(EventReceiver& receiver, NonnullOwnPtr<Event>&& event)
+void EventLoopImplementationUnix::post_event(EventReceiver* receiver, NonnullOwnPtr<Event>&& event)
 {
     m_thread_event_queue.post_event(receiver, move(event));
     if (&m_thread_event_queue != &ThreadEventQueue::current())
@@ -422,7 +422,7 @@ void EventLoopManagerUnix::wait_for_events(EventLoopImplementation::PumpMode mod
             type &= notifier.type();
 
             if (type != NotificationType::None)
-                ThreadEventQueue::current().post_event(notifier, make<NotifierActivationEvent>());
+                ThreadEventQueue::current().post_event(&notifier, make<NotifierActivationEvent>());
 #endif
         }
     }

Libraries/LibCore/EventLoopImplementationUnix.cpp

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <AK/NonnullOwnPtr.h>
 #include <AK/Time.h>
 #include <LibCore/EventLoopImplementation.h>
 
@@ -50,7 +51,7 @@ class EventLoopImplementationUnix final : public EventLoopImplementation {
 
     virtual void wake() override;
 
-    virtual void post_event(EventReceiver& receiver, NonnullOwnPtr<Event>&&) override;
+    virtual void post_event(EventReceiver*, NonnullOwnPtr<Event>&&) override;
 
 private:
     bool m_exit_requested { false };

Libraries/LibCore/EventLoopImplementationUnix.h

@@ -196,7 +196,7 @@ size_t EventLoopImplementationWindows::pump(PumpMode pump_mode)
             if (packet->type == CompletionType::Timer) {
                 auto* timer = static_cast<EventLoopTimer*>(packet);
                 if (auto owner = timer->owner.strong_ref())
-                    event_queue.post_event(*owner, make<TimerEvent>());
+                    event_queue.post_event(owner, make<TimerEvent>());
                 if (timer->is_periodic) {
                     NTSTATUS status = g_system.NtAssociateWaitCompletionPacket(timer->wait_packet.handle, thread_data->iocp.handle, timer->timer.handle, timer, NULL, 0, 0, NULL);
                     VERIFY(NT_SUCCESS(status));
@@ -205,7 +205,7 @@ size_t EventLoopImplementationWindows::pump(PumpMode pump_mode)
             }
             if (packet->type == CompletionType::Notifer) {
                 auto* notifier_data = static_cast<EventLoopNotifier*>(packet);
-                event_queue.post_event(*notifier_data->notifier, make<NotifierActivationEvent>());
+                event_queue.post_event(notifier_data->notifier, make<NotifierActivationEvent>());
                 NTSTATUS status = g_system.NtAssociateWaitCompletionPacket(notifier_data->wait_packet.handle, thread_data->iocp.handle, notifier_data->wait_event.handle, notifier_data, NULL, 0, 0, NULL);
                 VERIFY(NT_SUCCESS(status));
                 continue;
@@ -232,7 +232,7 @@ void EventLoopImplementationWindows::quit(int code)
     m_exit_code = code;
 }
 
-void EventLoopImplementationWindows::post_event(EventReceiver& receiver, NonnullOwnPtr<Event>&& event)
+void EventLoopImplementationWindows::post_event(EventReceiver* receiver, NonnullOwnPtr<Event>&& event)
 {
     m_thread_event_queue.post_event(receiver, move(event));
     if (&m_thread_event_queue != &ThreadEventQueue::current())

Libraries/LibCore/EventLoopImplementationWindows.cpp

@@ -42,7 +42,7 @@ class EventLoopImplementationWindows final : public EventLoopImplementation {
     virtual void wake() override;
     virtual bool was_exit_requested() const override { return m_exit_requested; }
 
-    virtual void post_event(EventReceiver& receiver, NonnullOwnPtr<Event>&&) override;
+    virtual void post_event(EventReceiver* receiver, NonnullOwnPtr<Event>&&) override;
 
 private:
     bool m_exit_requested { false };

Libraries/LibCore/EventLoopImplementationWindows.h

@@ -5,7 +5,6 @@
  */
 
 #include <AK/Vector.h>
-#include <LibCore/DeferredInvocationContext.h>
 #include <LibCore/EventLoopImplementation.h>
 #include <LibCore/EventReceiver.h>
 #include <LibCore/Promise.h>
@@ -22,7 +21,7 @@ struct ThreadEventQueue::Private {
         AK_MAKE_DEFAULT_MOVABLE(QueuedEvent);
 
     public:
-        QueuedEvent(EventReceiver& receiver, NonnullOwnPtr<Event> event)
+        QueuedEvent(RefPtr<EventReceiver> const& receiver, NonnullOwnPtr<Event> event)
             : receiver(receiver)
             , event(move(event))
         {
@@ -67,7 +66,7 @@ ThreadEventQueue::ThreadEventQueue()
 
 ThreadEventQueue::~ThreadEventQueue() = default;
 
-void ThreadEventQueue::post_event(Core::EventReceiver& receiver, NonnullOwnPtr<Core::Event> event)
+void ThreadEventQueue::post_event(Core::EventReceiver* receiver, NonnullOwnPtr<Core::Event> event)
 {
     {
         Threading::MutexLocker lock(m_private->mutex);
@@ -106,16 +105,16 @@ size_t ThreadEventQueue::process()
         auto receiver = queued_event.receiver.strong_ref();
         auto& event = *queued_event.event;
 
-        if (!receiver) {
+        if (event.type() == Event::Type::DeferredInvoke) {
+            static_cast<DeferredInvocationEvent&>(event).m_invokee();
+        } else if (!receiver) {
             switch (event.type()) {
             case Event::Quit:
                 VERIFY_NOT_REACHED();
             default:
                 // Receiver disappeared, drop the event on the floor.
                 break;
             }
-        } else if (event.type() == Event::Type::DeferredInvoke) {
-            static_cast<DeferredInvocationEvent&>(event).m_invokee();
         } else {
             NonnullRefPtr<EventReceiver> protector(*receiver);
             receiver->dispatch_event(event);

Libraries/LibCore/ThreadEventQueue.cpp

@@ -8,6 +8,7 @@
 
 #include <AK/NonnullOwnPtr.h>
 #include <AK/OwnPtr.h>
+#include <LibCore/Forward.h>
 
 namespace Core {
 
@@ -25,7 +26,7 @@ class ThreadEventQueue {
     size_t process();
 
     // Posts an event to the event queue.
-    void post_event(EventReceiver& receiver, NonnullOwnPtr<Event>);
+    void post_event(EventReceiver*, NonnullOwnPtr<Event>);
 
     // Used by Threading::BackgroundAction.
     void add_job(NonnullRefPtr<Promise<NonnullRefPtr<EventReceiver>>>);