style: Update font-style to css-fonts-4.

Bug: 1455358
Reviewed-by: xidorn
MozReview-Commit-ID: 1Nq5DyCjaZe

components/style/values/computed/font.rs

@@ -21,7 +21,7 @@ use std::slice;
 use style_traits::{CssWriter, ParseError, ToCss};
 use values::CSSFloat;
 use values::animated::{ToAnimatedValue, ToAnimatedZero};
-use values::computed::{Context, Integer, NonNegativeLength, Number, ToComputedValue};
+use values::computed::{Angle, Context, Integer, NonNegativeLength, Number, ToComputedValue};
 use values::generics::font::{FeatureTagValue, FontSettings};
 use values::generics::font::{KeywordInfo as GenericKeywordInfo, VariationValue};
 use values::specified::font::{self as specified, MIN_FONT_WEIGHT, MAX_FONT_WEIGHT};
@@ -838,3 +838,68 @@ impl ToComputedValue for specified::MozScriptLevel {
         specified::MozScriptLevel::MozAbsolute(*other as i32)
     }
 }
+
+/// The computed value of `font-style`.
+#[derive(Animate, Clone, ComputeSquaredDistance, Copy, Debug, MallocSizeOf,
+         PartialEq)]
+#[allow(missing_docs)]
+pub enum FontStyle {
+    #[animation(error)]
+    Normal,
+    #[animation(error)]
+    Italic,
+    // FIXME(emilio): This needs to clamp really.
+    Oblique(Angle),
+}
+
+impl ToAnimatedZero for FontStyle {
+    #[inline]
+    fn to_animated_zero(&self) -> Result<Self, ()> {
+        use num_traits::Zero;
+        Ok(FontStyle::Oblique(Angle::zero()))
+    }
+}
+
+impl FontStyle {
+    /// The default angle for font-style: oblique. This is 20deg per spec:
+    ///
+    /// https://drafts.csswg.org/css-fonts-4/#valdef-font-style-oblique-angle
+    pub fn default_angle() -> Angle {
+        Angle::Deg(specified::DEFAULT_FONT_STYLE_OBLIQUE_ANGLE_DEGREES)
+    }
+
+
+    /// Get the font style from Gecko's nsFont struct.
+    #[cfg(feature = "gecko")]
+    pub fn from_gecko(kw: u8) -> Self {
+        use gecko_bindings::structs;
+
+        match kw as u32 {
+            structs::NS_STYLE_FONT_STYLE_NORMAL => FontStyle::Normal,
+            structs::NS_STYLE_FONT_STYLE_ITALIC => FontStyle::Italic,
+            // FIXME(emilio): Grab the angle when we honor it :)
+            structs::NS_STYLE_FONT_STYLE_OBLIQUE => FontStyle::Oblique(Self::default_angle()),
+            _ => unreachable!("Unknown font style"),
+        }
+    }
+}
+
+impl ToCss for FontStyle {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        match *self {
+            FontStyle::Normal => dest.write_str("normal"),
+            FontStyle::Italic => dest.write_str("italic"),
+            FontStyle::Oblique(ref angle) => {
+                dest.write_str("oblique")?;
+                if *angle != Self::default_angle() {
+                    dest.write_char(' ')?;
+                    angle.to_css(dest)?;
+                }
+                Ok(())
+            }
+        }
+    }
+}

components/style/values/computed/mod.rs

@@ -40,7 +40,7 @@ pub use self::background::{BackgroundRepeat, BackgroundSize};
 pub use self::border::{BorderImageRepeat, BorderImageSideWidth, BorderImageSlice, BorderImageWidth};
 pub use self::border::{BorderCornerRadius, BorderRadius, BorderSpacing};
 pub use self::font::{FontSize, FontSizeAdjust, FontStretch, FontSynthesis, FontVariantAlternates, FontWeight};
-pub use self::font::{FontFamily, FontLanguageOverride, FontVariantEastAsian, FontVariationSettings};
+pub use self::font::{FontFamily, FontLanguageOverride, FontStyle, FontVariantEastAsian, FontVariationSettings};
 pub use self::font::{FontFeatureSettings, FontVariantLigatures, FontVariantNumeric};
 pub use self::font::{MozScriptLevel, MozScriptMinSize, MozScriptSizeMultiplier, XLang, XTextZoom};
 pub use self::box_::{AnimationIterationCount, AnimationName, Contain, Display};

