Rename sink to compositor

src/servo/content.rs

@@ -19,7 +19,7 @@ import dom::base::{Node, NodeScope, define_bindings};
 import dom::event::{Event, ResizeEvent};
 import dom::style;
 import dom::style::Stylesheet;
-import gfx::renderer::Sink;
+import gfx::renderer::Compositor;
 import parser::html_lexer::spawn_html_lexer_task;
 import parser::html_builder::build_dom;
 import layout::layout_task;
@@ -74,8 +74,8 @@ struct Document {
     }
 }
 
-struct Content<S:Sink send copy> {
-    let sink: S;
+struct Content<C:Compositor send copy> {
+    let compositor: C;
     let layout: Layout;
     let from_master: comm::Port<ControlMsg>;
     let event_port: comm::Port<Event>;
@@ -88,10 +88,10 @@ struct Content<S:Sink send copy> {
 
     let resource_task: ResourceTask;
 
-    new(layout: Layout, sink: S, from_master: Port<ControlMsg>,
+    new(layout: Layout, compositor: C, from_master: Port<ControlMsg>,
         resource_task: ResourceTask) {
         self.layout = layout;
-        self.sink = sink;
+        self.compositor = compositor;
         self.from_master = from_master;
         self.event_port = port();
 
@@ -101,7 +101,7 @@ struct Content<S:Sink send copy> {
         self.document = none;
         self.doc_url = none;
 
-        self.sink.add_event_listener(self.event_port.chan());
+        self.compositor.add_event_listener(self.event_port.chan());
 
         self.resource_task = resource_task;
     }
@@ -233,9 +233,9 @@ struct Content<S:Sink send copy> {
     }
 }
 
-fn create_content<S: Sink send copy>(layout: Layout, sink: S, resource_task: ResourceTask) -> Chan<ControlMsg> {
+fn create_content<S: Compositor send copy>(layout: Layout, compositor: S, resource_task: ResourceTask) -> Chan<ControlMsg> {
     do spawn_listener::<ControlMsg> |from_master| {
-        Content(layout, sink, from_master, resource_task).start();
+        Content(layout, compositor, from_master, resource_task).start();
     }
 }
 

src/servo/engine.rs

@@ -1,4 +1,4 @@
-import gfx::renderer::{Renderer, Sink};
+import gfx::renderer::{Renderer, Compositor};
 import pipes::{spawn_service, select};
 import layout::layout_task;
 import layout_task::Layout;
@@ -15,23 +15,23 @@ fn macros() {
     include!("macros.rs");
 }
 
-struct Engine<S:Sink send copy> {
-    let sink: S;
+struct Engine<C:Compositor send copy> {
+    let compositor: C;
 
     let renderer: Renderer;
     let resource_task: ResourceTask;
     let image_cache_task: ImageCacheTask;
     let layout: Layout;
     let content: comm::Chan<content::ControlMsg>;
 
-    new(+sink: S) {
-        self.sink = sink;
+    new(+compositor: C) {
+        self.compositor = compositor;
 
-        let renderer = Renderer(sink);
+        let renderer = Renderer(compositor);
         let resource_task = ResourceTask();
         let image_cache_task = image_cache_task(resource_task);
         let layout = Layout(renderer, image_cache_task);
-        let content = create_content(layout, sink, resource_task);
+        let content = create_content(layout, compositor, resource_task);
 
         self.renderer = renderer;
         self.resource_task = resource_task;

src/servo/gfx/pngsink.rs → src/servo/gfx/png_compositor.rs

@@ -1,11 +1,11 @@
 #[doc = "
-A graphics sink that renders to PNG format buffers
+A graphics compositor that renders to PNG format buffers
 
-Each time the renderer renders a frame the bufsink will output a
+Each time the renderer renders a frame the compositor will output a
 `~[u8]` containing the frame in PNG format.
 "];
 
-export PngSink, Msg, Exit;
+export PngCompositor, Msg, Exit;
 
 import libc::{c_int, c_uint, c_void, c_uchar};
 import azure_bg = azure::bindgen;
@@ -17,7 +17,7 @@ import cairo::{CAIRO_FORMAT_ARGB32, cairo_surface_t, cairo_status_t, CAIRO_STATU
 import cairo_bg = cairo::bindgen;
 import cairo_bg::{cairo_image_surface_create, cairo_surface_destroy,
                   cairo_surface_write_to_png_stream};
-import renderer::{Renderer, Sink, RenderMsg};
+import renderer::{Renderer, Compositor, RenderMsg};
 import task::spawn_listener;
 import comm::{Chan, Port, chan, port};
 import unsafe::reinterpret_cast;
@@ -28,39 +28,39 @@ import dvec::dvec;
 import layout::display_list::display_list;
 import std::cell::Cell;
 
-type PngSink = Chan<Msg>;
+type PngCompositor = Chan<Msg>;
 
 enum Msg {
     BeginDrawing(pipes::chan<DrawTarget>),
     Draw(pipes::chan<DrawTarget>, DrawTarget),
     Exit
 }
 
-impl Chan<Msg> : Sink {
+impl Chan<Msg> : Compositor {
     fn begin_drawing(+next_dt: pipes::chan<DrawTarget>) {
         self.send(BeginDrawing(next_dt))
     }
     fn draw(+next_dt: pipes::chan<DrawTarget>, +draw_me: DrawTarget) {
         self.send(Draw(next_dt, draw_me))
     }
     fn add_event_listener(_listener: Chan<Event>) {
-        // No events in this sink.
+        // No events in this compositor.
     }
 }
 
-fn PngSink(output: Chan<~[u8]>) -> PngSink {
+fn PngCompositor(output: Chan<~[u8]>) -> PngCompositor {
     do spawn_listener |po: Port<Msg>| {
         let cairo_surface = ImageSurface(CAIRO_FORMAT_ARGB32, 800, 600);
         let draw_target = Cell(DrawTarget(cairo_surface));
 
         loop {
             match po.recv() {
                 BeginDrawing(sender) => {
-                    debug!("pngsink: begin_drawing");
+                    debug!("png_compositor: begin_drawing");
                     sender.send(draw_target.take());
                 }
                 Draw(sender, dt) => {
-                    debug!("pngsink: draw");
+                    debug!("png_compositor: draw");
                     do_draw(sender, dt.clone(), output, cairo_surface);
                 }
                 Exit => break
@@ -85,15 +85,15 @@ fn do_draw(sender: pipes::chan<DrawTarget>,
 #[test]
 fn sanity_check() {
     do listen |self_channel| {
-        let sink = PngSink(self_channel);
-        let renderer = Renderer(sink);
+        let compositor = PngCompositor(self_channel);
+        let renderer = Renderer(compositor);
 
         let dlist : display_list = dvec();
         renderer.send(RenderMsg(dlist));
         let (exit_chan, exit_response_from_engine) = pipes::stream();
         renderer.send(renderer::ExitMsg(exit_chan));
         exit_response_from_engine.recv();
 
-        sink.send(Exit)
+        compositor.send(Exit)
     }
 }

src/servo/gfx/renderer.rs

@@ -31,24 +31,22 @@ enum Msg {
 #[doc = "
 The interface used to by the renderer to aquire draw targets for
 each rendered frame and submit them to be drawn to the display
-
-FIXME: Change this name to Compositor.
 "]
-trait Sink {
+trait Compositor {
     fn begin_drawing(+next_dt: pipes::chan<DrawTarget>);
     fn draw(+next_dt: pipes::chan<DrawTarget>, +draw_me: DrawTarget);
     fn add_event_listener(listener: comm::Chan<Event>);
 }
 
-fn Renderer<S: Sink send copy>(sink: S) -> comm::Chan<Msg> {
+fn Renderer<C: Compositor send copy>(compositor: C) -> comm::Chan<Msg> {
     do task::spawn_listener |po: comm::Port<Msg>| {
         let (draw_target_ch, draw_target_po) = pipes::stream();
         let mut draw_target_ch = draw_target_ch;
         let mut draw_target_po = draw_target_po;
 
         debug!("renderer: beginning rendering loop");
 
-        sink.begin_drawing(draw_target_ch);
+        compositor.begin_drawing(draw_target_ch);
 
         loop {
             match po.recv() {
@@ -70,7 +68,7 @@ fn Renderer<S: Sink send copy>(sink: S) -> comm::Chan<Msg> {
                     }
 
                     #debug("renderer: returning surface");
-                    sink.draw(draw_target_ch, draw_target.take());
+                    compositor.draw(draw_target_ch, draw_target.take());
                 }
               }
               ExitMsg(response_ch) => {

src/servo/platform/osmain.rs

@@ -10,7 +10,7 @@ import azure::cairo_hl::ImageSurface;
 import comm::*;
 import dvec::{DVec, dvec};
 import azure::cairo::cairo_surface_t;
-import gfx::renderer::Sink;
+import gfx::renderer::Compositor;
 import dom::event::{Event, ResizeEvent};
 import layers::ImageLayer;
 import geom::size::Size2D;
@@ -122,9 +122,9 @@ fn mainloop(po: Port<Msg>) {
 
 #[doc = "
 Implementation to allow the osmain channel to be used as a graphics
-sink for the renderer
+compositor for the renderer
 "]
-impl OSMain : Sink {
+impl OSMain : Compositor {
     fn begin_drawing(+next_dt: pipes::chan<DrawTarget>) {
         self.send(BeginDrawing(next_dt))
     }

src/servo/servo.rc

@@ -33,7 +33,7 @@ mod gfx {
     mod geometry;
     mod surface;
     mod renderer;
-    mod pngsink;
+    mod png_compositor;
 }
 
 mod image {

src/servo/servo.rs

@@ -67,26 +67,26 @@ fn run_pipeline_screen(urls: ~[~str]) {
 
 fn run_pipeline_png(-url: ~str, outfile: ~str) {
 
-    // Use a PNG encoder as the graphics sink
-    import gfx::pngsink;
-    import pngsink::PngSink;
+    // Use a PNG encoder as the graphics compositor
+    import gfx::png_compositor;
+    import png_compositor::PngCompositor;
     import result::{ok, err};
     import io::{Writer, buffered_file_writer};
 
-    listen(|pngdata_from_sink| {
-        let sink = PngSink(pngdata_from_sink);
-        let engine = Engine(sink);
+    listen(|pngdata_from_compositor| {
+        let compositor = PngCompositor(pngdata_from_compositor);
+        let engine = Engine(compositor);
         let engine_chan = engine.start();
         let engine_chan =
             EngineProto::client::LoadURL(engine_chan, make_url(url, none));
 
         match buffered_file_writer(outfile) {
-          ok(writer) => writer.write(pngdata_from_sink.recv()),
+          ok(writer) => writer.write(pngdata_from_compositor.recv()),
           err(e) => fail e
         }
 
         let engine_chan = EngineProto::client::Exit(engine_chan);
         pipes::recv(engine_chan);
-        sink.send(pngsink::Exit);
+        compositor.send(png_compositor::Exit);
     })
 }