Refactor RenderTask into a struct

src/servo/engine.rs

@@ -1,6 +1,6 @@
 use gfx::compositor::Compositor;
 use mod gfx::render_task;
-use gfx::render_task::{Renderer, RenderTask};
+use gfx::render_task::RenderTask;
 use task::spawn_listener;
 use layout::layout_task;
 use layout_task::LayoutTask;
@@ -25,7 +25,7 @@ pub enum Msg {
 struct Engine<C:Compositor Send Copy> {
     request_port: comm::Port<Msg>,
     compositor: C,
-    render_task: Renderer,
+    render_task: RenderTask,
     resource_task: ResourceTask,
     image_cache_task: ImageCacheTask,
     layout_task: LayoutTask,

src/servo/gfx/render_task.rs

@@ -1,9 +1,10 @@
 use au = gfx::geometry;
 use au::au;
 use comm::*;
-use compositor::Compositor;
+use compositor::{Compositor, LayerBuffer};
 use dl = display_list;
 use mod gfx::render_layers;
+use render_layers::render_layers;
 use gfx::render_layers::RenderLayer;
 use libc::size_t;
 use libc::types::common::c99::uint16_t;
@@ -13,8 +14,6 @@ use std::cell::Cell;
 use text::font_cache::FontCache;
 use render_context::RenderContext;
 
-pub type Renderer = comm::Chan<Msg>;
-
 pub enum Msg {
     RenderMsg(RenderLayer),
     ExitMsg(pipes::Chan<()>)
@@ -25,54 +24,32 @@ pub type RenderTask = comm::Chan<Msg>;
 pub fn RenderTask<C: Compositor Send>(compositor: C) -> RenderTask {
     do task::spawn_listener |po: comm::Port<Msg>| {
         let (layer_buffer_channel, layer_buffer_port) = pipes::stream();
-        let mut layer_buffer_channel = layer_buffer_channel;
-        let mut layer_buffer_port = layer_buffer_port;
-
-        let font_cache = FontCache();
-
-        debug!("renderer: beginning rendering loop");
 
         compositor.begin_drawing(move layer_buffer_channel);
 
+        Renderer {
+            port: po,
+            compositor: compositor,
+            mut layer_buffer_port: Cell(layer_buffer_port),
+            font_cache: FontCache(),
+        }.start();
+    }
+}
+
+priv struct Renderer<C: Compositor Send> {
+    port: comm::Port<Msg>,
+    compositor: C,
+    layer_buffer_port: Cell<pipes::Port<LayerBuffer>>,
+    font_cache: @FontCache
+}
+
+impl<C: Compositor Send> Renderer<C> {
+    fn start() {
+        debug!("renderer: beginning rendering loop");
+
         loop {
-            match po.recv() {
+            match self.port.recv() {
-                RenderMsg(move render_layer) => {
+                RenderMsg(move render_layer) => self.render(render_layer),
-                    debug!("renderer: got render request");
-
-                    if !layer_buffer_port.peek() {
-                        warn!("renderer: waiting on layer buffer");
-                    }
-
-                    let layer_buffer_cell = Cell(layer_buffer_port.recv());
-
-                    let (layer_buffer_channel, new_layer_buffer_port) = pipes::stream();
-                    let layer_buffer_channel = Cell(move layer_buffer_channel);
-                    layer_buffer_port = new_layer_buffer_port;
-
-                    let render_layer = Cell(move render_layer);
-
-                    #debug("renderer: rendering");
-
-                    do util::time::time(~"rendering") {
-                        let layer_buffer = layer_buffer_cell.take();
-                        let render_layer = move render_layer.take();
-
-                        let layer_buffer =
-                                for render_layers::render_layers(&render_layer, move layer_buffer)
-                                |render_layer, layer_buffer| {
-                            let ctx = RenderContext {
-                                canvas: layer_buffer,
-                                font_cache: font_cache
-                            };
-
-                            ctx.clear();
-                            render_layer.display_list.draw(&ctx);
-                        };
-
-                        #debug("renderer: returning surface");
-                        compositor.draw(layer_buffer_channel.take(), move layer_buffer);
-                    }
-                }
                 ExitMsg(response_ch) => {
                     response_ch.send(());
                     break;
@@ -80,4 +57,43 @@ pub fn RenderTask<C: Compositor Send>(compositor: C) -> RenderTask {
             }
         }
     }
-}
+
+    fn render(render_layer: RenderLayer) {
+        debug!("renderer: got render request");
+
+        let layer_buffer_port = self.layer_buffer_port.take();
+
+        if !layer_buffer_port.peek() {
+            warn!("renderer: waiting on layer buffer");
+        }
+
+        let layer_buffer = layer_buffer_port.recv();
+        let (layer_buffer_channel, new_layer_buffer_port) = pipes::stream();
+        self.layer_buffer_port.put_back(new_layer_buffer_port);
+
+        let render_layer_cell = Cell(move render_layer);
+        let layer_buffer_cell = Cell(layer_buffer);
+        let layer_buffer_channel_cell = Cell(move layer_buffer_channel);
+
+        #debug("renderer: rendering");
+
+        do util::time::time(~"rendering") {
+            let render_layer = render_layer_cell.take();
+            let layer_buffer = layer_buffer_cell.take();
+            let layer_buffer_channel = layer_buffer_channel_cell.take();
+
+            let layer_buffer = for render_layers(&render_layer, move layer_buffer) |render_layer, layer_buffer| {
+                let ctx = RenderContext {
+                    canvas: layer_buffer,
+                    font_cache: self.font_cache
+                };
+
+                ctx.clear();
+                render_layer.display_list.draw(&ctx);
+            };
+
+            #debug("renderer: returning surface");
+            self.compositor.draw(layer_buffer_channel, move layer_buffer);
+        }
+    }
+}