Layer bounds and buffer requests should use layer coordinates

Instead of passing a scaling factor down to rust-layers and keeping all
layers in page coordinates, work in layer coordinates. This is much more
natural, as the compositor and rust-layer should really need to care
about any potential contents zoom. It will also allow us to move more
code into rust-layers in a later commit.

src/components/compositing/compositor.rs

@@ -397,7 +397,15 @@ impl IOCompositor {
         }
     }
 
-    fn create_or_update_root_layer(&mut self, layer_properties: LayerProperties) {
+    // rust-layers keeps everything in layer coordinates, so we must convert all rectangles
+    // from page coordinates into layer coordinates based on our current scale.
+    fn convert_page_rect_to_layer_coordinates(&self, page_rect: Rect<f32>) -> Rect<f32> {
+        page_rect * self.device_pixels_per_page_px().get()
+    }
+
+    fn create_or_update_root_layer(&mut self, mut layer_properties: LayerProperties) {
+        layer_properties.rect = self.convert_page_rect_to_layer_coordinates(layer_properties.rect);
+
         let need_new_root_layer = !self.update_layer_if_exists(layer_properties);
         if need_new_root_layer {
             let root_pipeline = match self.root_pipeline {
@@ -433,7 +441,8 @@ impl IOCompositor {
         self.ask_for_tiles();
     }
 
-    fn create_or_update_descendant_layer(&mut self, layer_properties: LayerProperties) {
+    fn create_or_update_descendant_layer(&mut self, mut layer_properties: LayerProperties) {
+        layer_properties.rect = self.convert_page_rect_to_layer_coordinates(layer_properties.rect);
         if !self.update_layer_if_exists(layer_properties) {
             self.create_descendant_layer(layer_properties);
         }
@@ -483,6 +492,7 @@ impl IOCompositor {
                                                    pipeline_id: PipelineId,
                                                    layer_id: LayerId) {
         let page_window = self.page_window();
+        let device_pixels_per_page_px = self.device_pixels_per_page_px();
         let needs_recomposite = match self.scene.root {
             Some(ref mut root_layer) => {
                 self.fragment_point.take().map_or(false, |fragment_point| {
@@ -490,7 +500,8 @@ impl IOCompositor {
                                  pipeline_id,
                                  layer_id,
                                  fragment_point,
-                                 page_window)
+                                 page_window,
+                                 device_pixels_per_page_px)
                 })
             }
             None => fail!("Compositor: Tried to scroll to fragment without root layer."),
@@ -502,14 +513,16 @@ impl IOCompositor {
     fn set_layer_clip_rect(&mut self,
                            pipeline_id: PipelineId,
                            layer_id: LayerId,
-                           new_rect: Rect<f32>) {
+                           new_rect_in_page_coordinates: Rect<f32>) {
+        let new_rect_in_layer_coordinates =
+            self.convert_page_rect_to_layer_coordinates(new_rect_in_page_coordinates);
         let should_ask_for_tiles = match self.scene.root {
             Some(ref root_layer) => {
                 match CompositorData::find_layer_with_pipeline_and_layer_id(root_layer.clone(),
                                                                             pipeline_id,
                                                                             layer_id) {
                     Some(ref layer) => {
-                        *layer.bounds.borrow_mut() = new_rect;
+                        *layer.bounds.borrow_mut() = new_rect_in_layer_coordinates;
                         true
                     }
                     None => {
@@ -569,10 +582,16 @@ impl IOCompositor {
                                 layer_id: LayerId,
                                 point: Point2D<f32>) {
         let page_window = self.page_window();
+        let device_pixels_per_page_px = self.device_pixels_per_page_px();
         let (ask, move): (bool, bool) = match self.scene.root {
             Some(ref layer) if layer.extra_data.borrow().pipeline.id == pipeline_id => {
                 (true,
-                 events::move(layer.clone(), pipeline_id, layer_id, point, page_window))
+                 events::move(layer.clone(),
+                              pipeline_id,
+                              layer_id,
+                              point,
+                              page_window,
+                              device_pixels_per_page_px))
             }
             Some(_) | None => {
                 self.fragment_point = Some(point);
@@ -704,12 +723,14 @@ impl IOCompositor {
         let page_cursor = cursor.as_f32() / scale;
         let page_window = self.page_window();
         let mut scroll = false;
+        let device_pixels_per_page_px = self.device_pixels_per_page_px();
         match self.scene.root {
             Some(ref mut layer) => {
                 scroll = events::handle_scroll_event(layer.clone(),
                                                      page_delta,
                                                      page_cursor,
-                                                     page_window) || scroll;
+                                                     page_window,
+                                                     device_pixels_per_page_px) || scroll;
             }
             None => { }
         }
@@ -761,12 +782,14 @@ impl IOCompositor {
         let page_cursor = TypedPoint2D(-1f32, -1f32); // Make sure this hits the base layer
         let page_window = self.page_window();
 
+        let device_pixels_per_page_px = self.device_pixels_per_page_px();
         match self.scene.root {
             Some(ref mut layer) => {
                 events::handle_scroll_event(layer.clone(),
                                             page_delta,
                                             page_cursor,
-                                            page_window);
+                                            page_window,
+                                            device_pixels_per_page_px);
             }
             None => { }
         }
@@ -786,18 +809,18 @@ impl IOCompositor {
     /// Get BufferRequests from each layer.
     fn ask_for_tiles(&mut self) {
         let scale = self.device_pixels_per_page_px();
-        let page_window = self.page_window();
         let mut num_rerendermsgs_sent = 0;
+        let window_rect_in_device_pixels = Rect(Point2D(0f32, 0f32),
+                                                self.window_size.as_f32().to_untyped());
+
         match self.scene.root {
-            Some(ref layer) => {
+            Some(ref mut layer) => {
-                let rect = Rect(Point2D(0f32, 0f32), page_window.to_untyped());
                 let mut layers_and_requests = Vec::new();
                 let mut unused_buffers = Vec::new();
                 CompositorData::get_buffer_requests_recursively(&mut layers_and_requests,
                                                                 &mut unused_buffers,
                                                                 layer.clone(),
-                                                                rect,
+                                                                window_rect_in_device_pixels);
-                                                                scale.get());
 
                 // Return unused tiles first, so that they can be reused by any new BufferRequests.
                 let have_unused_buffers = unused_buffers.len() > 0;
@@ -811,12 +834,18 @@ impl IOCompositor {
                 // when handling the resulting BufferRequest responses.
                 let mut pipeline_requests:
                     HashMap<PipelineId, (RenderChan, Vec<ReRenderRequest>)> = HashMap::new();
-                for (layer, requests) in layers_and_requests.move_iter() {
+                for (layer, mut requests) in layers_and_requests.move_iter() {
                     let pipeline_id = layer.extra_data.borrow().pipeline.id;
                     let &(_, ref mut vec) = pipeline_requests.find_or_insert_with(pipeline_id, |_| {
                         (layer.extra_data.borrow().pipeline.render_chan.clone(), Vec::new())
                     });
 
+                    // All the BufferRequests are in layer/device coordinates, but the render task
+                    // wants to know the page coordinates. We scale them before sending them.
+                    for request in requests.mut_iter() {
+                        request.page_rect = request.page_rect / scale.get();
+                    }
+
                     vec.push(ReRenderRequest {
                         buffer_requests: requests,
                         scale: scale.get(),

src/components/compositing/compositor_data.rs

@@ -9,8 +9,9 @@ use pipeline::CompositionPipeline;
 use azure::azure_hl::Color;
 use geom::point::TypedPoint2D;
 use geom::rect::Rect;
+use geom::scale_factor::ScaleFactor;
 use geom::size::{Size2D, TypedSize2D};
-use gfx::render_task::{UnusedBufferMsg};
+use gfx::render_task::UnusedBufferMsg;
 use layers::layers::{BufferRequest, Layer, LayerBuffer, LayerBufferSet};
 use layers::platform::surface::NativeSurfaceMethods;
 use servo_msg::compositor_msg::{Epoch, LayerId};
@@ -86,9 +87,8 @@ impl CompositorData {
                                                                Vec<BufferRequest>)>,
                                            unused_buffers: &mut Vec<Box<LayerBuffer>>,
                                            layer: Rc<Layer<CompositorData>>,
-                                           window_rect: Rect<f32>,
+                                           window_rect_in_device_pixels: Rect<f32>) {
-                                           scale: f32) {
+        let (request, unused) = layer.get_tile_rects_page(window_rect_in_device_pixels);
-        let (request, unused) = layer.get_tile_rects_page(window_rect, scale);
         unused_buffers.push_all_move(unused);
 
         if !request.is_empty() {
@@ -96,10 +96,11 @@ impl CompositorData {
         }
 
         for kid in layer.children().iter() {
-            let mut new_rect = window_rect;
+            let mut new_rect = window_rect_in_device_pixels;
-            let offset = kid.extra_data.borrow().scroll_offset.to_untyped();
+            let content_offset = kid.content_offset.borrow();
-            new_rect.origin.x = new_rect.origin.x - offset.x;
+            new_rect.origin.x = new_rect.origin.x - content_offset.x;
-            new_rect.origin.y = new_rect.origin.y - offset.y;
+            new_rect.origin.y = new_rect.origin.y - content_offset.y;
+
             match new_rect.intersection(&*kid.bounds.borrow()) {
                 Some(new_rect) => {
                     // Child layers act as if they are rendered at (0,0), so we
@@ -110,8 +111,7 @@ impl CompositorData {
                     CompositorData::get_buffer_requests_recursively(requests,
                                                                     unused_buffers,
                                                                     kid.clone(),
-                                                                    child_rect,
+                                                                    child_rect);
-                                                                    scale);
                 }
                 None => {}
             }
@@ -126,12 +126,15 @@ impl CompositorData {
         layer.contents_changed();
 
         // 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.
+        // cursor position to make sure the scroll isn't propagated downwards. The
+        // scale factor does not matter here since we are scrolling to 0 offset and
+        // 0 * n == 0.
         let size: TypedSize2D<PagePx, f32> = Size2D::from_untyped(&layer.bounds.borrow().size);
         events::handle_scroll_event(layer.clone(),
-                                            TypedPoint2D(0f32, 0f32),
+                                    TypedPoint2D(0f32, 0f32),
-                                            TypedPoint2D(-1f32, -1f32),
+                                    TypedPoint2D(-1f32, -1f32),
-                                            size);
+                                    size,
+                                    ScaleFactor(1.0));
     }
 
     pub fn find_layer_with_pipeline_and_layer_id(layer: Rc<Layer<CompositorData>>,

src/components/compositing/events.rs

@@ -10,13 +10,14 @@ use geom::length::Length;
 use geom::matrix::identity;
 use geom::point::{Point2D, TypedPoint2D};
 use geom::rect::{Rect, TypedRect};
+use geom::scale_factor::ScaleFactor;
 use geom::size::TypedSize2D;
 use layers::layers::Layer;
 use script::dom::event::{ClickEvent, MouseDownEvent, MouseMoveEvent, MouseUpEvent};
 use script::script_task::{ScriptChan, SendEventMsg};
 use servo_msg::compositor_msg::{FixedPosition, LayerId};
 use servo_msg::constellation_msg::PipelineId;
-use servo_util::geometry::PagePx;
+use servo_util::geometry::{DevicePixel, PagePx};
 use std::rc::Rc;
 
 trait Clampable {
@@ -44,7 +45,8 @@ impl Clampable for f32 {
 pub fn handle_scroll_event(layer: Rc<Layer<CompositorData>>,
                            delta: TypedPoint2D<PagePx, f32>,
                            cursor: TypedPoint2D<PagePx, f32>,
-                           window_size: TypedSize2D<PagePx, f32>)
+                           window_size: TypedSize2D<PagePx, f32>,
+                           page_to_device_pixels_scale: ScaleFactor<PagePx, DevicePixel, f32>)
                            -> bool {
     // If this layer doesn't want scroll events, neither it nor its children can handle scroll
     // events.
@@ -60,7 +62,8 @@ pub fn handle_scroll_event(layer: Rc<Layer<CompositorData>>,
            handle_scroll_event(child.clone(),
                                delta,
                                cursor - rect.origin,
-                               rect.size) {
+                               rect.size,
+                               page_to_device_pixels_scale) {
             return true
         }
     }
@@ -86,13 +89,14 @@ pub fn handle_scroll_event(layer: Rc<Layer<CompositorData>>,
     }
 
     let offset = layer.extra_data.borrow().scroll_offset.clone();
-    scroll(layer.clone(), offset)
+    scroll(layer.clone(), offset, page_to_device_pixels_scale)
 }
 
 /// Actually scrolls the descendants of a layer that scroll. This is called by
 /// `handle_scroll_event` above when it determines that a layer wants to scroll.
 fn scroll(layer: Rc<Layer<CompositorData>>,
-          scroll_offset: TypedPoint2D<PagePx, f32>)
+          scroll_offset: TypedPoint2D<PagePx, f32>,
+          page_to_device_pixels_scale: ScaleFactor<PagePx, DevicePixel, f32>)
           -> bool {
     let mut result = false;
 
@@ -103,12 +107,13 @@ fn scroll(layer: Rc<Layer<CompositorData>>,
 
         let scroll_offset = layer.extra_data.borrow().scroll_offset.clone();
         *layer.transform.borrow_mut() = identity().translate(scroll_offset.x.get(), scroll_offset.y.get(), 0.0);
+        *layer.content_offset.borrow_mut() = (scroll_offset * page_to_device_pixels_scale).to_untyped();
 
         result = true
     }
 
     for child in layer.children().iter() {
-        result = scroll(child.clone(), scroll_offset) || result;
+        result = scroll(child.clone(), scroll_offset, page_to_device_pixels_scale) || result;
     }
 
     result
@@ -149,13 +154,19 @@ pub fn move(layer: Rc<Layer<CompositorData>>,
             pipeline_id: PipelineId,
             layer_id: LayerId,
             origin: Point2D<f32>,
-            window_size: TypedSize2D<PagePx, f32>)
+            window_size: TypedSize2D<PagePx, f32>,
+            page_to_device_pixels_scale: ScaleFactor<PagePx, DevicePixel, f32>)
             -> bool {
     // Search children for the right layer to move.
     if layer.extra_data.borrow().pipeline.id != pipeline_id ||
        layer.extra_data.borrow().id != layer_id {
         return layer.children().iter().any(|kid| {
-            move(kid.clone(), pipeline_id, layer_id, origin, window_size)
+            move(kid.clone(),
+                 pipeline_id,
+                 layer_id,
+                 origin,
+                 window_size,
+                 page_to_device_pixels_scale)
         });
     }
 
@@ -183,5 +194,5 @@ pub fn move(layer: Rc<Layer<CompositorData>>,
     }
 
     let offset = layer.extra_data.borrow().scroll_offset.clone();
-    scroll(layer.clone(), offset)
+    scroll(layer.clone(), offset, page_to_device_pixels_scale)
 }

src/support/layers/rust-layers

@@ -1 +1 @@
-Subproject commit 10e34dbdf9b9d4a437fedc412d37f13a42182e44
+Subproject commit 5f3dc4cc940c0f807171e26411e18ea1ee528368