From 02d930578268d7ccd14fc580ae1041e1c77e102b Mon Sep 17 00:00:00 2001 From: Gecko Backout Date: Tue, 11 Jul 2017 22:14:04 +0000 Subject: [PATCH] Backed out changeset 3977404931e5 for failing mochitest layout/style/test/test_value_computation.html. r=backout Backs out https://github.com/servo/servo/pull/17654 --- components/style/gecko/generated/bindings.rs | 2 +- components/style/properties/gecko.mako.rs | 4 +- .../properties/longhand/inherited_box.mako.rs | 79 ++++--------------- components/style/values/computed/mod.rs | 29 +++---- 4 files changed, 29 insertions(+), 85 deletions(-) diff --git a/components/style/gecko/generated/bindings.rs b/components/style/gecko/generated/bindings.rs index f5c64216008..427992d8939 100644 --- a/components/style/gecko/generated/bindings.rs +++ b/components/style/gecko/generated/bindings.rs @@ -897,7 +897,7 @@ extern "C" { } extern "C" { pub fn Gecko_SetImageOrientation(aVisibility: *mut nsStyleVisibility, - aOrientation: u8, aFlip: bool); + aRadians: f64, aFlip: bool); } extern "C" { pub fn Gecko_SetImageOrientationAsFromImage(aVisibility: diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs index 240139c33cb..13f7b130841 100644 --- a/components/style/properties/gecko.mako.rs +++ b/components/style/properties/gecko.mako.rs @@ -3846,9 +3846,9 @@ fn static_assert() { bindings::Gecko_SetImageOrientationAsFromImage(&mut self.gecko); } }, - T::AngleWithFlipped(ref orientation, flipped) => { + T::AngleWithFlipped(ref angle, flipped) => { unsafe { - bindings::Gecko_SetImageOrientation(&mut self.gecko, *orientation as u8, flipped); + bindings::Gecko_SetImageOrientation(&mut self.gecko, angle.radians() as f64, flipped); } } } diff --git a/components/style/properties/longhand/inherited_box.mako.rs b/components/style/properties/longhand/inherited_box.mako.rs index b6830761abf..772847df0ba 100644 --- a/components/style/properties/longhand/inherited_box.mako.rs +++ b/components/style/properties/longhand/inherited_box.mako.rs @@ -68,8 +68,9 @@ ${helpers.single_keyword("image-rendering", no_viewport_percentage!(SpecifiedValue); - use std::f64::consts::PI; - const TWO_PI: f64 = 2.0 * PI; + use std::f32::consts::PI; + use values::CSSFloat; + const TWO_PI: CSSFloat = 2.0 * PI; #[derive(Clone, PartialEq, Copy, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] @@ -98,77 +99,31 @@ ${helpers.single_keyword("image-rendering", } pub mod computed_value { - use std::fmt; - use style_traits::ToCss; - use values::specified::Angle; - - #[derive(Copy, Clone, Debug, Eq, PartialEq)] - #[cfg_attr(feature = "servo", derive(HeapSizeOf))] - pub enum Orientation { - Angle0 = 0, - Angle90, - Angle180, - Angle270, - } - - impl Orientation { - pub fn angle(&self) -> Angle { - match *self { - Orientation::Angle0 => Angle::from_degrees(0.0, false), - Orientation::Angle90 => Angle::from_degrees(90.0, false), - Orientation::Angle180 => Angle::from_degrees(180.0, false), - Orientation::Angle270 => Angle::from_degrees(270.0, false), - } - } - } - - impl ToCss for Orientation { - fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { - // Should agree with Angle::to_css. - match *self { - Orientation::Angle0 => dest.write_str("0deg"), - Orientation::Angle90 => dest.write_str("90deg"), - Orientation::Angle180 => dest.write_str("180deg"), - Orientation::Angle270 => dest.write_str("270deg"), - } - } - } + use values::computed::Angle; #[derive(Clone, PartialEq, Copy, Debug)] #[cfg_attr(feature = "servo", derive(HeapSizeOf))] pub enum T { FromImage, - AngleWithFlipped(Orientation, bool), + AngleWithFlipped(Angle, bool), } } - use self::computed_value::Orientation; - #[inline] pub fn get_initial_value() -> computed_value::T { - computed_value::T::AngleWithFlipped(Orientation::Angle0, false) + computed_value::T::AngleWithFlipped(computed::Angle::zero(), false) } // According to CSS Content Module Level 3: // The computed value of the property is calculated by rounding the specified angle // to the nearest quarter-turn, rounding away from 0, then moduloing the value by 1 turn. - // This mirrors the Gecko implementation in - // nsStyleImageOrientation::CreateAsAngleAndFlip. #[inline] - fn orientation_of_angle(angle: &computed::Angle) -> Orientation { - // Note that `angle` can be negative. - let mut rounded_angle = angle.radians64() % TWO_PI; - if rounded_angle < 0.0 { - // This computation introduces rounding error. Gecko previously - // didn't handle the negative case correctly; by branching we can - // match Gecko's behavior when it was correct. - rounded_angle = rounded_angle + TWO_PI; - } - if rounded_angle < 0.25 * PI { Orientation::Angle0 } - else if rounded_angle < 0.75 * PI { Orientation::Angle90 } - else if rounded_angle < 1.25 * PI { Orientation::Angle180 } - else if rounded_angle < 1.75 * PI { Orientation::Angle270 } - else { Orientation::Angle0 } + fn normalize_angle(angle: &computed::Angle) -> computed::Angle { + let radians = angle.radians(); + let rounded_quarter_turns = (4.0 * radians / TWO_PI).round(); + let normalized_quarter_turns = (rounded_quarter_turns % 4.0 + 4.0) % 4.0; + let normalized_radians = normalized_quarter_turns/4.0 * TWO_PI; + computed::Angle::from_radians(normalized_radians) } impl ToComputedValue for SpecifiedValue { @@ -178,11 +133,11 @@ ${helpers.single_keyword("image-rendering", fn to_computed_value(&self, context: &Context) -> computed_value::T { if let Some(ref angle) = self.angle { let angle = angle.to_computed_value(context); - let orientation = orientation_of_angle(&angle); - computed_value::T::AngleWithFlipped(orientation, self.flipped) + let normalized_angle = normalize_angle(&angle); + computed_value::T::AngleWithFlipped(normalized_angle, self.flipped) } else { if self.flipped { - computed_value::T::AngleWithFlipped(Orientation::Angle0, true) + computed_value::T::AngleWithFlipped(computed::Angle::zero(), true) } else { computed_value::T::FromImage } @@ -193,9 +148,9 @@ ${helpers.single_keyword("image-rendering", fn from_computed_value(computed: &computed_value::T) -> Self { match *computed { computed_value::T::FromImage => SpecifiedValue { angle: None, flipped: false }, - computed_value::T::AngleWithFlipped(ref orientation, flipped) => { + computed_value::T::AngleWithFlipped(ref angle, flipped) => { SpecifiedValue { - angle: Some(orientation.angle()), + angle: Some(Angle::from_computed_value(angle)), flipped: flipped, } } diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs index 1183cbd3044..9b08cd6e2bb 100644 --- a/components/style/values/computed/mod.rs +++ b/components/style/values/computed/mod.rs @@ -13,8 +13,7 @@ use media_queries::Device; use properties; use properties::{ComputedValues, StyleBuilder}; use std::f32; -use std::f64; -use std::f64::consts::PI; +use std::f32::consts::PI; use std::fmt; use style_traits::ToCss; use super::{CSSFloat, CSSInteger, RGBA}; @@ -314,27 +313,17 @@ impl Angle { /// Return the amount of radians this angle represents. #[inline] pub fn radians(&self) -> CSSFloat { - self.radians64().min(f32::MAX as f64).max(f32::MIN as f64) as f32 - } - - /// Return the amount of radians this angle represents as a 64-bit float. - /// Gecko stores angles as singles, but does this computation using doubles. - /// See nsCSSValue::GetAngleValueInRadians. - /// This is significant enough to mess up rounding to the nearest - /// quarter-turn for 225 degrees, for example. - #[inline] - pub fn radians64(&self) -> f64 { - const RAD_PER_DEG: f64 = PI / 180.0; - const RAD_PER_GRAD: f64 = PI / 200.0; - const RAD_PER_TURN: f64 = PI * 2.0; + const RAD_PER_DEG: CSSFloat = PI / 180.0; + const RAD_PER_GRAD: CSSFloat = PI / 200.0; + const RAD_PER_TURN: CSSFloat = PI * 2.0; let radians = match *self { - Angle::Degree(val) => val as f64 * RAD_PER_DEG, - Angle::Gradian(val) => val as f64 * RAD_PER_GRAD, - Angle::Turn(val) => val as f64 * RAD_PER_TURN, - Angle::Radian(val) => val as f64, + Angle::Degree(val) => val * RAD_PER_DEG, + Angle::Gradian(val) => val * RAD_PER_GRAD, + Angle::Turn(val) => val * RAD_PER_TURN, + Angle::Radian(val) => val, }; - radians.min(f64::MAX).max(f64::MIN) + radians.min(f32::MAX).max(f32::MIN) } /// Returns an angle that represents a rotation of zero radians.