From b8a9223648fcd2b8f379eb6a29f2769e82dc7967 Mon Sep 17 00:00:00 2001
From: Martin Robinson <mrobinson@igalia.com>
Date: Mon, 28 Jul 2014 19:50:09 -0700
Subject: [PATCH] Move get_buffer_requests into rust-layers from Servo

This is generally useful and layers now know how to get their own
BufferRequests.
---
 layers.rs |  7 ++----
 scene.rs  | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 66 insertions(+), 8 deletions(-)

diff --git a/layers.rs b/layers.rs
index 9f9eb47..3877716 100644
--- a/layers.rs
+++ b/layers.rs
@@ -71,12 +71,9 @@ impl<T> Layer<T> {
         self.children().push(new_child);
     }
 
-    pub fn get_tile_rects_page(&self,
-                               window: Rect<f32>)
-                               -> (Vec<BufferRequest>, Vec<Box<LayerBuffer>>) {
+    pub fn get_buffer_requests(&self, rect_in_layer: Rect<f32>) -> Vec<BufferRequest> {
         let mut tile_grid = self.tile_grid.borrow_mut();
-        (tile_grid.get_buffer_requests_in_rect(window, *self.content_age.borrow()),
-         tile_grid.take_unused_buffers())
+        return tile_grid.get_buffer_requests_in_rect(rect_in_layer, *self.content_age.borrow());
     }
 
     pub fn resize(&self, new_size: Size2D<f32>) {
diff --git a/scene.rs b/scene.rs
index 29a16be..c886d54 100755
--- a/scene.rs
+++ b/scene.rs
@@ -8,16 +8,20 @@
 // except according to those terms.
 
 use color::Color;
-use geom::size::Size2D;
 use geom::matrix::Matrix4;
-use layers::Layer;
+use geom::point::Point2D;
+use geom::rect::Rect;
+use geom::size::Size2D;
+use layers::{BufferRequest, Layer, LayerBuffer};
+use std::mem;
 use std::rc::Rc;
 
 pub struct Scene<T> {
     pub root: Option<Rc<Layer<T>>>,
     pub size: Size2D<f32>,
     pub transform: Matrix4<f32>,
-    pub background_color: Color
+    pub background_color: Color,
+    pub unused_buffers: Vec<Box<LayerBuffer>>,
 }
 
 impl<T> Scene<T> {
@@ -31,8 +35,65 @@ impl<T> Scene<T> {
                 g: 0.36f32,
                 b: 0.36f32,
                 a: 1.0f32
+            },
+            unused_buffers: Vec::new(),
+        }
+    }
+
+    pub fn get_buffer_requests_for_layer(&mut self,
+                                         layer: Rc<Layer<T>>,
+                                         layers_and_requests: &mut Vec<(Rc<Layer<T>>,
+                                                                        Vec<BufferRequest>)>,
+                                         rect_in_window: Rect<f32>) {
+        // The rectangle passed in is in the coordinate system of our parent, so we
+        // need to intersect with our boundaries and convert it to our coordinate system.
+        let content_offset = layer.content_offset.borrow();
+        let layer_bounds = layer.bounds.borrow();
+        let layer_rect = Rect(Point2D(rect_in_window.origin.x - content_offset.x,
+                                      rect_in_window.origin.y - content_offset.y),
+                              rect_in_window.size);
+
+        match layer_rect.intersection(&*layer_bounds) {
+            Some(mut intersected_rect) => {
+                // Child layers act as if they are rendered at (0,0), so we
+                // subtract the layer's (x,y) coords in its containing page
+                // to make the child_rect appear in coordinates local to it.
+                intersected_rect.origin = intersected_rect.origin.sub(&layer_bounds.origin);
+
+                let requests = layer.get_buffer_requests(intersected_rect);
+                if !requests.is_empty() {
+                    layers_and_requests.push((layer.clone(), requests));
+                }
+
+                self.unused_buffers.push_all_move(layer.collect_unused_buffers());
+
+                for kid in layer.children().iter() {
+                    self.get_buffer_requests_for_layer(kid.clone(),
+                                                       layers_and_requests,
+                                                       rect_in_window);
+                }
             }
+            None => {},
         }
     }
+
+    pub fn get_buffer_requests(&mut self,
+                               requests: &mut Vec<(Rc<Layer<T>>, Vec<BufferRequest>)>,
+                               window_rect_in_device_pixels: Rect<f32>) {
+        let root_layer = match self.root {
+            Some(ref root_layer) => root_layer.clone(),
+            None => return,
+        };
+
+        self.get_buffer_requests_for_layer(root_layer.clone(),
+                                           requests,
+                                           window_rect_in_device_pixels);
+    }
+
+    pub fn collect_unused_buffers(&mut self) -> Vec<Box<LayerBuffer>> {
+        let mut unused_buffers = Vec::new();
+        mem::swap(&mut unused_buffers, &mut self.unused_buffers);
+        return unused_buffers;
+    }
 }