macOS: Call ApplicationHandler directly instead of using Event (#3753)

Additionally, always queue events in `handle_scale_factor_changed`.

These events were intentionally not queued before, since they are
executed inside `handle_scale_factor_changed`, which is itself queued.
Though that's a bit too subtle, so let's just take the minuscule perf
hit of redundantly checking whether we need to queue again.

Co-authored-by: Kirill Chibisov <contact@kchibisov.com>

src/platform_impl/macos/event_handler.rs

@@ -2,31 +2,31 @@ use std::cell::RefCell;
 use std::{fmt, mem};
 
 use super::app_state::HandlePendingUserEvents;
-use crate::event::Event;
+use crate::application::ApplicationHandler;
 use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
 
-struct EventHandlerData {
-    #[allow(clippy::type_complexity)]
-    handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
-}
-
-impl fmt::Debug for EventHandlerData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventHandlerData").finish_non_exhaustive()
-    }
-}
-
-#[derive(Debug)]
+#[derive(Default)]
 pub(crate) struct EventHandler {
     /// This can be in the following states:
     /// - Not registered by the event loop (None).
     /// - Present (Some(handler)).
     /// - Currently executing the handler / in use (RefCell borrowed).
-    inner: RefCell<Option<EventHandlerData>>,
+    inner: RefCell<Option<&'static mut dyn ApplicationHandler<HandlePendingUserEvents>>>,
+}
+
+impl fmt::Debug for EventHandler {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let state = match self.inner.try_borrow().as_deref() {
+            Ok(Some(_)) => "<available>",
+            Ok(None) => "<not set>",
+            Err(_) => "<in use>",
+        };
+        f.debug_struct("EventHandler").field("state", &state).finish_non_exhaustive()
+    }
 }
 
 impl EventHandler {
-    pub(crate) const fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self { inner: RefCell::new(None) }
     }
 
@@ -37,7 +37,7 @@ impl EventHandler {
     /// from within the closure.
     pub(crate) fn set<'handler, R>(
         &self,
-        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler,
+        app: &'handler mut dyn ApplicationHandler<HandlePendingUserEvents>,
         closure: impl FnOnce() -> R,
     ) -> R {
         // SAFETY: We extend the lifetime of the handler here so that we can
@@ -48,9 +48,9 @@ impl EventHandler {
         // extended beyond `'handler`.
         let handler = unsafe {
             mem::transmute::<
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler>,
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
-            >(Box::new(handler))
+                &'handler mut dyn ApplicationHandler<HandlePendingUserEvents>,
+                &'static mut dyn ApplicationHandler<HandlePendingUserEvents>,
+            >(app)
         };
 
         match self.inner.try_borrow_mut().as_deref_mut() {
@@ -58,7 +58,7 @@ impl EventHandler {
                 unreachable!("tried to set handler while another was already set");
             },
             Ok(data @ None) => {
-                *data = Some(EventHandlerData { handler });
+                *data = Some(handler);
             },
             Err(_) => {
                 unreachable!("tried to set handler that is currently in use");
@@ -109,20 +109,22 @@ impl EventHandler {
         matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
     }
 
-    pub(crate) fn handle_event(
+    pub(crate) fn handle<
+        F: FnOnce(&mut dyn ApplicationHandler<HandlePendingUserEvents>, &RootActiveEventLoop),
+    >(
         &self,
-        event: Event<HandlePendingUserEvents>,
+        callback: F,
         event_loop: &RootActiveEventLoop,
     ) {
         match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(EventHandlerData { handler })) => {
+            Ok(Some(user_app)) => {
                 // It is important that we keep the reference borrowed here,
                 // so that `in_use` can properly detect that the handler is
                 // still in use.
                 //
                 // If the handler unwinds, the `RefMut` will ensure that the
                 // handler is no longer borrowed.
-                (handler)(event, event_loop);
+                callback(*user_app, event_loop);
             },
             Ok(None) => {
                 // `NSApplication`, our app delegate and this handler are all