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 aquire draw targets for
-each rendered frame and submit them to be drawn to the display
-*/
+/// The interface used to by the renderer to acquire draw targets for 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,10 +38,11 @@ pub struct Engine<C> {
     content_task: ContentTask
 }
 
-pub fn Engine<C:Compositor + Owned + Clone>(compositor: C,
+impl Engine {
+    pub fn start(compositor: CompositorImpl,
                  opts: &Opts,
-                                            dom_event_port: comm::Port<Event>,
-                                            dom_event_chan: comm::SharedChan<Event>,
+                 dom_event_port: Port<Event>,
+                 dom_event_chan: SharedChan<Event>,
                  resource_task: ResourceTask,
                  image_cache_task: ImageCacheTask)
                  -> EngineTask {
@@ -50,7 +52,10 @@ pub fn Engine<C:Compositor + Owned + Clone>(compositor: C,
         let opts = Cell(copy *opts);
         do spawn_listener::<Msg> |request| {
             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 opts = opts.take();
+            let layout_task = LayoutTask(render_task.clone(), image_cache_task.clone(), opts);
+
             let content_task = ContentTask(layout_task.clone(),
                                            dom_event_port.take(),
                                            dom_event_chan.take(),
@@ -64,12 +69,11 @@ pub fn Engine<C:Compositor + Owned + Clone>(compositor: C,
                 resource_task: resource_task.clone(),
                 image_cache_task: image_cache_task.clone(),
                 layout_task: layout_task,
-            content_task: content_task
-        }.run();
+                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,13 +82,13 @@ 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") {
                     self.content_task.send(ExecuteMsg(url))
                 } else {
                     self.content_task.send(ParseMsg(url))
                 }
-            return true;
+                return true
             }
 
             ExitMsg(sender) => {
@@ -100,7 +104,7 @@ impl<C:Compositor + Owned + Clone> Engine<C> {
                 self.resource_task.send(resource_task::Exit);
 
                 sender.send(());
-            return false;
+                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 engine::{Engine, LoadURLMsg};
+use compositing::{AddKeyHandler, CompositorImpl};
+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,16 +145,16 @@ 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();
-    osmain.chan.send(AddKeyHandler(keypress_to_engine));
+    let (keypress_from_compositor, keypress_to_engine) = comm::stream();
+    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,
                                     dom_event_port,
                                     dom_event_chan,
@@ -164,10 +164,10 @@ fn run_pipeline_screen(opts: &Opts) {
     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()),