compositing: Support multiple events per frame.

Improves scrolling performance on Mac.

ports/cef/browser.rs

@@ -32,8 +32,8 @@ pub enum ServoBrowser {
 impl ServoBrowser {
     fn handle_event(&mut self, event: WindowEvent) {
         match *self {
-            ServoBrowser::OnScreen(ref mut browser) => { browser.handle_event(event); }
-            ServoBrowser::OffScreen(ref mut browser) => { browser.handle_event(event); }
+            ServoBrowser::OnScreen(ref mut browser) => { browser.handle_events(vec![event]); }
+            ServoBrowser::OffScreen(ref mut browser) => { browser.handle_events(vec![event]); }
             ServoBrowser::Invalid => {}
         }
     }

ports/cef/window.rs

@@ -100,8 +100,8 @@ impl Window {
     }
 
     /// Currently unimplemented.
-    pub fn wait_events(&self) -> WindowEvent {
-        WindowEvent::Idle
+    pub fn wait_events(&self) -> Vec<WindowEvent> {
+        vec![WindowEvent::Idle]
     }
 
     fn cursor_type_for_cursor(&self, cursor: Cursor) -> cef_cursor_type_t {

ports/glutin/window.rs

@@ -14,13 +14,15 @@ use layers::geometry::DevicePixel;
 use layers::platform::surface::NativeGraphicsMetadata;
 use msg::constellation_msg;
 use msg::constellation_msg::Key;
-use NestedEventLoopListener;
+use std::mem;
 use std::rc::Rc;
 use std::sync::mpsc::{channel, Sender};
 use url::Url;
 use util::cursor::Cursor;
 use util::geometry::ScreenPx;
 
+use NestedEventLoopListener;
+
 #[cfg(feature = "window")]
 use compositing::windowing::{MouseWindowEvent, WindowNavigateMsg};
 #[cfg(feature = "window")]
@@ -259,7 +261,16 @@ impl Window {
     #[cfg(target_os="macos")]
     fn handle_next_event(&self) -> bool {
         let event = self.window.wait_events().next().unwrap();
-        self.handle_window_event(event)
+        let mut close = self.handle_window_event(event);
+        if !close {
+            while let Some(event) = self.window.poll_events().next() {
+                if self.handle_window_event(event) {
+                    close = true;
+                    break
+                }
+            }
+        }
+        close
     }
 
     #[cfg(any(target_os="linux", target_os="android"))]
@@ -283,7 +294,9 @@ impl Window {
         //
         // See https://github.com/servo/servo/issues/5780
         //
-        match self.window.poll_events().next() {
+        let first_event = self.window.poll_events().next();
+
+        match first_event {
             Some(event) => {
                 self.handle_window_event(event)
             }
@@ -294,40 +307,27 @@ impl Window {
         }
     }
 
-    pub fn wait_events(&self) -> WindowEvent {
-        {
-            let mut event_queue = self.event_queue.borrow_mut();
-            if !event_queue.is_empty() {
-                return event_queue.remove(0);
-            }
-        }
-
+    pub fn wait_events(&self) -> Vec<WindowEvent> {
+        let mut events = mem::replace(&mut *self.event_queue.borrow_mut(), Vec::new());
         let mut close_event = false;
 
         // When writing to a file then exiting, use event
         // polling so that we don't block on a GUI event
         // such as mouse click.
         if opts::get().output_file.is_some() {
-            for event in self.window.poll_events() {
-                close_event = self.handle_window_event(event);
-                if close_event {
-                    break;
-                }
+            while let Some(event) = self.window.poll_events().next() {
+                close_event = self.handle_window_event(event) || close_event;
             }
         } else {
             close_event = self.handle_next_event();
         }
 
         if close_event || self.window.is_closed() {
-            WindowEvent::Quit
-        } else {
-            let mut event_queue = self.event_queue.borrow_mut();
-            if event_queue.is_empty() {
-                WindowEvent::Idle
-            } else {
-                event_queue.remove(0)
-            }
+            events.push(WindowEvent::Quit)
         }
+
+        events.extend(mem::replace(&mut *self.event_queue.borrow_mut(), Vec::new()).into_iter());
+        events
     }
 
     pub unsafe fn set_nested_event_loop_listener(
@@ -634,8 +634,8 @@ impl Window {
         Rc::new(window)
     }
 
-    pub fn wait_events(&self) -> WindowEvent {
-        WindowEvent::Idle
+    pub fn wait_events(&self) -> Vec<WindowEvent> {
+        vec![WindowEvent::Idle]
     }
 
     pub unsafe fn set_nested_event_loop_listener(

ports/gonk/src/main.rs

@@ -76,16 +76,16 @@ fn main() {
             Some(ref window) => input::run_input_loop(&window.event_send)
         }
 
-        browser.browser.handle_event(WindowEvent::InitializeCompositing);
+        browser.browser.handle_events(vec![WindowEvent::InitializeCompositing]);
 
         // Feed events from the window to the browser until the browser
         // says to stop.
         loop {
             let should_continue = match window {
-                None => browser.browser.handle_event(WindowEvent::Idle),
+                None => browser.browser.handle_events(vec![WindowEvent::Idle]),
                 Some(ref window) => {
-                    let event = window.wait_events();
-                    browser.browser.handle_event(event)
+                    let events = window.wait_events();
+                    browser.browser.handle_events(events)
                 }
             };
             if !should_continue {

ports/gonk/src/window.rs

@@ -754,8 +754,8 @@ impl Window {
         Rc::new(window)
     }
 
-    pub fn wait_events(&self) -> WindowEvent {
-        self.event_recv.recv().unwrap()
+    pub fn wait_events(&self) -> Vec<WindowEvent> {
+        vec![self.event_recv.recv().unwrap()]
     }
 }