Remove lifetime from the Event

Lifetimes don't work nicely when dealing with multithreaded environments
in the current design of the existing winit's event handling model, so
remove it in favor of `InnerSizeWriter` fences passed to client, so they
could try to update the size.

Fixes #1387.

src/platform_impl/web/event_loop/mod.rs

@@ -31,7 +31,7 @@ impl<T> EventLoop<T> {
 
     pub fn run<F>(self, event_handler: F) -> !
     where
-        F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     {
         self.spawn_inner(event_handler, false);
 
@@ -46,14 +46,14 @@ impl<T> EventLoop<T> {
 
     pub fn spawn<F>(self, event_handler: F)
     where
-        F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     {
         self.spawn_inner(event_handler, true);
     }
 
     fn spawn_inner<F>(self, mut event_handler: F, event_loop_recreation: bool)
     where
-        F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     {
         let target = RootEventLoopWindowTarget {
             p: self.elw.p.clone(),

src/platform_impl/web/event_loop/runner.rs

@@ -24,7 +24,7 @@ use web_time::{Duration, Instant};
 
 pub struct Shared<T: 'static>(Rc<Execution<T>>);
 
-pub(super) type EventHandler<T> = dyn FnMut(Event<'_, T>, &mut ControlFlow);
+pub(super) type EventHandler<T> = dyn FnMut(Event<T>, &mut ControlFlow);
 
 impl<T> Clone for Shared<T> {
     fn clone(&self) -> Self {
@@ -748,7 +748,7 @@ impl<T: 'static> Shared<T> {
 }
 
 pub(crate) enum EventWrapper<T: 'static> {
-    Event(Event<'static, T>),
+    Event(Event<T>),
     ScaleChange {
         canvas: Weak<RefCell<backend::Canvas>>,
         size: PhysicalSize<u32>,
@@ -756,8 +756,8 @@ pub(crate) enum EventWrapper<T: 'static> {
     },
 }
 
-impl<T> From<Event<'static, T>> for EventWrapper<T> {
-    fn from(value: Event<'static, T>) -> Self {
+impl<T> From<Event<T>> for EventWrapper<T> {
+    fn from(value: Event<T>) -> Self {
         Self::Event(value)
     }
 }

src/platform_impl/web/mod.rs

@@ -38,4 +38,4 @@ pub use self::window::{PlatformSpecificWindowBuilderAttributes, Window, WindowId
 
 pub(crate) use self::keyboard::KeyEventExtra;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
-pub(self) use crate::platform_impl::Fullscreen;
+pub(crate) use crate::platform_impl::Fullscreen;

src/platform_impl/web/web_sys/canvas.rs

@@ -1,20 +1,7 @@
-use super::super::WindowId;
-use super::event_handle::EventListenerHandle;
-use super::intersection_handle::IntersectionObserverHandle;
-use super::media_query_handle::MediaQueryListHandle;
-use super::pointer::PointerHandler;
-use super::{event, fullscreen, ButtonsState, ResizeScaleHandle};
-use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::error::OsError as RootOE;
-use crate::event::{Force, MouseButton, MouseScrollDelta};
-use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState};
-use crate::platform_impl::{OsError, PlatformSpecificWindowBuilderAttributes};
-use crate::window::{WindowAttributes, WindowId as RootWindowId};
-
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use js_sys::Promise;
 use smol_str::SmolStr;
@@ -24,6 +11,20 @@ use web_sys::{
     CssStyleDeclaration, Document, Event, FocusEvent, HtmlCanvasElement, KeyboardEvent, WheelEvent,
 };
 
+use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
+use crate::error::OsError as RootOE;
+use crate::event::{Force, InnerSizeWriter, MouseButton, MouseScrollDelta};
+use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState};
+use crate::platform_impl::{OsError, PlatformSpecificWindowBuilderAttributes};
+use crate::window::{WindowAttributes, WindowId as RootWindowId};
+
+use super::super::WindowId;
+use super::event_handle::EventListenerHandle;
+use super::intersection_handle::IntersectionObserverHandle;
+use super::media_query_handle::MediaQueryListHandle;
+use super::pointer::PointerHandler;
+use super::{event, fullscreen, ButtonsState, ResizeScaleHandle};
+
 #[allow(dead_code)]
 pub struct Canvas {
     common: Common,
@@ -451,20 +452,25 @@ impl Canvas {
     pub(crate) fn handle_scale_change<T: 'static>(
         &self,
         runner: &super::super::event_loop::runner::Shared<T>,
-        event_handler: impl FnOnce(crate::event::Event<'_, T>),
+        event_handler: impl FnOnce(crate::event::Event<T>),
         current_size: PhysicalSize<u32>,
         scale: f64,
     ) {
         // First, we send the `ScaleFactorChanged` event:
         self.set_current_size(current_size);
-        let mut new_size = current_size;
-        event_handler(crate::event::Event::WindowEvent {
-            window_id: RootWindowId(self.id),
-            event: crate::event::WindowEvent::ScaleFactorChanged {
-                scale_factor: scale,
-                new_inner_size: &mut new_size,
-            },
-        });
+        let new_size = {
+            let new_size = Arc::new(Mutex::new(current_size));
+            event_handler(crate::event::Event::WindowEvent {
+                window_id: RootWindowId(self.id),
+                event: crate::event::WindowEvent::ScaleFactorChanged {
+                    scale_factor: scale,
+                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_size)),
+                },
+            });
+
+            let new_size = *new_size.lock().unwrap();
+            new_size
+        };
 
         if current_size != new_size {
             // Then we resize the canvas to the new size, a new