components/style/values/specified/angle.rs

@@ -41,13 +41,19 @@ impl ToCss for Angle {
     }
 }
 
+// FIXME(emilio): Probably computed angles shouldn't preserve the unit and
+// should serialize to degrees per:
+//
+// https://drafts.csswg.org/css-values/#compat
 impl ToComputedValue for Angle {
     type ComputedValue = ComputedAngle;
 
+    #[inline]
     fn to_computed_value(&self, _context: &Context) -> Self::ComputedValue {
         self.value
     }
 
+    #[inline]
     fn from_computed_value(computed: &Self::ComputedValue) -> Self {
         Angle {
             value: *computed,
@@ -89,6 +95,12 @@ impl Angle {
         }
     }
 
+    /// Whether this specified angle came from a `calc()` expression.
+    #[inline]
+    pub fn was_calc(&self) -> bool {
+        self.was_calc
+    }
+
     /// Returns the amount of radians this angle represents.
     #[inline]
     pub fn radians(self) -> f32 {

components/style/values/specified/font.rs

@@ -17,13 +17,13 @@ use properties::longhands::system_font::SystemFont;
 use std::fmt::{self, Write};
 use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
 use values::CustomIdent;
-use values::computed::Percentage as ComputedPercentage;
+use values::computed::{Angle as ComputedAngle, Percentage as ComputedPercentage};
 use values::computed::{font as computed, Context, Length, NonNegativeLength, ToComputedValue};
 use values::computed::font::{FamilyName, FontFamilyList, SingleFontFamily};
 use values::generics::NonNegative;
 use values::generics::font::{FeatureTagValue, FontSettings, FontTag};
 use values::generics::font::{KeywordInfo as GenericKeywordInfo, KeywordSize, VariationValue};
-use values::specified::{AllowQuirks, Integer, LengthOrPercentage, NoCalcLength, Number, Percentage};
+use values::specified::{AllowQuirks, Angle, Integer, LengthOrPercentage, NoCalcLength, Number, Percentage};
 use values::specified::length::{FontBaseSize, AU_PER_PT, AU_PER_PX};
 
 const DEFAULT_SCRIPT_MIN_SIZE_PT: u32 = 8;
@@ -191,6 +191,166 @@ impl Parse for AbsoluteFontWeight {
     }
 }
 
+/// A specified value for the `font-style` property.
+///
+/// https://drafts.csswg.org/css-fonts-4/#font-style-prop
+///
+/// FIXME(emilio): It'd be nice to share more code with computed::FontStyle,
+/// except the system font stuff makes it kind of a pain.
+#[allow(missing_docs)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
+pub enum FontStyle {
+    Normal,
+    Italic,
+    Oblique(Angle),
+    System(SystemFont),
+}
+
+impl ToComputedValue for FontStyle {
+    type ComputedValue = computed::FontStyle;
+
+    fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
+        match *self {
+            FontStyle::Normal => computed::FontStyle::Normal,
+            FontStyle::Italic => computed::FontStyle::Italic,
+            FontStyle::Oblique(ref angle) => {
+                computed::FontStyle::Oblique(angle.to_computed_value(context))
+            }
+            #[cfg(feature = "gecko")]
+            FontStyle::System(..) => context
+                .cached_system_font
+                .as_ref()
+                .unwrap()
+                .font_style
+                .clone(),
+            #[cfg(not(feature = "gecko"))]
+            FontStyle::System(_) => unreachable!(),
+        }
+    }
+
+    fn from_computed_value(computed: &Self::ComputedValue) -> Self {
+        match *computed {
+            computed::FontStyle::Normal => FontStyle::Normal,
+            computed::FontStyle::Italic => FontStyle::Italic,
+            computed::FontStyle::Oblique(ref angle) => {
+                FontStyle::Oblique(Angle::from_computed_value(angle))
+            }
+        }
+    }
+}
+
+/// The default angle for `font-style: oblique`.
+///
+/// NOTE(emilio): As of right now this diverges from the spec, which specifies
+/// 20, because it's not updated yet to account for the resolution in:
+///
+///   https://github.com/w3c/csswg-drafts/issues/2295
+pub const DEFAULT_FONT_STYLE_OBLIQUE_ANGLE_DEGREES: f32 = 14.;
+
+/// From https://drafts.csswg.org/css-fonts-4/#valdef-font-style-oblique-angle:
+///
+///     Values less than -90deg or values greater than 90deg are
+///     invalid and are treated as parse errors.
+///
+/// The maximum angle value that `font-style: oblique` should compute to.
+pub const FONT_STYLE_OBLIQUE_MAX_ANGLE_DEGREES: f32 = 90.;
+
+/// The minimum angle value that `font-style: oblique` should compute to.
+pub const FONT_STYLE_OBLIQUE_MIN_ANGLE_DEGREES: f32 = -90.;
+
+impl FontStyle {
+    /// More system font copy-pasta.
+    pub fn system_font(f: SystemFont) -> Self {
+        FontStyle::System(f)
+    }
+
+    /// Retreive a SystemFont from FontStyle.
+    pub fn get_system(&self) -> Option<SystemFont> {
+        if let FontStyle::System(s) = *self {
+            Some(s)
+        } else {
+            None
+        }
+    }
+
+    /// Gets a clamped angle from a specified Angle.
+    pub fn compute_angle(angle: &Angle) -> ComputedAngle {
+        ComputedAngle::Deg(
+            angle.degrees()
+                .max(FONT_STYLE_OBLIQUE_MIN_ANGLE_DEGREES)
+                .min(FONT_STYLE_OBLIQUE_MAX_ANGLE_DEGREES)
+        )
+    }
+
+    /// Parse a suitable angle for font-style: oblique.
+    pub fn parse_angle<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Angle, ParseError<'i>> {
+        let angle = Angle::parse(context, input)?;
+        if angle.was_calc() {
+            return Ok(angle);
+        }
+
+        let degrees = angle.degrees();
+        if degrees < FONT_STYLE_OBLIQUE_MIN_ANGLE_DEGREES ||
+            degrees > FONT_STYLE_OBLIQUE_MAX_ANGLE_DEGREES
+        {
+            return Err(input.new_custom_error(
+                StyleParseErrorKind::UnspecifiedError
+            ));
+        }
+        return Ok(angle)
+    }
+
+    /// The default angle for `font-style: oblique`.
+    pub fn default_angle() -> Angle {
+        Angle::from_degrees(
+            DEFAULT_FONT_STYLE_OBLIQUE_ANGLE_DEGREES,
+            /* was_calc = */ false,
+        )
+    }
+}
+
+impl ToCss for FontStyle {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        match *self {
+            FontStyle::Normal => dest.write_str("normal"),
+            FontStyle::Italic => dest.write_str("italic"),
+            FontStyle::Oblique(ref angle) => {
+                dest.write_str("oblique")?;
+                if *angle != Self::default_angle() {
+                    dest.write_char(' ')?;
+                    angle.to_css(dest)?;
+                }
+                Ok(())
+            }
+            FontStyle::System(ref s) => s.to_css(dest),
+        }
+    }
+}
+
+impl Parse for FontStyle {
+    fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self, ParseError<'i>> {
+        Ok(try_match_ident_ignore_ascii_case! { input,
+            "normal" => FontStyle::Normal,
+            "italic" => FontStyle::Italic,
+            "oblique" => {
+                let angle = input.try(|input| Self::parse_angle(context, input))
+                    .unwrap_or_else(|_| Self::default_angle());
+
+                FontStyle::Oblique(angle)
+            }
+        })
+    }
+}
+
 /// A value for the `font-stretch` property.
 ///
 /// https://drafts.csswg.org/css-fonts-4/#font-stretch-prop

components/style/values/specified/mod.rs

@@ -35,7 +35,7 @@ pub use self::border::{BorderImageRepeat, BorderImageSideWidth};
 pub use self::border::{BorderRadius, BorderSideWidth, BorderSpacing};
 pub use self::column::ColumnCount;
 pub use self::font::{FontSize, FontSizeAdjust, FontStretch, FontSynthesis, FontVariantAlternates, FontWeight};
-pub use self::font::{FontFamily, FontLanguageOverride, FontVariantEastAsian, FontVariationSettings};
+pub use self::font::{FontFamily, FontLanguageOverride, FontStyle, FontVariantEastAsian, FontVariationSettings};
 pub use self::font::{FontFeatureSettings, FontVariantLigatures, FontVariantNumeric};
 pub use self::font::{MozScriptLevel, MozScriptMinSize, MozScriptSizeMultiplier, XLang, XTextZoom};
 pub use self::box_::{AnimationIterationCount, AnimationName, Contain, Display};