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/ios/app_state.rs

@@ -6,6 +6,7 @@ use std::{
     mem,
     os::raw::c_void,
     ptr,
+    sync::{Arc, Mutex},
     time::Instant,
 };
 
@@ -25,7 +26,7 @@ use super::uikit::UIView;
 use super::view::WinitUIWindow;
 use crate::{
     dpi::LogicalSize,
-    event::{Event, StartCause, WindowEvent},
+    event::{Event, InnerSizeWriter, StartCause, WindowEvent},
     event_loop::ControlFlow,
     platform_impl::platform::{
         event_loop::{EventHandler, EventProxy, EventWrapper, Never},
@@ -57,7 +58,7 @@ enum UserCallbackTransitionResult<'a> {
     },
 }
 
-impl Event<'static, Never> {
+impl Event<Never> {
     fn is_redraw(&self) -> bool {
         matches!(self, Event::RedrawRequested(_))
     }
@@ -807,18 +808,18 @@ fn handle_hidpi_proxy(
     scale_factor: f64,
     window: Id<WinitUIWindow>,
 ) {
-    let mut size = suggested_size.to_physical(scale_factor);
-    let new_inner_size = &mut size;
+    let new_inner_size = Arc::new(Mutex::new(suggested_size.to_physical(scale_factor)));
     let event = Event::WindowEvent {
         window_id: RootWindowId(window.id()),
         event: WindowEvent::ScaleFactorChanged {
             scale_factor,
-            new_inner_size,
+            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
         },
     };
     event_handler.handle_nonuser_event(event, &mut control_flow);
     let (view, screen_frame) = get_view_and_screen_frame(&window);
-    let physical_size = *new_inner_size;
+    let physical_size = *new_inner_size.lock().unwrap();
+    drop(new_inner_size);
     let logical_size = physical_size.to_logical(scale_factor);
     let size = CGSize::new(logical_size.width, logical_size.height);
     let new_frame: CGRect = CGRect::new(screen_frame.origin, size);

src/platform_impl/ios/event_loop.rs

@@ -33,7 +33,7 @@ use crate::{
 
 #[derive(Debug)]
 pub(crate) enum EventWrapper {
-    StaticEvent(Event<'static, Never>),
+    StaticEvent(Event<Never>),
     EventProxy(EventProxy),
 }
 
@@ -106,7 +106,7 @@ impl<T: 'static> 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),
     {
         unsafe {
             let application = UIApplication::shared(MainThreadMarker::new().unwrap());
@@ -315,7 +315,7 @@ fn setup_control_flow_observers() {
 pub enum Never {}
 
 pub trait EventHandler: Debug {
-    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
+    fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow);
     fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
 }
 
@@ -334,10 +334,10 @@ impl<F, T: 'static> Debug for EventLoopHandler<F, T> {
 
 impl<F, T> EventHandler for EventLoopHandler<F, T>
 where
-    F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+    F: 'static + FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     T: 'static,
 {
-    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
+    fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow) {
         (self.f)(
             event.map_nonuser_event().unwrap(),
             &self.event_loop,

src/platform_impl/ios/mod.rs

@@ -89,7 +89,7 @@ pub(crate) use self::{
 
 use self::uikit::UIScreen;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
-pub(self) use crate::platform_impl::Fullscreen;
+pub(crate) use crate::platform_impl::Fullscreen;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId {