Refactor compositing a bit to conform to modern Rust style

src/components/servo/compositing/mod.rs

@@ -17,8 +17,10 @@ use geom::rect::Rect;
 use geom::size::Size2D;
 use gfx::compositor::{Compositor, LayerBuffer, LayerBufferSet};
 use gfx::opts::Opts;
-use layers::layers::{Image, ImageData};
-use layers;
+use layers::layers::{ARGB32Format, BasicImageData, ContainerLayer, ContainerLayerKind, Format};
+use layers::layers::{Image, ImageData, ImageLayer, ImageLayerKind, RGB24Format, WithDataFn};
+use layers::rendergl;
+use layers::scene::Scene;
 use servo_util::{time, url};
 
 mod resize_rate_limiter;
@@ -35,7 +37,7 @@ impl CompositorImpl {
         let script_chan = Cell(script_chan);
         let chan: Chan<Msg> = do on_osmain |port| {
             debug!("preparing to enter main loop");
-            mainloop(port, script_chan.take(), &opts);
+            run_main_loop(port, script_chan.take(), &opts);
         };
 
         CompositorImpl {
@@ -59,59 +61,51 @@ struct AzureDrawTargetImageData {
     size: Size2D<uint>
 }
 
-impl layers::layers::ImageData for AzureDrawTargetImageData {
+impl ImageData for AzureDrawTargetImageData {
     fn size(&self) -> Size2D<uint> {
         self.size
     }
     fn stride(&self) -> uint {
         self.data_source_surface.stride() as uint
     }
-    fn format(&self) -> layers::layers::Format {
+    fn format(&self) -> Format {
         // FIXME: This is not always correct. We should query the Azure draw target for the format.
-        layers::layers::ARGB32Format
+        ARGB32Format
     }
-    fn with_data(&self, f: layers::layers::WithDataFn) { 
+    fn with_data(&self, f: WithDataFn) { 
         do self.data_source_surface.with_data |data| {
             f(data);
         }
     }
 }
 
-fn mainloop(po: Port<Msg>, script_chan: SharedChan<ScriptMsg>, opts: &Opts) {
-    let key_handlers: @mut ~[Chan<()>] = @mut ~[];
-
+fn run_main_loop(po: Port<Msg>, script_chan: SharedChan<ScriptMsg>, opts: &Opts) {
     let app: Application = ApplicationMethods::new();
     let window: @mut Window = WindowMethods::new(&app);
+    let resize_rate_limiter = @mut ResizeRateLimiter(script_chan.clone());
 
-    let surfaces = @mut SurfaceSet(opts.render_backend);
-
-    let context = layers::rendergl::init_render_context();
+    let surfaces = @mut SurfaceSet::new(opts.render_backend);
+    let context = rendergl::init_render_context();
 
     // Create an initial layer tree.
     //
     // TODO: There should be no initial layer tree until the renderer creates one from the display
     // list. This is only here because we don't have that logic in the renderer yet.
-    let root_layer = @mut layers::layers::ContainerLayer();
+    let root_layer = @mut ContainerLayer();
     let original_layer_transform;
     {
-        let image_data = @layers::layers::BasicImageData::new(Size2D(0u, 0u),
-                                                              0,
-                                                              layers::layers::RGB24Format,
-                                                              ~[]);
+        let image_data = @BasicImageData::new(Size2D(0, 0), 0, RGB24Format, ~[]);
         let image = @mut Image::new(image_data as @ImageData);
-        let image_layer = @mut layers::layers::ImageLayer(image);
+        let image_layer = @mut ImageLayer(image);
         original_layer_transform = image_layer.common.transform;
         image_layer.common.set_transform(original_layer_transform.scale(800.0, 600.0, 1.0));
-        root_layer.add_child(layers::layers::ImageLayerKind(image_layer));
+        root_layer.add_child(ImageLayerKind(image_layer));
     }
 
-
-    let scene = @mut layers::scene::Scene(layers::layers::ContainerLayerKind(root_layer),
-                                          Size2D(800.0, 600.0),
-                                          identity());
-
+    let scene = @mut Scene(ContainerLayerKind(root_layer), Size2D(800.0, 600.0), identity());
+    let key_handlers: @mut ~[Chan<()>] = @mut ~[];
     let done = @mut false;
-    let resize_rate_limiter = @mut ResizeRateLimiter(script_chan.clone());
+
     let check_for_messages: @fn() = || {
         // Periodically check if the script task responded to our last resize event
         resize_rate_limiter.check_resize_response();
@@ -120,11 +114,15 @@ fn mainloop(po: Port<Msg>, script_chan: SharedChan<ScriptMsg>, opts: &Opts) {
         while po.peek() {
             match po.recv() {
                 AddKeyHandler(key_ch) => key_handlers.push(key_ch),
-                BeginDrawing(sender) => lend_surface(surfaces, sender),
+                BeginDrawing(sender) => surfaces.lend(sender),
+                Exit => *done = true,
+
                 Draw(sender, draw_target) => {
                     debug!("osmain: received new frame");
-                    return_surface(surfaces, draw_target);
-                    lend_surface(surfaces, sender);
+
+                    // Perform a buffer swap.
+                    surfaces.put_back(draw_target);
+                    surfaces.lend(sender);
 
                     // Iterate over the children of the container layer.
                     let mut current_layer_child = root_layer.first_child;
@@ -149,11 +147,11 @@ fn mainloop(po: Port<Msg>, script_chan: SharedChan<ScriptMsg>, opts: &Opts) {
                         current_layer_child = match current_layer_child {
                             None => {
                                 debug!("osmain: adding new image layer");
-                                image_layer = @mut layers::layers::ImageLayer(image);
-                                root_layer.add_child(layers::layers::ImageLayerKind(image_layer));
+                                image_layer = @mut ImageLayer(image);
+                                root_layer.add_child(ImageLayerKind(image_layer));
                                 None
                             }
-                            Some(layers::layers::ImageLayerKind(existing_image_layer)) => {
+                            Some(ImageLayerKind(existing_image_layer)) => {
                                 image_layer = existing_image_layer;
                                 image_layer.set_image(image);
 
@@ -166,16 +164,13 @@ fn mainloop(po: Port<Msg>, script_chan: SharedChan<ScriptMsg>, opts: &Opts) {
                         };
 
                         // Set the layer's transform.
-                        let x = buffer.rect.origin.x as f32;
-                        let y = buffer.rect.origin.y as f32;
-                        image_layer.common.set_transform(
-                            original_layer_transform.translate(x, y, 0.0)
-                                .scale(width as f32, height as f32, 1.0));
+                        let (x, y) = (buffer.rect.origin.x as f32, buffer.rect.origin.y as f32);
+                        let transform = original_layer_transform.translate(x, y, 0.0);
+                        let transform = transform.scale(width as f32, height as f32, 1.0);
+                        image_layer.common.set_transform(transform)
                     }
-                    surfaces.front.layer_buffer_set.buffers = buffers;
-                }
-                Exit => {
-                    *done = true;
+
+                    surfaces.front.layer_buffer_set.buffers = buffers
                 }
             }
         }
@@ -187,7 +182,7 @@ fn mainloop(po: Port<Msg>, script_chan: SharedChan<ScriptMsg>, opts: &Opts) {
             scene.size = window.size();
 
             // Render the scene.
-            layers::rendergl::render_scene(context, scene);
+            rendergl::render_scene(context, scene);
         }
 
         window.present();
@@ -230,66 +225,73 @@ struct SurfaceSet {
     back: Surface,
 }
 
-fn lend_surface(surfaces: &mut SurfaceSet, receiver: Chan<LayerBufferSet>) {
-    // We are in a position to lend out the surface?
-    assert!(surfaces.front.have);
-    // Ok then take it
-    let old_layer_buffers = util::replace(&mut surfaces.front.layer_buffer_set.buffers, ~[]);
-    let new_layer_buffers = do old_layer_buffers.map |layer_buffer| {
-        let draw_target_ref = &layer_buffer.draw_target;
-        let layer_buffer = LayerBuffer {
-            draw_target: draw_target_ref.clone(),
-            rect: copy layer_buffer.rect,
-            stride: layer_buffer.stride
-        };
-        debug!("osmain: lending surface %?", layer_buffer);
-        layer_buffer
-    };
-    surfaces.front.layer_buffer_set.buffers = old_layer_buffers;
-
-    let new_layer_buffer_set = LayerBufferSet { buffers: new_layer_buffers };
-    receiver.send(new_layer_buffer_set);
-    // Now we don't have it
-    surfaces.front.have = false;
-    // But we (hopefully) have another!
-    util::swap(&mut surfaces.front, &mut surfaces.back);
-    // Let's look
-    assert!(surfaces.front.have);
-}
+impl SurfaceSet {
+    /// Creates a new surface set.
+    fn new(backend: BackendType) -> SurfaceSet {
+        SurfaceSet {
+            front: Surface::new(backend),
+            back: Surface::new(backend),
+        }
+    }
 
-fn return_surface(surfaces: &mut SurfaceSet, layer_buffer_set: LayerBufferSet) {
-    //#debug("osmain: returning surface %?", layer_buffer_set);
-    // We have room for a return
-    assert!(surfaces.front.have);
-    assert!(!surfaces.back.have);
+    fn lend(&mut self, receiver: Chan<LayerBufferSet>) {
+        // We are in a position to lend out the surface?
+        assert!(self.front.have);
+        // Ok then take it
+        let old_layer_buffers = util::replace(&mut self.front.layer_buffer_set.buffers, ~[]);
+        let new_layer_buffers = do old_layer_buffers.map |layer_buffer| {
+            let draw_target_ref = &layer_buffer.draw_target;
+            let layer_buffer = LayerBuffer {
+                draw_target: draw_target_ref.clone(),
+                rect: copy layer_buffer.rect,
+                stride: layer_buffer.stride
+            };
+            debug!("osmain: lending surface %?", layer_buffer);
+            layer_buffer
+        };
+        self.front.layer_buffer_set.buffers = old_layer_buffers;
+
+        let new_layer_buffer_set = LayerBufferSet { buffers: new_layer_buffers };
+        receiver.send(new_layer_buffer_set);
+        // Now we don't have it
+        self.front.have = false;
+        // But we (hopefully) have another!
+        util::swap(&mut self.front, &mut self.back);
+        // Let's look
+        assert!(self.front.have);
+    }
 
-    surfaces.back.layer_buffer_set = layer_buffer_set;
+    fn put_back(&mut self, layer_buffer_set: LayerBufferSet) {
+        // We have room for a return
+        assert!(self.front.have);
+        assert!(!self.back.have);
 
-    // Now we have it again
-    surfaces.back.have = true;
-}
+        self.back.layer_buffer_set = layer_buffer_set;
 
-fn SurfaceSet(backend: BackendType) -> SurfaceSet {
-    SurfaceSet { front: Surface(backend), back: Surface(backend) }
+        // Now we have it again
+        self.back.have = true;
+    }
 }
 
 struct Surface {
     layer_buffer_set: LayerBufferSet,
     have: bool,
 }
 
-fn Surface(backend: BackendType) -> Surface {
-    let layer_buffer = LayerBuffer {
-        draw_target: DrawTarget::new(backend, Size2D(800i32, 600i32), B8G8R8A8),
-        rect: Rect(Point2D(0u, 0u), Size2D(800u, 600u)),
-        stride: 800 * 4
-    };
-    let layer_buffer_set = LayerBufferSet {
-        buffers: ~[ layer_buffer ]
-    };
-    Surface {
-        layer_buffer_set: layer_buffer_set,
-        have: true
+impl Surface {
+    fn new(backend: BackendType) -> Surface {
+        let layer_buffer = LayerBuffer {
+            draw_target: DrawTarget::new(backend, Size2D(800, 600), B8G8R8A8),
+            rect: Rect(Point2D(0u, 0u), Size2D(800u, 600u)),
+            stride: 800 * 4
+        };
+        let layer_buffer_set = LayerBufferSet {
+            buffers: ~[ layer_buffer ]
+        };
+        Surface {
+            layer_buffer_set: layer_buffer_set,
+            have: true
+        }
     }
 }