Bug 1740584 - Implement relative root font lengths rcap, rch, rex, ric. r=emilio,firefox-style-system-reviewers,layout-reviewers

Differential Revision: https://phabricator.services.mozilla.com/D274527

Author: kbhomes

layout/base/nsPresContext.cpp

@@ -2149,8 +2149,10 @@ void nsPresContext::UserFontSetUpdated(gfxUserFontEntry* aUpdatedFont) {
   // TODO(emilio): We could be more granular if we knew which families have
   // potentially changed.
   if (!aUpdatedFont) {
-    auto hint = StyleSet()->UsesFontMetrics() ? RestyleHint::RecascadeSubtree()
-                                              : RestyleHint{0};
+    auto hint =
+        (StyleSet()->UsesFontMetrics() || StyleSet()->UsesRootFontMetrics())
+            ? RestyleHint::RecascadeSubtree()
+            : RestyleHint{0};
     PostRebuildAllStyleDataEvent(NS_STYLE_HINT_REFLOW, hint);
     return;
   }

layout/style/ServoStyleSet.cpp

@@ -1186,6 +1186,10 @@ bool ServoStyleSet::UsesFontMetrics() const {
   return Servo_StyleSet_UsesFontMetrics(mRawData.get());
 }
 
+bool ServoStyleSet::UsesRootFontMetrics() const {
+  return Servo_StyleSet_UsesRootFontMetrics(mRawData.get());
+}
+
 bool ServoStyleSet::EnsureUniqueInnerOnCSSSheets() {
   using SheetOwner = Variant<ServoStyleSet*, ShadowRoot*>;
 

layout/style/ServoStyleSet.h

@@ -166,6 +166,8 @@ class ServoStyleSet {
 
   bool UsesFontMetrics() const;
 
+  bool UsesRootFontMetrics() const;
+
   void SetAuthorStyleDisabled(bool aStyleDisabled);
 
   // Get a CopmutedStyle for a text node (which no rules will match).

layout/style/nsFontFaceUtils.cpp

@@ -172,6 +172,7 @@ void nsFontFaceUtils::MarkDirtyForFontChange(nsIFrame* aSubtreeRoot,
   PresShell* presShell = pc->PresShell();
 
   const bool usesMetricsFromStyle = pc->StyleSet()->UsesFontMetrics();
+  const bool usesRootMetricsFromStyle = pc->StyleSet()->UsesRootFontMetrics();
 
   // StyleSingleFontFamily::IsNamedFamily expects a UTF-16 string. Convert it
   // once here rather than on each call.
@@ -201,7 +202,18 @@ void nsFontFaceUtils::MarkDirtyForFontChange(nsIFrame* aSubtreeRoot,
           ScheduleReflow(presShell, f);
           alreadyScheduled = ReflowAlreadyScheduled::Yes;
         }
-        if (kind & FontUsageKind::FontMetrics) {
+
+        // If the updated font is used for font metrics, then styles need to be
+        // recomputed. This can occur if the current frame directly uses the
+        // font's metrics (ex/ch/...). However, if there are any elements in the
+        // document using root element relative font metrics (rex/rch/...) and
+        // the root element itself used the updated font, then the entire
+        // subtree needs to be restyled.
+        const bool shouldRestyleForFontMetrics =
+            (kind & FontUsageKind::FontMetrics) ||
+            (usesRootMetricsFromStyle && f->Style()->IsRootElementStyle());
+
+        if (shouldRestyleForFontMetrics) {
           MOZ_ASSERT(f->GetContent() && f->GetContent()->IsElement(),
                      "How could we target a non-element with selectors?");
           f->PresContext()->RestyleManager()->PostRestyleEvent(

servo/components/style/custom_properties.rs

@@ -415,7 +415,12 @@ impl NonCustomReferences {
         if value.eq_ignore_ascii_case(FontRelativeLength::RLH) {
             return Self::ROOT_FONT_UNITS | Self::ROOT_LH_UNITS;
         }
-        if value.eq_ignore_ascii_case(FontRelativeLength::REM) {
+        if value.eq_ignore_ascii_case(FontRelativeLength::REM)
+            || value.eq_ignore_ascii_case(FontRelativeLength::REX)
+            || value.eq_ignore_ascii_case(FontRelativeLength::RCH)
+            || value.eq_ignore_ascii_case(FontRelativeLength::RCAP)
+            || value.eq_ignore_ascii_case(FontRelativeLength::RIC)
+        {
             return Self::ROOT_FONT_UNITS;
         }
         Self::empty()

servo/components/style/font_metrics.rs

@@ -6,7 +6,7 @@
 
 #![deny(missing_docs)]
 
-use crate::values::computed::Length;
+use crate::values::computed::{FontSize, Length};
 
 /// Represents the font metrics that style needs from a font to compute the
 /// value of certain CSS units like `ex`.
@@ -44,6 +44,74 @@ impl Default for FontMetrics {
     }
 }
 
+impl FontMetrics {
+    /// Returns the x-height, computing a fallback value if not present
+    pub fn x_height_or_default(&self, reference_font_size: &FontSize) -> Length {
+        // https://drafts.csswg.org/css-values/#ex
+        //
+        //     In the cases where it is impossible or impractical to
+        //     determine the x-height, a value of 0.5em must be
+        //     assumed.
+        //
+        // (But note we use 0.5em of the used, not computed
+        // font-size)
+        self.x_height
+            .unwrap_or_else(|| reference_font_size.used_size() * 0.5)
+    }
+
+    /// Returns the zero advance measure, computing a fallback value if not present
+    pub fn zero_advance_measure_or_default(
+        &self,
+        reference_font_size: &FontSize,
+        upright: bool,
+    ) -> Length {
+        // https://drafts.csswg.org/css-values/#ch
+        //
+        //     In the cases where it is impossible or impractical to
+        //     determine the measure of the “0” glyph, it must be
+        //     assumed to be 0.5em wide by 1em tall. Thus, the ch
+        //     unit falls back to 0.5em in the general case, and to
+        //     1em when it would be typeset upright (i.e.
+        //     writing-mode is vertical-rl or vertical-lr and
+        //     text-orientation is upright).
+        //
+        // Same caveat about computed vs. used font-size applies
+        // above.
+        self.zero_advance_measure.unwrap_or_else(|| {
+            if upright {
+                reference_font_size.used_size()
+            } else {
+                reference_font_size.used_size() * 0.5
+            }
+        })
+    }
+
+    /// Returns the cap-height, computing a fallback value if not present
+    pub fn cap_height_or_default(&self) -> Length {
+        // https://drafts.csswg.org/css-values/#cap
+        //
+        //     In the cases where it is impossible or impractical to
+        //     determine the cap-height, the font’s ascent must be
+        //     used.
+        //
+        self.cap_height.unwrap_or_else(|| self.ascent)
+    }
+
+    /// Returns the ideographic advance measure, computing a fallback value if not present
+    pub fn ic_width_or_default(&self, reference_font_size: &FontSize) -> Length {
+        // https://drafts.csswg.org/css-values/#ic
+        //
+        //     In the cases where it is impossible or impractical to
+        //     determine the ideographic advance measure, it must be
+        //     assumed to be 1em.
+        //
+        // Same caveat about computed vs. used as for other
+        // metric-dependent units.
+        self.ic_width
+            .unwrap_or_else(|| reference_font_size.used_size())
+    }
+}
+
 /// Type of font metrics to retrieve.
 #[derive(Clone, Debug, PartialEq)]
 pub enum FontMetricsOrientation {

servo/components/style/gecko/media_queries.rs

@@ -19,7 +19,8 @@ use crate::values::computed::font::GenericFontFamily;
 use crate::values::computed::{ColorScheme, Length, NonNegativeLength};
 use crate::values::specified::color::{ColorSchemeFlags, ForcedColors, SystemColor};
 use crate::values::specified::font::{
-    QueryFontMetricsFlags, FONT_MEDIUM_LINE_HEIGHT_PX, FONT_MEDIUM_PX,
+    QueryFontMetricsFlags, FONT_MEDIUM_CAP_PX, FONT_MEDIUM_CH_PX, FONT_MEDIUM_EX_PX,
+    FONT_MEDIUM_IC_PX, FONT_MEDIUM_LINE_HEIGHT_PX, FONT_MEDIUM_PX,
 };
 use crate::values::specified::ViewportVariant;
 use crate::values::{CustomIdent, KeyframesName};
@@ -50,6 +51,14 @@ pub struct Device {
     root_font_size: AtomicU32,
     /// Line height of the root element, used for rlh units in other elements.
     root_line_height: AtomicU32,
+    /// X-height of the root element, used for rex units in other elements.
+    root_font_metrics_ex: AtomicU32,
+    /// Cap-height of the root element, used for rcap units in other elements.
+    root_font_metrics_cap: AtomicU32,
+    /// Advance measure (ch) of the root element, used for rch units in other elements.
+    root_font_metrics_ch: AtomicU32,
+    /// Ideographic advance measure of the root element, used for ric units in other elements.
+    root_font_metrics_ic: AtomicU32,
     /// The body text color, stored as an `nscolor`, used for the "tables
     /// inherit from body" quirk.
     ///
@@ -61,6 +70,9 @@ pub struct Device {
     /// Whether any styles computed in the document relied on the root line-height
     /// by using rlh units.
     used_root_line_height: AtomicBool,
+    /// Whether any styles computed in the document relied on the root font metrics
+    /// by using rcap, rch, rex, or ric units.
+    used_root_font_metrics: AtomicBool,
     /// Whether any styles computed in the document relied on font metrics.
     used_font_metrics: AtomicBool,
     /// Whether any styles computed in the document relied on the viewport size
@@ -103,11 +115,17 @@ impl Device {
             default_values: ComputedValues::default_values(doc),
             root_font_size: AtomicU32::new(FONT_MEDIUM_PX.to_bits()),
             root_line_height: AtomicU32::new(FONT_MEDIUM_LINE_HEIGHT_PX.to_bits()),
+            root_font_metrics_ex: AtomicU32::new(FONT_MEDIUM_EX_PX.to_bits()),
+            root_font_metrics_cap: AtomicU32::new(FONT_MEDIUM_CAP_PX.to_bits()),
+            root_font_metrics_ch: AtomicU32::new(FONT_MEDIUM_CH_PX.to_bits()),
+            root_font_metrics_ic: AtomicU32::new(FONT_MEDIUM_IC_PX.to_bits()),
+
             // This gets updated when we see the <body>, so it doesn't really
             // matter which color-scheme we look at here.
             body_text_color: AtomicUsize::new(prefs.mLightColors.mDefault as usize),
             used_root_font_size: AtomicBool::new(false),
             used_root_line_height: AtomicBool::new(false),
+            used_root_font_metrics: AtomicBool::new(false),
             used_font_metrics: AtomicBool::new(false),
             used_viewport_size: AtomicBool::new(false),
             used_dynamic_viewport_size: AtomicBool::new(false),
@@ -193,6 +211,66 @@ impl Device {
             .store(size.to_bits(), Ordering::Relaxed);
     }
 
+    /// Get the x-height of the root element (for rex)
+    pub fn root_font_metrics_ex(&self) -> Length {
+        self.used_root_font_metrics.store(true, Ordering::Relaxed);
+        Length::new(f32::from_bits(
+            self.root_font_metrics_ex.load(Ordering::Relaxed),
+        ))
+    }
+
+    /// Set the x-height of the root element (for rex), in zoom-independent CSS pixels.
+    pub fn set_root_font_metrics_ex(&self, size: f32) -> bool {
+        let size = size.to_bits();
+        let previous = self.root_font_metrics_ex.swap(size, Ordering::Relaxed);
+        previous != size
+    }
+
+    /// Get the cap-height of the root element (for rcap)
+    pub fn root_font_metrics_cap(&self) -> Length {
+        self.used_root_font_metrics.store(true, Ordering::Relaxed);
+        Length::new(f32::from_bits(
+            self.root_font_metrics_cap.load(Ordering::Relaxed),
+        ))
+    }
+
+    /// Set the cap-height of the root element (for rcap), in zoom-independent CSS pixels.
+    pub fn set_root_font_metrics_cap(&self, size: f32) -> bool {
+        let size = size.to_bits();
+        let previous = self.root_font_metrics_cap.swap(size, Ordering::Relaxed);
+        previous != size
+    }
+
+    /// Get the advance measure of the root element (for rch)
+    pub fn root_font_metrics_ch(&self) -> Length {
+        self.used_root_font_metrics.store(true, Ordering::Relaxed);
+        Length::new(f32::from_bits(
+            self.root_font_metrics_ch.load(Ordering::Relaxed),
+        ))
+    }
+
+    /// Set the advance measure of the root element (for rch), in zoom-independent CSS pixels.
+    pub fn set_root_font_metrics_ch(&self, size: f32) -> bool {
+        let size = size.to_bits();
+        let previous = self.root_font_metrics_ch.swap(size, Ordering::Relaxed);
+        previous != size
+    }
+
+    /// Get the ideographic advance measure of the root element (for ric)
+    pub fn root_font_metrics_ic(&self) -> Length {
+        self.used_root_font_metrics.store(true, Ordering::Relaxed);
+        Length::new(f32::from_bits(
+            self.root_font_metrics_ic.load(Ordering::Relaxed),
+        ))
+    }
+
+    /// Set the ideographic advance measure of the root element (for ric), in zoom-independent CSS pixels.
+    pub fn set_root_font_metrics_ic(&self, size: f32) -> bool {
+        let size = size.to_bits();
+        let previous = self.root_font_metrics_ic.swap(size, Ordering::Relaxed);
+        previous != size
+    }
+
     /// The quirks mode of the document.
     pub fn quirks_mode(&self) -> QuirksMode {
         self.document().mCompatMode.into()
@@ -230,8 +308,11 @@ impl Device {
         font: &crate::properties::style_structs::Font,
         base_size: Length,
         flags: QueryFontMetricsFlags,
+        track_usage: bool,
     ) -> FontMetrics {
-        self.used_font_metrics.store(true, Ordering::Relaxed);
+        if track_usage {
+            self.used_font_metrics.store(true, Ordering::Relaxed);
+        }
         let pc = match self.pres_context() {
             Some(pc) => pc,
             None => return Default::default(),
@@ -309,6 +390,7 @@ impl Device {
         self.reset_computed_values();
         self.used_root_font_size.store(false, Ordering::Relaxed);
         self.used_root_line_height.store(false, Ordering::Relaxed);
+        self.used_root_font_metrics.store(false, Ordering::Relaxed);
         self.used_font_metrics.store(false, Ordering::Relaxed);
         self.used_viewport_size.store(false, Ordering::Relaxed);
         self.used_dynamic_viewport_size
@@ -325,6 +407,11 @@ impl Device {
         self.used_root_line_height.load(Ordering::Relaxed)
     }
 
+    /// Returns whether we ever looked up the root font metrics of the device.
+    pub fn used_root_font_metrics(&self) -> bool {
+        self.used_root_font_metrics.load(Ordering::Relaxed)
+    }
+
     /// Recreates all the temporary state that the `Device` stores.
     ///
     /// This includes the viewport override from `@viewport` rules, and also the