Removed CompositorEventListener trait

components/compositing/compositor.rs

@@ -6,8 +6,8 @@ use CompositionPipeline;
 use SendableFrameTree;
 use app_units::Au;
 use compositor_layer::{CompositorData, CompositorLayer, RcCompositorLayer, WantsScrollEventsFlag};
-use compositor_thread::{CompositorEventListener, CompositorProxy};
+use compositor_thread::{CompositorProxy, CompositorReceiver};
-use compositor_thread::{CompositorReceiver, InitialCompositorState, Msg, RenderListener};
+use compositor_thread::{InitialCompositorState, Msg, RenderListener};
 use delayed_composition::DelayedCompositionTimerProxy;
 use euclid::point::TypedPoint2D;
 use euclid::rect::TypedRect;
@@ -2443,31 +2443,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             webrender_api.tick_scrolling_bounce_animations()
         }
     }
-}
 
-fn find_layer_with_pipeline_and_layer_id_for_layer(layer: Rc<Layer<CompositorData>>,
+    pub fn handle_events(&mut self, messages: Vec<WindowEvent>) -> bool {
-                                                   pipeline_id: PipelineId,
-                                                   layer_id: LayerId)
-                                                   -> Option<Rc<Layer<CompositorData>>> {
-    if layer.extra_data.borrow().pipeline_id == pipeline_id &&
-       layer.extra_data.borrow().id == layer_id {
-        return Some(layer);
-    }
-
-    for kid in &*layer.children() {
-        let result = find_layer_with_pipeline_and_layer_id_for_layer(kid.clone(),
-                                                                     pipeline_id,
-                                                                     layer_id);
-        if result.is_some() {
-            return result;
-        }
-    }
-
-    None
-}
-
-impl<Window> CompositorEventListener for IOCompositor<Window> where Window: WindowMethods {
-    fn handle_events(&mut self, messages: Vec<WindowEvent>) -> bool {
         // Check for new messages coming from the other threads in the system.
         while let Some(msg) = self.port.try_recv_compositor_msg() {
             if !self.handle_browser_message(msg) {
@@ -2510,7 +2487,7 @@ impl<Window> CompositorEventListener for IOCompositor<Window> where Window: Wind
     /// paint is not scheduled the compositor will hang forever.
     ///
     /// This is used when resizing the window.
-    fn repaint_synchronously(&mut self) {
+    pub fn repaint_synchronously(&mut self) {
         if self.webrender.is_none() {
             while self.shutdown_state != ShutdownState::ShuttingDown {
                 let msg = self.port.recv_compositor_msg();
@@ -2546,11 +2523,11 @@ impl<Window> CompositorEventListener for IOCompositor<Window> where Window: Wind
         }
     }
 
-    fn pinch_zoom_level(&self) -> f32 {
+    pub fn pinch_zoom_level(&self) -> f32 {
         self.viewport_zoom.get() as f32
     }
 
-    fn title_for_main_frame(&self) {
+    pub fn title_for_main_frame(&self) {
         let root_pipeline_id = match self.root_pipeline {
             None => return,
             Some(ref root_pipeline) => root_pipeline.id,
@@ -2562,6 +2539,27 @@ impl<Window> CompositorEventListener for IOCompositor<Window> where Window: Wind
     }
 }
 
+fn find_layer_with_pipeline_and_layer_id_for_layer(layer: Rc<Layer<CompositorData>>,
+                                                   pipeline_id: PipelineId,
+                                                   layer_id: LayerId)
+                                                   -> Option<Rc<Layer<CompositorData>>> {
+    if layer.extra_data.borrow().pipeline_id == pipeline_id &&
+       layer.extra_data.borrow().id == layer_id {
+        return Some(layer);
+    }
+
+    for kid in &*layer.children() {
+        let result = find_layer_with_pipeline_and_layer_id_for_layer(kid.clone(),
+                                                                     pipeline_id,
+                                                                     layer_id);
+        if result.is_some() {
+            return result;
+        }
+    }
+
+    None
+}
+
 /// Why we performed a composite. This is used for debugging.
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum CompositingReason {

components/compositing/compositor_thread.rs

@@ -5,7 +5,7 @@
 //! Communication with the compositor thread.
 
 use SendableFrameTree;
-use compositor::{self, CompositingReason};
+use compositor::{CompositingReason, IOCompositor};
 use euclid::point::Point2D;
 use euclid::size::Size2D;
 use gfx_traits::{Epoch, FrameTreeId, LayerId, LayerProperties, PaintListener};
@@ -24,7 +24,7 @@ use style_traits::viewport::ViewportConstraints;
 use url::Url;
 use webrender;
 use webrender_traits;
-use windowing::{WindowEvent, WindowMethods};
+use windowing::WindowMethods;
 
 /// Sends messages to the compositor. This is a trait supplied by the port because the method used
 /// to communicate with the compositor may have to kick OS event loops awake, communicate cross-
@@ -236,21 +236,12 @@ pub struct CompositorThread;
 impl CompositorThread {
     pub fn create<Window>(window: Rc<Window>,
                           state: InitialCompositorState)
-                          -> Box<CompositorEventListener + 'static>
+                          -> IOCompositor<Window>
                           where Window: WindowMethods + 'static {
-        box compositor::IOCompositor::create(window, state)
+        IOCompositor::create(window, state)
-            as Box<CompositorEventListener>
     }
 }
 
-pub trait CompositorEventListener {
-    fn handle_events(&mut self, events: Vec<WindowEvent>) -> bool;
-    fn repaint_synchronously(&mut self);
-    fn pinch_zoom_level(&self) -> f32;
-    /// Requests that the compositor send the title for the main frame as soon as possible.
-    fn title_for_main_frame(&self);
-}
-
 /// Data used to construct a compositor.
 pub struct InitialCompositorState {
     /// A channel to the compositor.

components/compositing/lib.rs

@@ -36,7 +36,8 @@ extern crate util;
 extern crate webrender;
 extern crate webrender_traits;
 
-pub use compositor_thread::{CompositorEventListener, CompositorProxy, CompositorThread};
+pub use compositor_thread::{CompositorProxy, CompositorThread};
+pub use compositor::IOCompositor;
 use euclid::size::TypedSize2D;
 use gfx::paint_thread::ChromeToPaintMsg;
 use ipc_channel::ipc::IpcSender;

components/servo/lib.rs

@@ -57,11 +57,10 @@ fn webdriver(port: u16, constellation: Sender<ConstellationMsg>) {
 #[cfg(not(feature = "webdriver"))]
 fn webdriver(_port: u16, _constellation: Sender<ConstellationMsg>) { }
 
-use compositing::CompositorEventListener;
 use compositing::compositor_thread::InitialCompositorState;
 use compositing::windowing::WindowEvent;
 use compositing::windowing::WindowMethods;
-use compositing::{CompositorProxy, CompositorThread};
+use compositing::{CompositorProxy, CompositorThread, IOCompositor};
 #[cfg(not(target_os = "windows"))]
 use constellation::content_process_sandbox_profile;
 use constellation::{Constellation, InitialConstellationState, UnprivilegedPipelineContent};
@@ -97,13 +96,12 @@ pub use gleam::gl;
 /// application Servo is embedded in. Clients then create an event
 /// loop to pump messages between the embedding application and
 /// various browser components.
-pub struct Browser {
+pub struct Browser<Window: WindowMethods + 'static> {
-    compositor: Box<CompositorEventListener + 'static>,
+    compositor: IOCompositor<Window>,
 }
 
-impl Browser {
+impl<Window> Browser<Window> where Window: WindowMethods + 'static {
-    pub fn new<Window>(window: Rc<Window>) -> Browser
+    pub fn new(window: Rc<Window>) -> Browser<Window> {
-                       where Window: WindowMethods + 'static {
         // Global configuration options, parsed from the command line.
         let opts = opts::get();
 

components/servo/main.rs

@@ -98,7 +98,7 @@ fn unregister_glutin_resize_handler(window: &Rc<app::window::Window>) {
 }
 
 struct BrowserWrapper {
-    browser: Browser,
+    browser: Browser<app::window::Window>,
 }
 
 impl app::NestedEventLoopListener for BrowserWrapper {