From ea4b1631dd3e2564c8406267e1a0c3751be3d4bc Mon Sep 17 00:00:00 2001
From: Alan Jeffrey <ajeffrey@mozilla.com>
Date: Fri, 14 Jun 2019 14:13:41 -0500
Subject: [PATCH 1/3] Don't process events while borrowing the event loop

---
 ports/glutin/app.rs | 30 +++++++++++-------------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/ports/glutin/app.rs b/ports/glutin/app.rs
index ac219003988..babc44d5b3f 100644
--- a/ports/glutin/app.rs
+++ b/ports/glutin/app.rs
@@ -101,29 +101,21 @@ impl App {
     }
 
     fn run_loop(self) {
-        let mut stop = false;
         loop {
-            let mut events_loop = self.events_loop.borrow_mut();
-            if self.window.is_animating() && !self.suspended.get() {
-                // We block on compositing (self.handle_events() ends up calling swap_buffers)
-                events_loop.poll_events(|e| {
+            if !self.window.is_animating()  || self.suspended.get() {
+                // If there's no animations running then we block on the window event loop.
+                self.events_loop.borrow_mut().run_forever(|e| {
                     self.winit_event_to_servo_event(e);
-                });
-                stop = self.handle_events();
-            } else {
-                // We block on winit's event loop (window events)
-                events_loop.run_forever(|e| {
-                    self.winit_event_to_servo_event(e);
-                    if self.has_events() && !self.suspended.get() {
-                        stop = self.handle_events();
-                    }
-                    if stop || self.window.is_animating() && !self.suspended.get() {
-                        glutin::ControlFlow::Break
-                    } else {
-                        glutin::ControlFlow::Continue
-                    }
+                    glutin::ControlFlow::Break
                 });
             }
+            // Grab any other events that may have happened
+            self.events_loop.borrow_mut().poll_events(|e| {
+                self.winit_event_to_servo_event(e);
+            });
+            // If animations are running, we block on compositing
+            // (self.handle_events() ends up calling swap_buffers)
+            let stop = self.handle_events();
             if stop {
                 break;
             }

From 373ae0e341c18f8380c8031075d201a59ae9180d Mon Sep 17 00:00:00 2001
From: Alan Jeffrey <ajeffrey@mozilla.com>
Date: Wed, 26 Jun 2019 10:13:22 -0500
Subject: [PATCH 2/3] Handle resize events during run_forever

---
 ports/glutin/app.rs | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/ports/glutin/app.rs b/ports/glutin/app.rs
index babc44d5b3f..8292f5912be 100644
--- a/ports/glutin/app.rs
+++ b/ports/glutin/app.rs
@@ -73,7 +73,8 @@ impl App {
         !self.event_queue.borrow().is_empty() || self.window.has_events()
     }
 
-    fn winit_event_to_servo_event(&self, event: glutin::Event) {
+    // This function decides whether the event should be handled during `run_forever`.
+    fn winit_event_to_servo_event(&self, event: glutin::Event) -> glutin::ControlFlow {
         match event {
             // App level events
             glutin::Event::Suspended(suspended) => {
@@ -94,10 +95,18 @@ impl App {
                 if Some(window_id) != self.window.id() {
                     warn!("Got an event from unknown window");
                 } else {
+                    // Resize events need to be handled during run_forever
+                    let cont = if let glutin::WindowEvent::Resized(_) = event {
+                        glutin::ControlFlow::Continue
+                    } else {
+                        glutin::ControlFlow::Break
+                    };
                     self.window.winit_event_to_servo_event(event);
+                    return cont;
                 }
             },
         }
+        glutin::ControlFlow::Break
     }
 
     fn run_loop(self) {
@@ -105,8 +114,15 @@ impl App {
             if !self.window.is_animating()  || self.suspended.get() {
                 // If there's no animations running then we block on the window event loop.
                 self.events_loop.borrow_mut().run_forever(|e| {
-                    self.winit_event_to_servo_event(e);
-                    glutin::ControlFlow::Break
+                    let cont = self.winit_event_to_servo_event(e);
+                    if cont == glutin::ControlFlow::Continue {
+                        // Note we need to be careful to make sure that any events
+                        // that are handled during run_forever aren't re-entrant,
+                        // since we are handling them while holding onto a mutable borrow
+                        // of the events loop
+                        self.handle_events();
+                    }
+                    cont
                 });
             }
             // Grab any other events that may have happened

From f2a64db15113d0b531fd4fcfc389d96790817cf9 Mon Sep 17 00:00:00 2001
From: Alan Jeffrey <ajeffrey@mozilla.com>
Date: Mon, 1 Jul 2019 09:00:59 -0500
Subject: [PATCH 3/3] Dead code elimination

---
 ports/glutin/app.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/ports/glutin/app.rs b/ports/glutin/app.rs
index 8292f5912be..c8fc807f4f2 100644
--- a/ports/glutin/app.rs
+++ b/ports/glutin/app.rs
@@ -69,10 +69,6 @@ impl App {
         mem::replace(&mut *self.event_queue.borrow_mut(), Vec::new())
     }
 
-    fn has_events(&self) -> bool {
-        !self.event_queue.borrow().is_empty() || self.window.has_events()
-    }
-
     // This function decides whether the event should be handled during `run_forever`.
     fn winit_event_to_servo_event(&self, event: glutin::Event) -> glutin::ControlFlow {
         match event {