Update euclid to 0.10.1

components/canvas/Cargo.toml

@@ -12,13 +12,13 @@ path = "lib.rs"
 [dependencies]
 azure = {git = "https://github.com/servo/rust-azure", features = ["plugins"]}
 canvas_traits = {path = "../canvas_traits"}
-euclid = "0.9"
+euclid = "0.10.1"
 gfx_traits = {path = "../gfx_traits"}
 gleam = "0.2.8"
 ipc-channel = "0.5"
 log = "0.3.5"
 num-traits = "0.1.32"
-offscreen_gl_context = "0.3"
+offscreen_gl_context = "0.4"
 plugins = {path = "../plugins"}
 util = {path = "../util"}
 

components/canvas/canvas_paint_thread.rs

@@ -683,9 +683,10 @@ impl<'a> CanvasPaintThread<'a> {
         let draw_target = self.drawtarget.create_similar_draw_target(&Size2D::new(source_rect.size.width as i32,
                                                                                   source_rect.size.height as i32),
                                                                      self.drawtarget.get_format());
-        let matrix = Matrix2D::identity().translate(-source_rect.origin.x as AzFloat,
-                                                    -source_rect.origin.y as AzFloat)
-                                         .mul(&self.state.transform);
+        let matrix = Matrix2D::identity()
+            .pre_translated(-source_rect.origin.x as AzFloat,
+                            -source_rect.origin.y as AzFloat)
+            .pre_mul(&self.state.transform);
         draw_target.set_transform(&matrix);
         draw_target
     }

components/canvas_traits/Cargo.toml

@@ -12,7 +12,7 @@ path = "lib.rs"
 [dependencies]
 azure = {git = "https://github.com/servo/rust-azure", features = ["plugins"]}
 cssparser = {version = "0.5.7", features = ["heap_size", "serde-serialization"]}
-euclid = "0.9"
+euclid = "0.10.1"
 gfx_traits = {path = "../gfx_traits"}
 heapsize = "0.3.0"
 heapsize_plugin = "0.1.2"

components/compositing/Cargo.toml

@@ -12,7 +12,7 @@ path = "lib.rs"
 [dependencies]
 app_units = "0.3"
 azure = {git = "https://github.com/servo/rust-azure", features = ["plugins"]}
-euclid = "0.9"
+euclid = "0.10.1"
 gfx_traits = {path = "../gfx_traits"}
 gleam = "0.2.8"
 image = "0.10"

components/compositing/compositor.rs

@@ -467,7 +467,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             context: None,
             root_pipeline: None,
             pipeline_details: HashMap::new(),
-            scene: Scene::new(TypedRect::new(TypedPoint2D::zero(), window_size.as_f32())),
+            scene: Scene::new(TypedRect::new(TypedPoint2D::zero(), window_size.to_f32())),
             window_size: window_size,
             viewport: None,
             scale_factor: scale_factor,
@@ -898,7 +898,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
 
         self.scene.root = Some(self.create_root_layer_for_pipeline_and_size(&frame_tree.pipeline,
                                                                             None));
-        self.scene.set_root_layer_size(self.window_size.as_f32());
+        self.scene.set_root_layer_size(self.window_size.to_f32());
 
         self.create_pipeline_details_for_frame_tree(&frame_tree);
 
