Properly serialize % values in calc expressions

3 files changed, 46 insertions, 39 deletions

diff --git a/components/style/properties.mako.rs b/components/style/properties.mako.rs
index 1ec5b97bd2c..2df2e339939 100644
--- a/components/style/properties.mako.rs
+++ b/components/style/properties.mako.rs
@@ -1912,7 +1912,7 @@ pub mod longhands {
             .map(|value| match value {
                 specified::LengthOrPercentage::Length(value) => value,
                 specified::LengthOrPercentage::Percentage(value) =>
-                    specified::Length::FontRelative(specified::FontRelativeLength::Em(value)),
+                    specified::Length::FontRelative(specified::FontRelativeLength::Em(value.0)),
                 // FIXME(dzbarsky) handle calc for font-size
                 specified::LengthOrPercentage::Calc(_) =>
                     specified::Length::FontRelative(specified::FontRelativeLength::Em(1.)),
@@ -3986,6 +3986,7 @@ pub mod longhands {
     }
 
     pub fn parse_origin(_: &ParserContext, input: &mut Parser) -> Result<OriginParseResult,()> {
+        use values::specified::{LengthOrPercentage, Percentage};
         let (mut horizontal, mut vertical, mut depth) = (None, None, None);
         loop {
             if let Err(_) = input.try(|input| {
@@ -3994,37 +3995,37 @@ pub mod longhands {
                     token,
                     "left" => {
                         if horizontal.is_none() {
-                            horizontal = Some(specified::LengthOrPercentage::Percentage(0.0))
+                            horizontal = Some(LengthOrPercentage::Percentage(Percentage(0.0)))
                         } else {
                             return Err(())
                         }
                     },
                     "center" => {
                         if horizontal.is_none() {
-                            horizontal = Some(specified::LengthOrPercentage::Percentage(0.5))
+                            horizontal = Some(LengthOrPercentage::Percentage(Percentage(0.5)))
                         } else if vertical.is_none() {
-                            vertical = Some(specified::LengthOrPercentage::Percentage(0.5))
+                            vertical = Some(LengthOrPercentage::Percentage(Percentage(0.5)))
                         } else {
                             return Err(())
                         }
                     },
                     "right" => {
                         if horizontal.is_none() {
-                            horizontal = Some(specified::LengthOrPercentage::Percentage(1.0))
+                            horizontal = Some(LengthOrPercentage::Percentage(Percentage(1.0)))
                         } else {
                             return Err(())
                         }
                     },
                     "top" => {
                         if vertical.is_none() {
-                            vertical = Some(specified::LengthOrPercentage::Percentage(0.0))
+                            vertical = Some(LengthOrPercentage::Percentage(Percentage(0.0)))
                         } else {
                             return Err(())
                         }
                     },
                     "bottom" => {
                         if vertical.is_none() {
-                            vertical = Some(specified::LengthOrPercentage::Percentage(1.0))
+                            vertical = Some(LengthOrPercentage::Percentage(Percentage(1.0)))
                         } else {
                             return Err(())
                         }
@@ -4033,13 +4034,13 @@ pub mod longhands {
                 }
                 Ok(())
             }) {
-                match specified::LengthOrPercentage::parse(input) {
+                match LengthOrPercentage::parse(input) {
                     Ok(value) => {
                         if horizontal.is_none() {
                             horizontal = Some(value);
                         } else if vertical.is_none() {
                             vertical = Some(value);
-                        } else if let specified::LengthOrPercentage::Length(length) = value {
+                        } else if let LengthOrPercentage::Length(length) = value {
                             depth = Some(length);
                         } else {
                             break;
@@ -4067,7 +4068,7 @@ pub mod longhands {
 
     <%self:longhand name="transform-origin">
         use values::computed::Context;
-        use values::specified::{Length, LengthOrPercentage};
+        use values::specified::{Length, LengthOrPercentage, Percentage};
 
         use cssparser::ToCss;
         use std::fmt;
@@ -4123,8 +4124,8 @@ pub mod longhands {
         pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue,()> {
             let result = try!(super::parse_origin(context, input));
             Ok(SpecifiedValue {
-                horizontal: result.horizontal.unwrap_or(LengthOrPercentage::Percentage(0.5)),
-                vertical: result.vertical.unwrap_or(LengthOrPercentage::Percentage(0.5)),
+                horizontal: result.horizontal.unwrap_or(LengthOrPercentage::Percentage(Percentage(0.5))),
+                vertical: result.vertical.unwrap_or(LengthOrPercentage::Percentage(Percentage(0.5))),
                 depth: result.depth.unwrap_or(Length::Absolute(Au(0))),
             })
         }
@@ -4149,7 +4150,7 @@ pub mod longhands {
 
     <%self:longhand name="perspective-origin">
         use values::computed::Context;
-        use values::specified::LengthOrPercentage;
+        use values::specified::{LengthOrPercentage, Percentage};
 
         use cssparser::ToCss;
         use std::fmt;
@@ -4199,8 +4200,8 @@ pub mod longhands {
             match result.depth {
                 Some(_) => Err(()),
                 None => Ok(SpecifiedValue {
-                    horizontal: result.horizontal.unwrap_or(LengthOrPercentage::Percentage(0.5)),
-                    vertical: result.vertical.unwrap_or(LengthOrPercentage::Percentage(0.5)),
+                    horizontal: result.horizontal.unwrap_or(LengthOrPercentage::Percentage(Percentage(0.5))),
+                    vertical: result.vertical.unwrap_or(LengthOrPercentage::Percentage(Percentage(0.5))),
                 })
             }
         }
diff --git a/components/style/values.rs b/components/style/values.rs
index 70ec4c46901..76f34f69941 100644
--- a/components/style/values.rs
+++ b/components/style/values.rs
@@ -387,7 +387,7 @@ pub mod specified {
         pub em: Option<FontRelativeLength>,
         pub ex: Option<FontRelativeLength>,
         pub rem: Option<FontRelativeLength>,
-        pub percentage: Option<CSSFloat>,
+        pub percentage: Option<Percentage>,
     }
     impl Calc {
         fn parse_sum(input: &mut Parser) -> Result<CalcSumNode, ()> {
@@ -603,7 +603,7 @@ pub mod specified {
                 em: em.map(FontRelativeLength::Em),
                 ex: ex.map(FontRelativeLength::Ex),
                 rem: rem.map(FontRelativeLength::Rem),
-                percentage: percentage,
+                percentage: percentage.map(Percentage),
             })
         }
     }
@@ -660,9 +660,18 @@ pub mod specified {
     }
 
     #[derive(Clone, PartialEq, Copy, Debug, HeapSizeOf)]
+    pub struct Percentage(pub CSSFloat); // [0 .. 100%] maps to [0.0 .. 1.0]
+
+    impl ToCss for Percentage {
+        fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+            write!(dest, "{}%", self.0 * 100.)
+        }
+    }
+
+    #[derive(Clone, PartialEq, Copy, Debug, HeapSizeOf)]
     pub enum LengthOrPercentage {
         Length(Length),
-        Percentage(CSSFloat),  // [0 .. 100%] maps to [0.0 .. 1.0]
+        Percentage(Percentage),
         Calc(Calc),
     }
 
@@ -670,8 +679,7 @@ pub mod specified {
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             match self {
                 &LengthOrPercentage::Length(length) => length.to_css(dest),
-                &LengthOrPercentage::Percentage(percentage)
-                => write!(dest, "{}%", percentage * 100.),
+                &LengthOrPercentage::Percentage(percentage) => percentage.to_css(dest),
                 &LengthOrPercentage::Calc(calc) => calc.to_css(dest),
             }
         }
@@ -688,7 +696,7 @@ pub mod specified {
                 Token::Dimension(ref value, ref unit) if context.is_ok(value.value) =>
                     Length::parse_dimension(value.value, unit).map(LengthOrPercentage::Length),
                 Token::Percentage(ref value) if context.is_ok(value.unit_value) =>
-                    Ok(LengthOrPercentage::Percentage(value.unit_value)),
+                    Ok(LengthOrPercentage::Percentage(Percentage(value.unit_value))),
                 Token::Number(ref value) if value.value == 0. =>
                     Ok(LengthOrPercentage::Length(Length::Absolute(Au(0)))),
                 Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
@@ -712,7 +720,7 @@ pub mod specified {
     #[derive(Clone, PartialEq, Copy, Debug, HeapSizeOf)]
     pub enum LengthOrPercentageOrAuto {
         Length(Length),
-        Percentage(CSSFloat),  // [0 .. 100%] maps to [0.0 .. 1.0]
+        Percentage(Percentage),
         Auto,
         Calc(Calc),
     }
@@ -721,8 +729,7 @@ pub mod specified {
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             match self {
                 &LengthOrPercentageOrAuto::Length(length) => length.to_css(dest),
-                &LengthOrPercentageOrAuto::Percentage(percentage)
-                => write!(dest, "{}%", percentage * 100.),
+                &LengthOrPercentageOrAuto::Percentage(percentage) => percentage.to_css(dest),
                 &LengthOrPercentageOrAuto::Auto => dest.write_str("auto"),
                 &LengthOrPercentageOrAuto::Calc(calc) => calc.to_css(dest),
             }
@@ -737,7 +744,7 @@ pub mod specified {
                 Token::Dimension(ref value, ref unit) if context.is_ok(value.value) =>
                     Length::parse_dimension(value.value, unit).map(LengthOrPercentageOrAuto::Length),
                 Token::Percentage(ref value) if context.is_ok(value.unit_value) =>
-                    Ok(LengthOrPercentageOrAuto::Percentage(value.unit_value)),
+                    Ok(LengthOrPercentageOrAuto::Percentage(Percentage(value.unit_value))),
                 Token::Number(ref value) if value.value == 0. =>
                     Ok(LengthOrPercentageOrAuto::Length(Length::Absolute(Au(0)))),
                 Token::Ident(ref value) if value.eq_ignore_ascii_case("auto") =>
@@ -762,7 +769,7 @@ pub mod specified {
     #[derive(Clone, PartialEq, Copy, Debug, HeapSizeOf)]
     pub enum LengthOrPercentageOrNone {
         Length(Length),
-        Percentage(CSSFloat),  // [0 .. 100%] maps to [0.0 .. 1.0]
+        Percentage(Percentage),
         None,
     }
 
@@ -770,8 +777,7 @@ pub mod specified {
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             match self {
                 &LengthOrPercentageOrNone::Length(length) => length.to_css(dest),
-                &LengthOrPercentageOrNone::Percentage(percentage) =>
-                    write!(dest, "{}%", percentage * 100.),
+                &LengthOrPercentageOrNone::Percentage(percentage) => percentage.to_css(dest),
                 &LengthOrPercentageOrNone::None => dest.write_str("none"),
             }
         }
@@ -784,7 +790,7 @@ pub mod specified {
                 Token::Dimension(ref value, ref unit) if context.is_ok(value.value) =>
                     Length::parse_dimension(value.value, unit).map(LengthOrPercentageOrNone::Length),
                 Token::Percentage(ref value) if context.is_ok(value.unit_value) =>
-                    Ok(LengthOrPercentageOrNone::Percentage(value.unit_value)),
+                    Ok(LengthOrPercentageOrNone::Percentage(Percentage(value.unit_value))),
                 Token::Number(ref value) if value.value == 0. =>
                     Ok(LengthOrPercentageOrNone::Length(Length::Absolute(Au(0)))),
                 Token::Ident(ref value) if value.eq_ignore_ascii_case("none") =>
@@ -846,7 +852,7 @@ pub mod specified {
     #[derive(Clone, PartialEq, Copy)]
     pub enum PositionComponent {
         Length(Length),
-        Percentage(CSSFloat),  // [0 .. 100%] maps to [0.0 .. 1.0]
+        Percentage(Percentage),
         Center,
         Left,
         Right,
@@ -861,7 +867,7 @@ pub mod specified {
                     .map(PositionComponent::Length)
                 }
                 Token::Percentage(ref value) => {
-                    Ok(PositionComponent::Percentage(value.unit_value))
+                    Ok(PositionComponent::Percentage(Percentage(value.unit_value)))
                 }
                 Token::Number(ref value) if value.value == 0. => {
                     Ok(PositionComponent::Length(Length::Absolute(Au(0))))
@@ -884,11 +890,11 @@ pub mod specified {
             match self {
                 PositionComponent::Length(x) => LengthOrPercentage::Length(x),
                 PositionComponent::Percentage(x) => LengthOrPercentage::Percentage(x),
-                PositionComponent::Center => LengthOrPercentage::Percentage(0.5),
+                PositionComponent::Center => LengthOrPercentage::Percentage(Percentage(0.5)),
                 PositionComponent::Left |
-                PositionComponent::Top => LengthOrPercentage::Percentage(0.0),
+                PositionComponent::Top => LengthOrPercentage::Percentage(Percentage(0.0)),
                 PositionComponent::Right |
-                PositionComponent::Bottom => LengthOrPercentage::Percentage(1.0),
+                PositionComponent::Bottom => LengthOrPercentage::Percentage(Percentage(1.0)),
             }
         }
     }
@@ -1305,7 +1311,7 @@ pub mod computed {
                 }
             }
 
-            Calc { length: length, percentage: self.percentage }
+            Calc { length: length, percentage: self.percentage.map(|p| p.0) }
         }
     }
 
@@ -1342,7 +1348,7 @@ pub mod computed {
                     LengthOrPercentage::Length(value.to_computed_value(context))
                 }
                 specified::LengthOrPercentage::Percentage(value) => {
-                    LengthOrPercentage::Percentage(value)
+                    LengthOrPercentage::Percentage(value.0)
                 }
                 specified::LengthOrPercentage::Calc(calc) => {
                     LengthOrPercentage::Calc(calc.to_computed_value(context))
@@ -1390,7 +1396,7 @@ pub mod computed {
                     LengthOrPercentageOrAuto::Length(value.to_computed_value(context))
                 }
                 specified::LengthOrPercentageOrAuto::Percentage(value) => {
-                    LengthOrPercentageOrAuto::Percentage(value)
+                    LengthOrPercentageOrAuto::Percentage(value.0)
                 }
                 specified::LengthOrPercentageOrAuto::Auto => {
                     LengthOrPercentageOrAuto::Auto
@@ -1440,7 +1446,7 @@ pub mod computed {
                     LengthOrPercentageOrNone::Length(value.to_computed_value(context))
                 }
                 specified::LengthOrPercentageOrNone::Percentage(value) => {
-                    LengthOrPercentageOrNone::Percentage(value)
+                    LengthOrPercentageOrNone::Percentage(value.0)
                 }
                 specified::LengthOrPercentageOrNone::None => {
                     LengthOrPercentageOrNone::None
diff --git a/components/style/viewport.rs b/components/style/viewport.rs
index cc56030e226..247cd6400ae 100644
--- a/components/style/viewport.rs
+++ b/components/style/viewport.rs
@@ -451,7 +451,7 @@ impl ViewportConstraints {
                         LengthOrPercentageOrAuto::Length(value) =>
                             Some(value.to_computed_value(&context)),
                         LengthOrPercentageOrAuto::Percentage(value) =>
-                            Some(initial_viewport.$dimension.scale_by(value)),
+                            Some(initial_viewport.$dimension.scale_by(value.0)),
                         LengthOrPercentageOrAuto::Auto => None,
                         LengthOrPercentageOrAuto::Calc(calc) => {
                             let calc = calc.to_computed_value(&context);