LibCore: 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

@@ -102,7 +102,7 @@ size_t EventLoop::pump(WaitMode mode)
     return m_impl->pump(mode == WaitMode::WaitForEvents ? EventLoopImplementation::PumpMode::WaitForEvents : EventLoopImplementation::PumpMode::DontWaitForEvents);
 }
 
-void EventLoop::post_event(EventReceiver& receiver, NonnullOwnPtr<Event>&& event)
+void EventLoop::post_event(RefPtr<EventReceiver> const& receiver, NonnullOwnPtr<Event>&& event)
 {
     m_impl->post_event(receiver, move(event));
 }
@@ -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)));
+    post_event(nullptr, make<Core::DeferredInvocationEvent>(move(invokee)));
 }
 
 void deferred_invoke(Function<void()> invokee)

Libraries/LibCore/EventLoop.cpp

@@ -68,7 +68,7 @@ class EventLoop {
     void spin_until(Function<bool()>);
 
     // Post an event to this event loop.
-    void post_event(EventReceiver& receiver, NonnullOwnPtr<Event>&&);
+    void post_event(RefPtr<EventReceiver> const& receiver, NonnullOwnPtr<Event>&&);
 
     void add_job(NonnullRefPtr<Promise<NonnullRefPtr<EventReceiver>>> job_promise);
 

Libraries/LibCore/EventLoop.h

@@ -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(RefPtr<EventReceiver> const&, NonnullOwnPtr<Event>&&) = 0;
 
 protected:
     EventLoopImplementation();

Libraries/LibCore/EventLoopImplementation.h

@@ -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(RefPtr<EventReceiver> const& receiver, NonnullOwnPtr<Event>&& event)
 {
     m_thread_event_queue.post_event(receiver, move(event));
     if (&m_thread_event_queue != &ThreadEventQueue::current())

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(RefPtr<EventReceiver> const&, NonnullOwnPtr<Event>&&) override;
 
 private:
     bool m_exit_requested { false };

Libraries/LibCore/EventLoopImplementationUnix.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(RefPtr<Core::EventReceiver> const& 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(RefPtr<EventReceiver> const&, NonnullOwnPtr<Event>);
 
     // Used by Threading::BackgroundAction.
     void add_job(NonnullRefPtr<Promise<NonnullRefPtr<EventReceiver>>>);

Libraries/LibCore/ThreadEventQueue.h

@@ -41,7 +41,7 @@ class WEBVIEW_API EventLoopImplementationMacOS final : public Core::EventLoopImp
     virtual void quit(int) override;
     virtual void wake() override;
     virtual bool was_exit_requested() const override;
-    virtual void post_event(Core::EventReceiver& receiver, NonnullOwnPtr<Core::Event>&&) override;
+    virtual void post_event(RefPtr<Core::EventReceiver> const&, NonnullOwnPtr<Core::Event>&&) override;
 
     virtual ~EventLoopImplementationMacOS() override;