@@ -1146,7 +1146,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
 
     fn send_window_size(&self, size_type: WindowSizeType) {
         let dppx = self.page_zoom * self.device_pixels_per_screen_px();
-        let initial_viewport = self.window_size.as_f32() / dppx;
+        let initial_viewport = self.window_size.to_f32() / dppx;
         let visible_viewport = initial_viewport / self.viewport_zoom;
         let msg = ConstellationMsg::WindowSize(WindowSizeData {
             device_pixel_ratio: dppx,
@@ -1383,7 +1383,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
 
         self.window_size = new_size;
 
-        self.scene.set_root_layer_size(new_size.as_f32());
+        self.scene.set_root_layer_size(new_size.to_f32());
         self.send_window_size(WindowSizeType::Resize);
     }
 
@@ -1627,8 +1627,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                     if let Some(combined_event) = last_combined_event {
                         if combined_event.phase != scroll_event.phase {
                             let delta = (combined_event.delta / self.scene.scale).to_untyped();
-                            let cursor = (combined_event.cursor.as_f32() /
-                                          self.scene.scale).to_untyped();
+                            let cursor =
+                                (combined_event.cursor.to_f32() / self.scene.scale).to_untyped();
                             webrender_api.scroll(delta, cursor, combined_event.phase);
                             last_combined_event = None
                         }
@@ -1669,7 +1669,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 // TODO(gw): Support zoom (WR issue #28).
                 if let Some(combined_event) = last_combined_event {
                     let delta = (combined_event.delta / self.scene.scale).to_untyped();
-                    let cursor = (combined_event.cursor.as_f32() / self.scene.scale).to_untyped();
+                    let cursor = (combined_event.cursor.to_f32() / self.scene.scale).to_untyped();
                     webrender_api.scroll(delta, cursor, combined_event.phase);
                     self.waiting_for_results_of_scroll = true
                 }
@@ -1678,7 +1678,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 for event in std_mem::replace(&mut self.pending_scroll_zoom_events,
                                                      Vec::new()) {
                     let delta = event.delta / self.scene.scale;
-                    let cursor = event.cursor.as_f32() / self.scene.scale;
+                    let cursor = event.cursor.to_f32() / self.scene.scale;
 
                     if let Some(ref mut layer) = self.scene.root {
                         layer.handle_scroll_event(delta, cursor);
@@ -1736,7 +1736,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         }
 
         let dppx = self.page_zoom * self.device_pixels_per_screen_px();
-        let window_size = self.window_size.as_f32() / dppx * ScaleFactor::new(1.0);
+        let window_size = self.window_size.to_f32() / dppx * ScaleFactor::new(1.0);
         let mut new_visible_rects = HashMap::new();
         if let Some(ref layer) = self.scene.root {
             process_layer(&**layer, &window_size, &mut new_visible_rects)
@@ -1835,7 +1835,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
 
         // We need to set the size of the root layer again, since the window size
         // has changed in unscaled layer pixels.
-        self.scene.set_root_layer_size(self.window_size.as_f32());
+        self.scene.set_root_layer_size(self.window_size.to_f32());
     }
 
     fn on_zoom_reset_window_event(&mut self) {
@@ -2236,8 +2236,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             self.dump_layer_tree();
             // Adjust the layer dimensions as necessary to correspond to the size of the window.
             self.scene.viewport = match self.viewport {
-                Some((point, size)) => TypedRect::new(point.as_f32(), size.as_f32()),
-                None => TypedRect::new(TypedPoint2D::zero(), self.window_size.as_f32()),
+                Some((point, size)) => TypedRect::new(point.to_f32(), size.to_f32()),
+                None => TypedRect::new(TypedPoint2D::zero(), self.window_size.to_f32()),
             };
 
             // Paint the scene.

components/constellation/Cargo.toml

@@ -15,7 +15,7 @@ canvas = {path = "../canvas"}
 canvas_traits = {path = "../canvas_traits"}
 compositing = {path = "../compositing"}
 devtools_traits = {path = "../devtools_traits"}
-euclid = "0.9"
+euclid = "0.10.1"
 gfx = {path = "../gfx"}
 gfx_traits = {path = "../gfx_traits"}
 ipc-channel = "0.5"
@@ -24,7 +24,7 @@ layout_traits = {path = "../layout_traits"}
 log = "0.3.5"
 msg = {path = "../msg"}
 net_traits = {path = "../net_traits"}
-offscreen_gl_context = "0.3"
+offscreen_gl_context = "0.4"
 plugins = {path = "../plugins"}
 profile_traits = {path = "../profile_traits"}
 rand = "0.3"

components/constellation/constellation.rs

@@ -501,9 +501,9 @@ impl<Message, LTF, STF> Constellation<Message, LTF, STF>
                 time_profiler_chan: state.time_profiler_chan,
                 mem_profiler_chan: state.mem_profiler_chan,
                 window_size: WindowSizeData {
-                    visible_viewport: opts::get().initial_window_size.as_f32() *
+                    visible_viewport: opts::get().initial_window_size.to_f32() *
                                           ScaleFactor::new(1.0),
-                    initial_viewport: opts::get().initial_window_size.as_f32() *
+                    initial_viewport: opts::get().initial_window_size.to_f32() *
                         ScaleFactor::new(1.0),
                     device_pixel_ratio:
                         ScaleFactor::new(opts::get().device_pixels_per_px.unwrap_or(1.0)),

components/gfx/Cargo.toml

@@ -14,7 +14,7 @@ path = "lib.rs"
 app_units = "0.3"
 azure = {git = "https://github.com/servo/rust-azure", features = ["plugins"]}
 bitflags = "0.7"
-euclid = "0.9"
+euclid = "0.10.1"
 fnv = "1.0"
 gfx_traits = {path = "../gfx_traits"}
 harfbuzz-sys = "0.1"

components/gfx/display_list/mod.rs

@@ -21,7 +21,7 @@ use euclid::approxeq::ApproxEq;
 use euclid::num::{One, Zero};
 use euclid::rect::TypedRect;
 use euclid::side_offsets::SideOffsets2D;
-use euclid::{Matrix2D, Matrix4D, Point2D, Rect, Size2D};
+use euclid::{Matrix4D, Point2D, Rect, Size2D};
 use fnv::FnvHasher;
 use gfx_traits::print_tree::PrintTree;
 use gfx_traits::{LayerId, ScrollPolicy, StackingContextId};
@@ -339,10 +339,7 @@ impl DisplayList {
                                            transform: &Matrix4D<f32>,
                                            index: usize) {
         let old_transform = paint_context.draw_target.get_transform();
-        paint_context.draw_target.set_transform(
-            &Matrix2D::new(transform.m11, transform.m12,
-                           transform.m21, transform.m22,
-                           transform.m41, transform.m42));
+        paint_context.draw_target.set_transform(&transform.to_2d());
 
         let item = &self.list[index];
         item.draw_into_context(paint_context);
@@ -459,9 +456,11 @@ impl DisplayList {
                     Point2D::new(origin.x.to_nearest_pixel(pixels_per_px.get()),
                                  origin.y.to_nearest_pixel(pixels_per_px.get()));
 
-                let transform = transform.translate(pixel_snapped_origin.x as AzFloat,
-                                                    pixel_snapped_origin.y as AzFloat,
-                                                    0.0).mul(&stacking_context.transform);
+                let transform = transform
+                    .pre_translated(pixel_snapped_origin.x as AzFloat,
+                                    pixel_snapped_origin.y as AzFloat,
+                                    0.0)
+                    .pre_mul(&stacking_context.transform);
 
                 if transform.is_identity_or_simple_translation() {
                     let pixel_snapped_origin = Point2D::new(Au::from_f32_px(pixel_snapped_origin.x),
@@ -477,6 +476,18 @@ impl DisplayList {
             }
         };
 
+        let transformed_transform =
+            match transformed_tile_rect(paint_context.screen_rect, &transform) {
+                Some(transformed) => transformed,
+                None => {
+                    // https://drafts.csswg.org/css-transforms/#transform-function-lists
+                    // If a transform function causes the current transformation matrix (CTM)
+                    // of an object to be non-invertible, the object and its content do not
+                    // get displayed.
+                    return;
+                },
+            };
+
         {
             let mut paint_subcontext = PaintContext {
                 draw_target: draw_target.clone(),
@@ -490,10 +501,7 @@ impl DisplayList {
             };
 
             // Set up our clip rect and transform.
-            paint_subcontext.draw_target.set_transform(
-                &Matrix2D::new(transform.m11, transform.m12,
-                               transform.m21, transform.m22,
-                               transform.m41, transform.m42));
+            paint_subcontext.draw_target.set_transform(&transform.to_2d());
             paint_subcontext.push_clip_if_applicable();
 
             self.draw_stacking_context_contents(
@@ -502,7 +510,7 @@ impl DisplayList {
                 &mut paint_subcontext,
                 &transform,
                 &subpixel_offset,
-                Some(transformed_tile_rect(paint_context.screen_rect, &transform)));
+                Some(transformed_transform));
 
             paint_subcontext.remove_transient_clip_if_applicable();
             paint_subcontext.pop_clip_if_applicable();
@@ -535,17 +543,20 @@ impl DisplayList {
     }
 }
 
-fn transformed_tile_rect(tile_rect: TypedRect<usize, ScreenPx>, transform: &Matrix4D<f32>) -> Rect<Au> {
+fn transformed_tile_rect(tile_rect: TypedRect<usize, ScreenPx>,
+                         transform: &Matrix4D<f32>)
+                         -> Option<Rect<Au>> {
     // Invert the current transform, then use this to back transform
     // the tile rect (placed at the origin) into the space of this
     // stacking context.
-    let inverse_transform = transform.invert();
-    let inverse_transform_2d = Matrix2D::new(inverse_transform.m11, inverse_transform.m12,
-                                             inverse_transform.m21, inverse_transform.m22,
-                                             inverse_transform.m41, inverse_transform.m42);
-    let tile_size = Size2D::new(tile_rect.as_f32().size.width, tile_rect.as_f32().size.height);
+    let inverse_transform = match transform.inverse() {
+        Some(inverse) => inverse,
+        None => return None,
+    };
+    let inverse_transform_2d = inverse_transform.to_2d();
+    let tile_size = Size2D::new(tile_rect.to_f32().size.width, tile_rect.to_f32().size.height);
     let tile_rect = Rect::new(Point2D::zero(), tile_size).to_untyped();
-    geometry::f32_rect_to_au_rect(inverse_transform_2d.transform_rect(&tile_rect))
+    Some(geometry::f32_rect_to_au_rect(inverse_transform_2d.transform_rect(&tile_rect)))
 }
 
 
@@ -699,11 +710,9 @@ impl StackingContext {
         let origin_x = self.bounds.origin.x.to_f32_px();
         let origin_y = self.bounds.origin.y.to_f32_px();
 
-        let transform = Matrix4D::identity().translate(origin_x, origin_y, 0.0)
-                                            .mul(&self.transform);
-        let transform_2d = Matrix2D::new(transform.m11, transform.m12,
-                                         transform.m21, transform.m22,
-                                         transform.m41, transform.m42);
+        let transform = Matrix4D::identity().pre_translated(origin_x, origin_y, 0.0)
+                                            .pre_mul(&self.transform);
+        let transform_2d = transform.to_2d();
 
         let overflow = geometry::au_rect_to_f32_rect(self.overflow);
         let overflow = transform_2d.transform_rect(&overflow);
@@ -726,7 +735,7 @@ impl StackingContext {
         // Convert the point into stacking context local transform space.
         let mut point = if self.context_type == StackingContextType::Real {
             let point = *effective_point - self.bounds.origin;
-            let inv_transform = self.transform.invert();
+            let inv_transform = self.transform.inverse().unwrap();
             let frac_point = inv_transform.transform_point(&Point2D::new(point.x.to_f32_px(),
                                                                          point.y.to_f32_px()));
             Point2D::new(Au::from_f32_px(frac_point.x), Au::from_f32_px(frac_point.y))

components/gfx/paint_context.rs

@@ -127,7 +127,7 @@ impl<'a> PaintContext<'a> {
     }
 
     pub fn screen_pixels_per_px(&self) -> ScaleFactor<f32, PagePx, ScreenPx> {
-        ScaleFactor::new(self.screen_rect.as_f32().size.width / self.page_rect.size.width)
+        ScaleFactor::new(self.screen_rect.to_f32().size.width / self.page_rect.size.width)
     }
 
     pub fn draw_target(&self) -> &DrawTarget {
@@ -242,7 +242,7 @@ impl<'a> PaintContext<'a> {
         //
         // Annoyingly, surface patterns in Azure/Skia are relative to the top left of the *canvas*,
         // not the rectangle we're drawing to. So we need to translate it explicitly.
-        let matrix = Matrix2D::identity().translate(dest_rect.origin.x, dest_rect.origin.y);
+        let matrix = Matrix2D::identity().pre_translated(dest_rect.origin.x, dest_rect.origin.y);
         let stretch_size = stretch_size.to_nearest_azure_size(scale);
         if source_rect.size == stretch_size {
             let pattern = SurfacePattern::new(azure_surface.azure_source_surface,
@@ -1358,17 +1358,15 @@ impl<'a> PaintContext<'a> {
             SidewaysLeft => {
                 let x = origin.x.to_f32_px();
                 let y = origin.y.to_f32_px();
-                self.draw_target.set_transform(&draw_target_transform.mul(&Matrix2D::new(0., -1.,
-                                                                                         1., 0.,
-                                                                                         x, y)));
+                self.draw_target.set_transform(
+                    &draw_target_transform.pre_mul(&Matrix2D::row_major(0., -1., 1., 0., x, y)));
                 Point2D::zero()
             }
             SidewaysRight => {
                 let x = origin.x.to_f32_px();
                 let y = origin.y.to_f32_px();
-                self.draw_target.set_transform(&draw_target_transform.mul(&Matrix2D::new(0., 1.,
-                                                                                         -1., 0.,
-                                                                                         x, y)));
+                self.draw_target.set_transform(
+                    &draw_target_transform.pre_mul(&Matrix2D::row_major(0., 1., -1., 0., x, y)));
                 Point2D::zero()
             }
         };
@@ -1450,9 +1448,10 @@ impl<'a> PaintContext<'a> {
                                           Size2D::new(size.width as AzFloat,
                                                       size.height as AzFloat));
             let temporary_draw_target_bounds = old_transform.transform_rect(&inflated_size);
-            matrix = Matrix2D::identity().translate(
-                -temporary_draw_target_bounds.origin.x as AzFloat,
-                -temporary_draw_target_bounds.origin.y as AzFloat).mul(&old_transform);
+            matrix = Matrix2D::identity()
+                .pre_translated(-temporary_draw_target_bounds.origin.x as AzFloat,
+                                -temporary_draw_target_bounds.origin.y as AzFloat)
+                .pre_mul(&old_transform);
         }
 
         let temporary_draw_target =
@@ -1978,10 +1977,10 @@ impl TemporaryDrawTarget {
         let temporary_draw_target =
             main_draw_target.create_similar_draw_target(&temporary_draw_target_size,
                                                         main_draw_target.get_format());
-        let matrix =
-            Matrix2D::identity().translate(-temporary_draw_target_bounds.origin.x as AzFloat,
-                                           -temporary_draw_target_bounds.origin.y as AzFloat)
-                                .mul(&draw_target_transform);
+        let matrix = Matrix2D::identity()
+            .pre_translated(-temporary_draw_target_bounds.origin.x as AzFloat,
+                            -temporary_draw_target_bounds.origin.y as AzFloat)
+            .pre_mul(&draw_target_transform);
         temporary_draw_target.set_transform(&matrix);
         TemporaryDrawTarget {
             draw_target: temporary_draw_target,