Update to latest rust-layers

Layers now store their complete boundaries, so we can eliminate the
various ways these were stored in Servo.

src/components/compositing/compositor.rs

@@ -372,7 +372,8 @@ impl IOCompositor {
                                                                self.opts.cpu_painting,
                                                                layer_properties.background_color);
             let size = layer_properties.rect.size;
-            let new_root = Rc::new(Layer::new(size,
+            let new_root = Rc::new(Layer::new(layer_properties.rect,
+                                              size,
                                               self.opts.tile_size,
                                               new_compositor_data));
 

src/components/compositing/compositor_data.rs

@@ -8,7 +8,7 @@ use pipeline::CompositionPipeline;
 
 use azure::azure_hl::Color;
 use geom::matrix::identity;
-use geom::point::{Point2D, TypedPoint2D};
+use geom::point::TypedPoint2D;
 use geom::rect::Rect;
 use geom::size::{Size2D, TypedSize2D};
 use gfx::render_task::{ReRenderMsg, UnusedBufferMsg};
@@ -41,9 +41,6 @@ pub struct CompositorData {
     /// top left corner of the page.
     pub scroll_offset: TypedPoint2D<PagePx, f32>,
 
-    /// The bounds of this layer in terms of its parent (a.k.a. the scissor box).
-    pub bounds: Rect<f32>,
-
     /// The size of the underlying page in page coordinates. This is an option
     /// because we may not know the size of the page until layout is finished completely.
     /// if we have no size yet, the layer is hidden until a size message is recieved.
@@ -65,8 +62,6 @@ pub struct CompositorData {
     /// The color to use for the unrendered-content void
     pub unrendered_color: Color,
 
-    pub scissor: Option<Rect<f32>>,
-
     /// A monotonically increasing counter that keeps track of the current epoch.
     /// add_buffer() calls that don't match the current epoch will be ignored.
     pub epoch: Epoch,
@@ -82,7 +77,6 @@ impl CompositorData {
     pub fn new(pipeline: CompositionPipeline,
                layer_id: LayerId,
                epoch: Epoch,
-               bounds: Rect<f32>,
                page_size: Option<Size2D<f32>>,
                cpu_painting: bool,
                wants_scroll_events: WantsScrollEventsFlag,
@@ -93,14 +87,12 @@ impl CompositorData {
             pipeline: pipeline,
             id: layer_id,
             scroll_offset: TypedPoint2D(0f32, 0f32),
-            bounds: bounds,
             page_size: page_size,
             hidden: false,
             wants_scroll_events: wants_scroll_events,
             scroll_policy: scroll_policy,
             cpu_painting: cpu_painting,
             unrendered_color: unrendered_color,
-            scissor: None,
             epoch: epoch,
         }
     }
@@ -113,7 +105,6 @@ impl CompositorData {
         CompositorData::new(pipeline,
                             LayerId::null(),
                             epoch,
-                            Rect(Point2D(0f32, 0f32), page_size),
                             Some(page_size),
                             cpu_painting,
                             WantsScrollEvents,
@@ -130,19 +121,16 @@ impl CompositorData {
         let new_compositor_data = CompositorData::new(layer.extra_data.borrow().pipeline.clone(),
                                                       layer_properties.id,
                                                       layer_properties.epoch,
-                                                      layer_properties.rect,
                                                       Some(page_size),
                                                       layer.extra_data.borrow().cpu_painting,
                                                       DoesntWantScrollEvents,
                                                       layer_properties.scroll_policy,
                                                       layer_properties.background_color);
-        let new_kid = Rc::new(Layer::new(page_size,
+        let new_kid = Rc::new(Layer::new(layer_properties.rect,
+                                         page_size,
                                          Layer::tile_size(layer.clone()),
                                          new_compositor_data));
 
-        new_kid.extra_data.borrow_mut().scissor = Some(layer_properties.rect);
-        *new_kid.origin.borrow_mut() = layer_properties.rect.origin;
-
         // Place the kid's layer in the container passed in.
         Layer::add_child(layer.clone(), new_kid.clone());
     }
@@ -178,30 +166,25 @@ impl CompositorData {
         }
 
         let send_child_buffer_request = |kid: &Rc<Layer<CompositorData>>| -> bool {
-            match kid.extra_data.borrow().scissor {
+            let mut new_rect = window_rect;
-                Some(scissor) => {
+            let offset = kid.extra_data.borrow().scroll_offset.to_untyped();
-                    let mut new_rect = window_rect;
+            new_rect.origin.x = new_rect.origin.x - offset.x;
-                    let offset = kid.extra_data.borrow().scroll_offset.to_untyped();
+            new_rect.origin.y = new_rect.origin.y - offset.y;
-                    new_rect.origin.x = new_rect.origin.x - offset.x;
+            match new_rect.intersection(&*kid.bounds.borrow()) {
-                    new_rect.origin.y = new_rect.origin.y - offset.y;
+                Some(new_rect) => {
-                    match new_rect.intersection(&scissor) {
+                    // Child layers act as if they are rendered at (0,0), so we
-                        Some(new_rect) => {
+                    // subtract the layer's (x,y) coords in its containing page
-                            // Child layers act as if they are rendered at (0,0), so we
+                    // to make the child_rect appear in coordinates local to it.
-                            // subtract the layer's (x,y) coords in its containing page
+                    let child_rect = Rect(new_rect.origin.sub(&kid.bounds.borrow().origin),
-                            // to make the child_rect appear in coordinates local to it.
+                                          new_rect.size);
-                            let child_rect = Rect(new_rect.origin.sub(&scissor.origin),
+                    CompositorData::send_buffer_requests_recursively(kid.clone(),
-                                                  new_rect.size);
+                                                                     graphics_context,
-                            CompositorData::send_buffer_requests_recursively(kid.clone(),
+                                                                     child_rect,
-                                                                             graphics_context,
+                                                                     scale)
-                                                                             child_rect,
+                }
-                                                                             scale)
+                None => {
-                        }
+                    false // Layer is offscreen
-                        None => {
-                            false // Layer is offscreen
-                        }
-                    }
                 }
-                None => fail!("child layer not clipped!"),
             }
         };
 
@@ -225,16 +208,12 @@ impl CompositorData {
                                                                     layer_id) {
             Some(child_node) => {
                 debug!("compositor_data: node found for set_clipping_rect()");
-                *child_node.origin.borrow_mut() = new_rect.origin;
+                let old_rect = child_node.bounds.borrow().clone();
-                let old_rect = child_node.extra_data.borrow().scissor.clone();
+                *child_node.bounds.borrow_mut() = new_rect;
-                child_node.extra_data.borrow_mut().scissor = Some(new_rect);
+
-                match old_rect {
+                // Rect is unhidden
-                    Some(old_rect) => {
+                Layer::set_status_page(layer.clone(), old_rect, Normal, false);
-                        // Rect is unhidden
+
-                        Layer::set_status_page(layer.clone(), old_rect, Normal, false);
-                    }
-                    None => {} // Nothing to do
-                }
                 // Hide the new rect
                 Layer::set_status_page(layer.clone(), new_rect, Hidden, false);
 
@@ -276,20 +255,14 @@ impl CompositorData {
             let _ = layer.extra_data.borrow().pipeline.render_chan.send_opt(msg);
         }
 
-        let scissor_clone = layer.extra_data.borrow().scissor.clone();
+        // Call scroll for bounds checking if the page shrunk. Use (-1, -1) as the
-        match scissor_clone {
+        // cursor position to make sure the scroll isn't propagated downwards.
-            Some(scissor) => {
+        let size: TypedSize2D<PagePx, f32> = Size2D::from_untyped(&layer.bounds.borrow().size);
-                // Call scroll for bounds checking if the page shrunk. Use (-1, -1) as the
+        events::handle_scroll_event(layer.clone(),
-                // cursor position to make sure the scroll isn't propagated downwards.
-                let size: TypedSize2D<PagePx, f32> = Size2D::from_untyped(&scissor.size);
-                events::handle_scroll_event(layer.clone(),
                                             TypedPoint2D(0f32, 0f32),
                                             TypedPoint2D(-1f32, -1f32),
                                             size);
-                layer.extra_data.borrow_mut().hidden = false;
+        layer.extra_data.borrow_mut().hidden = false;
-            }
-            None => {} // Nothing to do
-        }
 
         CompositorData::set_occlusions(layer.clone());
     }
@@ -437,12 +410,7 @@ impl CompositorData {
     fn set_occlusions(layer: Rc<Layer<CompositorData>>) {
         for kid in layer.children().iter() {
             if !kid.extra_data.borrow().hidden {
-                match kid.extra_data.borrow().scissor {
+                Layer::set_status_page(layer.clone(), *kid.bounds.borrow(), Hidden, false);
-                    None => {} // Nothing to do
-                    Some(rect) => {
-                        Layer::set_status_page(layer.clone(), rect, Hidden, false);
-                    }
-                }
             }
         }
 

src/components/compositing/events.rs

@@ -60,20 +60,13 @@ pub fn handle_scroll_event(layer: Rc<Layer<CompositorData>>,
     // Allow children to scroll.
     let cursor = cursor - layer.extra_data.borrow().scroll_offset;
     for child in layer.children().iter() {
-        match child.extra_data.borrow().scissor {
+        let rect: TypedRect<PagePx, f32> = Rect::from_untyped(&*child.bounds.borrow());
-            None => {
+        if rect.contains(&cursor) &&
-                error!("CompositorData: unable to perform cursor hit test for layer");
+           handle_scroll_event(child.clone(),
-            }
+                               delta,
-            Some(rect) => {
+                               cursor - rect.origin,
-                let rect: TypedRect<PagePx, f32> = Rect::from_untyped(&rect);
+                               rect.size) {
-                if rect.contains(&cursor) &&
+            return true
-                   handle_scroll_event(child.clone(),
-                                       delta,
-                                       cursor - rect.origin,
-                                       rect.size) {
-                    return true
-                }
-            }
         }
     }
 
@@ -141,17 +134,10 @@ pub fn send_mouse_event(layer: Rc<Layer<CompositorData>>,
             continue;
         }
 
-        match child.extra_data.borrow().scissor {
+        let rect: TypedRect<PagePx, f32> = Rect::from_untyped(&*child.bounds.borrow());
-            None => {
+        if rect.contains(&cursor) {
-                error!("CompositorData: unable to perform cursor hit test for layer");
+            send_mouse_event(child.clone(), event, cursor - rect.origin);
-            }
+            return;
-            Some(rect) => {
-                let rect: TypedRect<PagePx, f32> = Rect::from_untyped(&rect);
-                if rect.contains(&cursor) {
-                    send_mouse_event(child.clone(), event, cursor - rect.origin);
-                    return;
-                }
-            }
         }
     }
 
@@ -215,4 +201,3 @@ pub fn move(layer: Rc<Layer<CompositorData>>,
     let offset = layer.extra_data.borrow().scroll_offset.clone();
     scroll(layer.clone(), offset)
 }
-

src/support/layers/rust-layers

@@ -1 +1 @@
-Subproject commit f49717435a375a1e3beb26777b7303204e0a1a8a
+Subproject commit 168305cc4229eb79fb33ad045ec0b39f8097966a