servo: Remove the type parameter from the compositor, rename OSMain, and refactor engine a bit

src/servo-gfx/compositor.rs

@@ -21,10 +21,8 @@ pub struct LayerBufferSet {
     buffers: ~[LayerBuffer]
 }
 
-/**
+/// The interface used to by the renderer to acquire draw targets for each rendered frame and
-The interface used to by the renderer to aquire draw targets for
+/// submit them to be drawn to the display.
-each rendered frame and submit them to be drawn to the display
-*/
 pub trait Compositor {
     fn begin_drawing(&self, next_dt: comm::Chan<LayerBufferSet>);
     fn draw(&self, next_dt: comm::Chan<LayerBufferSet>, +draw_me: LayerBufferSet);

src/servo/engine.rs

@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use compositing::CompositorImpl;
 use content::content_task::{ContentTask, ExecuteMsg, ParseMsg};
 use content::content_task;
 use dom::event::Event;
@@ -13,7 +14,7 @@ use resource::resource_task;
 use util::task::spawn_listener;
 
 use core::cell::Cell;
-use core::comm::{Port, Chan};
+use core::comm::{Chan, Port, SharedChan};
 use gfx::compositor::Compositor;
 use gfx::opts::Opts;
 use gfx::render_task::RenderTask;
@@ -23,13 +24,13 @@ use std::net::url::Url;
 pub type EngineTask = Chan<Msg>;
 
 pub enum Msg {
-    LoadURLMsg(Url),
+    LoadUrlMsg(Url),
     ExitMsg(Chan<()>)
 }
 
-pub struct Engine<C> {
+pub struct Engine {
     request_port: Port<Msg>,
-    compositor: C,
+    compositor: CompositorImpl,
     render_task: RenderTask,
     resource_task: ResourceTask,
     image_cache_task: ImageCacheTask,
@@ -37,39 +38,42 @@ pub struct Engine<C> {
     content_task: ContentTask
 }
 
-pub fn Engine<C:Compositor + Owned + Clone>(compositor: C,
+impl Engine {
-                                            opts: &Opts,
+    pub fn start(compositor: CompositorImpl,
-                                            dom_event_port: comm::Port<Event>,
+                 opts: &Opts,
-                                            dom_event_chan: comm::SharedChan<Event>,
+                 dom_event_port: Port<Event>,
-                                            resource_task: ResourceTask,
+                 dom_event_chan: SharedChan<Event>,
-                                            image_cache_task: ImageCacheTask)
+                 resource_task: ResourceTask,
-                                         -> EngineTask {
+                 image_cache_task: ImageCacheTask)
-    let dom_event_port = Cell(dom_event_port);
+                 -> EngineTask {
-    let dom_event_chan = Cell(dom_event_chan);
+        let dom_event_port = Cell(dom_event_port);
+        let dom_event_chan = Cell(dom_event_chan);
 
-    let opts = Cell(copy *opts);
+        let opts = Cell(copy *opts);
-    do spawn_listener::<Msg> |request| {
+        do spawn_listener::<Msg> |request| {
-        let render_task = RenderTask(compositor.clone(), opts.with_ref(|o| copy *o));
+            let render_task = RenderTask(compositor.clone(), opts.with_ref(|o| copy *o));
-        let layout_task = LayoutTask(render_task.clone(), image_cache_task.clone(), opts.take());
-        let content_task = ContentTask(layout_task.clone(),
-                                       dom_event_port.take(),
-                                       dom_event_chan.take(),
-                                       resource_task.clone(),
-                                       image_cache_task.clone());
 
-        Engine {
+            let opts = opts.take();
-            request_port: request,
+            let layout_task = LayoutTask(render_task.clone(), image_cache_task.clone(), opts);
-            compositor: compositor.clone(),
+
-            render_task: render_task,
+            let content_task = ContentTask(layout_task.clone(),
-            resource_task: resource_task.clone(),
+                                           dom_event_port.take(),
-            image_cache_task: image_cache_task.clone(),
+                                           dom_event_chan.take(),
-            layout_task: layout_task,
+                                           resource_task.clone(),
-            content_task: content_task
+                                           image_cache_task.clone());
-        }.run();
+
+            Engine {
+                request_port: request,
+                compositor: compositor.clone(),
+                render_task: render_task,
+                resource_task: resource_task.clone(),
+                image_cache_task: image_cache_task.clone(),
+                layout_task: layout_task,
+                content_task: content_task,
+            }.run()
+        }
     }
-}
 
-impl<C:Compositor + Owned + Clone> Engine<C> {
     fn run(&self) {
         while self.handle_request(self.request_port.recv()) {
             // Go on...
@@ -78,30 +82,30 @@ impl<C:Compositor + Owned + Clone> Engine<C> {
 
     fn handle_request(&self, request: Msg) -> bool {
         match request {
-          LoadURLMsg(url) => {
+            LoadUrlMsg(url) => {
-            if url.path.ends_with(".js") {
+                if url.path.ends_with(".js") {
-                self.content_task.send(ExecuteMsg(url))
+                    self.content_task.send(ExecuteMsg(url))
-            } else {
+                } else {
-                self.content_task.send(ParseMsg(url))
+                    self.content_task.send(ParseMsg(url))
+                }
+                return true
             }
-            return true;
-          }
 
-          ExitMsg(sender) => {
+            ExitMsg(sender) => {
-            self.content_task.send(content_task::ExitMsg);
+                self.content_task.send(content_task::ExitMsg);
-            self.layout_task.send(layout_task::ExitMsg);
+                self.layout_task.send(layout_task::ExitMsg);
-            
-            let (response_port, response_chan) = comm::stream();
 
-            self.render_task.send(render_task::ExitMsg(response_chan));
+                let (response_port, response_chan) = comm::stream();
-            response_port.recv();
 
-            self.image_cache_task.exit();
+                self.render_task.send(render_task::ExitMsg(response_chan));
-            self.resource_task.send(resource_task::Exit);
+                response_port.recv();
 
-            sender.send(());
+                self.image_cache_task.exit();
-            return false;
+                self.resource_task.send(resource_task::Exit);
-          }
+
+                sender.send(());
+                return false
+            }
         }
     }
 }

src/servo/servo.rc

@@ -33,8 +33,8 @@ extern mod core_graphics;
 #[cfg(target_os="macos")]
 extern mod core_text;
 
-use compositing::{AddKeyHandler, OSMain};
+use compositing::{AddKeyHandler, CompositorImpl};
-use engine::{Engine, LoadURLMsg};
+use engine::{Engine, LoadUrlMsg};
 
 pub use gfx::opts::{Opts, Png, Screen};  // FIXME: Do we really want "Screen" and "Png" visible?
 pub use gfx::resource;
@@ -145,29 +145,29 @@ fn run_pipeline_screen(opts: &Opts) {
     let dom_event_chan = comm::SharedChan::new(dom_event_chan);
 
     // The platform event handler thread
-    let osmain = OSMain(dom_event_chan.clone(), copy *opts);
+    let compositor = CompositorImpl::new(dom_event_chan.clone(), copy *opts);
 
     // Send each file to render then wait for keypress
-    let (keypress_from_osmain, keypress_to_engine) = comm::stream();
+    let (keypress_from_compositor, keypress_to_engine) = comm::stream();
-    osmain.chan.send(AddKeyHandler(keypress_to_engine));
+    compositor.chan.send(AddKeyHandler(keypress_to_engine));
 
     // Create a servo instance
     let resource_task = ResourceTask();
     let image_cache_task = ImageCacheTask(resource_task.clone());
-    let engine_task = Engine(osmain.clone(),
+    let engine_task = Engine::start(compositor.clone(),
-                             opts,
+                                    opts,
-                             dom_event_port,
+                                    dom_event_port,
-                             dom_event_chan,
+                                    dom_event_chan,
-                             resource_task,
+                                    resource_task,
-                             image_cache_task);
+                                    image_cache_task);
 
     for opts.urls.each |filename| {
         let url = make_url(copy *filename, None);
         debug!("master: Sending url `%s`", url.to_str());
-        engine_task.send(LoadURLMsg(url));
+        engine_task.send(LoadUrlMsg(url));
         debug!("master: Waiting for keypress");
 
-        match keypress_from_osmain.try_recv() {
+        match keypress_from_compositor.try_recv() {
           Some(*) => { }
           None => { error!("keypress stream closed unexpectedly") }
         };
@@ -179,7 +179,7 @@ fn run_pipeline_screen(opts: &Opts) {
     engine_task.send(engine::ExitMsg(exit_chan));
     exit_response_from_engine.recv();
 
-    osmain.chan.send(compositing::Exit);
+    compositor.chan.send(compositing::Exit);
 }
 
 fn run_pipeline_png(_opts: &Opts, _outfile: &str) {
@@ -209,7 +209,7 @@ fn run_pipeline_png(url: ~str, outfile: &str) {
                                  dom_event_chan,
                                  resource_task,
                                  image_cache_task);
-        engine_task.send(LoadURLMsg(make_url(copy url, None)));
+        engine_task.send(LoadUrlMsg(make_url(copy url, None)));
 
         match buffered_file_writer(&Path(outfile)) {
           Ok(writer) => writer.write(pngdata_from_compositor.recv()),