Changes to support latest rust-layers

Now tiles are stored in TileGrid and layer methods are simple instance
methods.

src/components/compositing/compositor_data.rs

@@ -11,9 +11,8 @@ use geom::matrix::identity;
 use geom::point::TypedPoint2D;
 use geom::rect::Rect;
 use geom::size::{Size2D, TypedSize2D};
-use gfx::render_task::{ReRenderRequest, RenderChan, UnusedBufferMsg};
+use gfx::render_task::{ReRenderRequest, ReRenderMsg, RenderChan, UnusedBufferMsg};
-use layers::layers::{Layer, Flip, LayerBuffer, LayerBufferSet, NoFlip, TextureLayer};
+use layers::layers::{Layer, Flip, LayerBuffer, LayerBufferSet, NoFlip, TextureLayer, Tile};
-use layers::quadtree::Tile;
 use layers::platform::surface::{NativeCompositingGraphicsContext, NativeSurfaceMethods};
 use layers::texturegl::{Texture, TextureTarget};
 use servo_msg::compositor_msg::{Epoch, FixedPosition, LayerId};
@@ -112,11 +111,9 @@ impl CompositorData {
                                                       layer_properties.scroll_policy,
                                                       layer_properties.background_color);
         let new_kid = Rc::new(Layer::new(layer_properties.rect,
-                                         Layer::tile_size(layer.clone()),
+                                         layer.tile_size,
                                          new_compositor_data));
-
+        layer.add_child(new_kid.clone());
-        // Place the kid's layer in the container passed in.
-        Layer::add_child(layer.clone(), new_kid.clone());
     }
 
     // Given the current window size, determine which tiles need to be (re-)rendered and sends them
@@ -129,7 +126,7 @@ impl CompositorData {
                                            window_rect: Rect<f32>,
                                            scale: f32)
                                            -> bool {
-        let (request, unused) = Layer::get_tile_rects_page(layer.clone(), window_rect, scale);
+        let (request, unused) = layer.get_tile_rects_page(window_rect, scale);
         let redisplay = !unused.is_empty();
         if redisplay {
             // Send back unused tiles.
@@ -207,7 +204,6 @@ impl CompositorData {
                                                                  new_rect))
 
             }
-
         }
     }
 
@@ -215,11 +211,8 @@ impl CompositorData {
         layer.extra_data.borrow_mut().epoch = layer_properties.epoch;
         layer.extra_data.borrow_mut().unrendered_color = layer_properties.background_color;
 
-        let unused_buffers = Layer::resize(layer.clone(), layer_properties.rect.size);
+        layer.resize(layer_properties.rect.size);
-        if !unused_buffers.is_empty() {
+        layer.contents_changed();
-            let msg = UnusedBufferMsg(unused_buffers);
-            let _ = layer.extra_data.borrow().pipeline.render_chan.send_opt(msg);
-        }
 
         // Call scroll for bounds checking if the page shrunk. Use (-1, -1) as the
         // cursor position to make sure the scroll isn't propagated downwards.
@@ -292,7 +285,7 @@ impl CompositorData {
         return None;
     }
 
-    // Collect buffers from the quadtree. This method IS NOT recursive, so child layers
+    // Collect buffers from the layer. This method IS NOT recursive, so child layers
     // are not rebuilt directly from this method.
     pub fn build_layer_tree(layer: Rc<Layer<CompositorData>>,
                             graphics_context: &NativeCompositingGraphicsContext) {
@@ -300,7 +293,7 @@ impl CompositorData {
         layer.tiles.borrow_mut().clear();
 
         // Add new tiles.
-        Layer::do_for_all_tiles(layer.clone(), |buffer: &Box<LayerBuffer>| {
+        layer.do_for_all_tiles(|buffer: &Box<LayerBuffer>| {
             debug!("osmain: compositing buffer rect {}", buffer.rect);
 
             let size = Size2D(buffer.screen_pos.size.width as int,
@@ -354,24 +347,37 @@ impl CompositorData {
         }
 
         {
-            let mut unused_tiles = vec!();
             for buffer in new_buffers.buffers.move_iter().rev() {
-                unused_tiles.push_all_move(Layer::add_tile_pixel(layer.clone(), buffer));
+                layer.add_tile_pixel(buffer);
             }
+
+            let unused_tiles = layer.collect_unused_tiles();
             if !unused_tiles.is_empty() { // send back unused buffers
                 let msg = UnusedBufferMsg(unused_tiles);
                 let _ = layer.extra_data.borrow().pipeline.render_chan.send_opt(msg);
             }
+
+            let (pending_buffer_requests, scale) = layer.flush_pending_buffer_requests();
+            if !pending_buffer_requests.is_empty() {
+                let mut requests = vec!();
+                requests.push(ReRenderRequest {
+                    buffer_requests: pending_buffer_requests,
+                    scale: scale,
+                    layer_id: layer.extra_data.borrow().id,
+                    epoch: layer.extra_data.borrow().epoch,
+                });
+                let _ = layer.extra_data.borrow().pipeline.render_chan.send_opt(ReRenderMsg(requests));
+            }
         }
 
         CompositorData::build_layer_tree(layer.clone(), graphics_context);
         return true;
     }
 
-    /// Destroys all quadtree tiles, sending the buffers back to the renderer to be destroyed or
+    /// Destroys all layer tiles, sending the buffers back to the renderer to be destroyed or
     /// reused.
     fn clear(layer: Rc<Layer<CompositorData>>) {
-        let mut tiles = Layer::collect_tiles(layer.clone());
+        let mut tiles = layer.collect_tiles();
 
         if !tiles.is_empty() {
             // We have no way of knowing without a race whether the render task is even up and
@@ -400,7 +406,7 @@ impl CompositorData {
     ///
     /// This is used during shutdown, when we know the render task is going away.
     pub fn forget_all_tiles(layer: Rc<Layer<CompositorData>>) {
-        let tiles = Layer::collect_tiles(layer.clone());
+        let tiles = layer.collect_tiles();
         for tile in tiles.move_iter() {
             let mut tile = tile;
             tile.mark_wont_leak()

src/components/gfx/buffer_map.rs

@@ -5,7 +5,7 @@
 use std::collections::hashmap::HashMap;
 use geom::size::Size2D;
 use layers::platform::surface::NativePaintingGraphicsContext;
-use layers::quadtree::Tile;
+use layers::layers::Tile;
 use std::hash::Hash;
 use std::hash::sip::SipState;
 use std::mem;

src/support/geom/rust-geom

@@ -1 +1 @@
-Subproject commit 862af73433f36f156519ff24bd87abd3a8c10790
+Subproject commit 76e5b8281ce988b6cc58a18932c66287e8252be3

src/support/layers/rust-layers

@@ -1 +1 @@
-Subproject commit 3f116aef7db600654e6311aad2ac1968cbabf88a
+Subproject commit fc8332bdd278531e3c498813b366b147c96a8b37