servo: Add full support for generic font families (#50)

In order to do this, an interface is exposed so that the embedder can
set a default style for a device.

Signed-off-by: Martin Robinson <[email protected]>
Co-authored-by: Mukilan Thiyagarajan <[email protected]>

Author: mrobinson

style/properties/cascade.rs

@@ -773,21 +773,18 @@ impl<'b> Cascade<'b> {
             self.recompute_font_size_for_zoom_change(&mut context.builder);
         }
 
+        // Compute font-family.
+        let has_font_family = apply!(FontFamily);
+        let has_lang = apply!(XLang);
+
         #[cfg(feature = "gecko")] {
-            // Compute font-family.
-            let has_font_family = apply!(FontFamily);
-            let has_lang = apply!(XLang);
             if has_lang {
                 self.recompute_initial_font_family_if_needed(&mut context.builder);
             }
             if has_font_family {
                 self.prioritize_user_fonts_if_needed(&mut context.builder);
             }
         }
-        #[cfg(feature = "servo")] {
-            apply!(FontFamily);
-            apply!(XLang);
-        }
 
         // Compute font-size.
         #[cfg(feature = "gecko")] {
@@ -809,7 +806,12 @@ impl<'b> Cascade<'b> {
             }
         }
         #[cfg(feature = "servo")]
-        apply!(FontSize);
+        {
+            apply!(FontSize);
+            if has_lang || has_font_family {
+                self.recompute_keyword_font_size_if_needed(context);
+            }
+        }
 
         // Compute the rest of the first-available-font-affecting properties.
         apply!(FontWeight);
@@ -1193,7 +1195,6 @@ impl<'b> Cascade<'b> {
     }
 
     /// Some keyword sizes depend on the font family and language.
-    #[cfg(feature = "gecko")]
     fn recompute_keyword_font_size_if_needed(&self, context: &mut computed::Context) {
         use crate::values::computed::ToComputedValue;
 
@@ -1212,6 +1213,7 @@ impl<'b> Cascade<'b> {
                 },
             };
 
+            #[cfg(feature = "gecko")]
             if font.mScriptUnconstrainedSize == new_size.computed_size {
                 return;
             }

style/properties/properties.mako.rs

@@ -1392,8 +1392,6 @@ pub mod style_structs {
     use fxhash::FxHasher;
     use super::longhands;
     use std::hash::{Hash, Hasher};
-    use crate::media_queries::Device;
-    use crate::values::computed::NonNegativeLength;
 
     % for style_struct in data.active_style_structs():
         % if style_struct.name == "Font":
@@ -1522,34 +1520,24 @@ pub mod style_structs {
                 /// Computes a font hash in order to be able to cache fonts
                 /// effectively in GFX and layout.
                 pub fn compute_font_hash(&mut self) {
-                    // Corresponds to the fields in
-                    // `gfx::font_template::FontTemplateDescriptor`.
                     let mut hasher: FxHasher = Default::default();
                     self.font_weight.hash(&mut hasher);
                     self.font_stretch.hash(&mut hasher);
                     self.font_style.hash(&mut hasher);
                     self.font_family.hash(&mut hasher);
                     self.hash = hasher.finish()
                 }
-
-                /// (Servo does not handle MathML, so this just calls copy_font_size_from)
-                pub fn inherit_font_size_from(&mut self, parent: &Self,
-                                              _: Option<NonNegativeLength>,
-                                              _: &Device) {
-                    self.copy_font_size_from(parent);
-                }
-                /// (Servo does not handle MathML, so this just calls set_font_size)
-                pub fn apply_font_size(&mut self,
-                                       v: longhands::font_size::computed_value::T,
-                                       _: &Self,
-                                       _: &Device) -> Option<NonNegativeLength> {
-                    self.set_font_size(v);
-                    None
-                }
-                /// (Servo does not handle MathML, so this does nothing)
-                pub fn apply_unconstrained_font_size(&mut self, _: NonNegativeLength) {
+                /// Create a new Font with the initial values of all members.
+                pub fn initial_values() -> Self {
+                    Self {
+                        % for longhand in style_struct.longhands:
+                            % if not longhand.logical:
+                                ${longhand.ident}: longhands::${longhand.ident}::get_initial_value(),
+                            % endif
+                        % endfor
+                        hash: 0,
+                    }
                 }
-
             % elif style_struct.name == "Outline":
                 /// Whether the outline-width property is non-zero.
                 #[inline]
@@ -1952,7 +1940,45 @@ impl ComputedValues {
     }
 
     /// Get the initial computed values.
-    pub fn initial_values() -> &'static Self { &*INITIAL_SERVO_VALUES }
+    pub fn initial_values_with_font_override(default_font: super::style_structs::Font) -> Arc<Self> {
+        use crate::logical_geometry::WritingMode;
+        use crate::computed_value_flags::ComputedValueFlags;
+        use servo_arc::Arc;
+        use super::{ComputedValues, ComputedValuesInner, longhands, style_structs};
+
+        Arc::new(ComputedValues {
+            inner: ComputedValuesInner {
+                % for style_struct in data.active_style_structs():
+                    % if style_struct.name == "Font":
+                        font: Arc::new(default_font),
+                    <% continue %>
+                    % endif %
+
+                    ${style_struct.ident}: Arc::new(style_structs::${style_struct.name} {
+                        % for longhand in style_struct.longhands:
+                            % if not longhand.logical:
+                                ${longhand.ident}: longhands::${longhand.ident}::get_initial_value(),
+                            % endif
+                        % endfor
+                        % if style_struct.name == "InheritedText":
+                            text_decorations_in_effect:
+                                crate::values::computed::text::TextDecorationsInEffect::default(),
+                        % endif
+                        % if style_struct.name == "Box":
+                            original_display: longhands::display::get_initial_value(),
+                        % endif
+                    }),
+                % endfor
+                custom_properties: crate::custom_properties::ComputedCustomProperties::default(),
+                writing_mode: WritingMode::empty(),
+                rules: None,
+                visited_style: None,
+                effective_zoom: crate::values::computed::Zoom::ONE,
+                flags: ComputedValueFlags::empty(),
+            },
+            pseudo: None,
+        })
+    }
 
     /// Converts the computed values to an Arc<> from a reference.
     pub fn to_arc(&self) -> Arc<Self> {
@@ -2798,53 +2824,6 @@ impl<'a> StyleBuilder<'a> {
     % endfor
 }
 
-#[cfg(feature = "servo")]
-pub use self::lazy_static_module::INITIAL_SERVO_VALUES;
-
-// Use a module to work around #[cfg] on lazy_static! not being applied to every generated item.
-#[cfg(feature = "servo")]
-#[allow(missing_docs)]
-mod lazy_static_module {
-    use crate::logical_geometry::WritingMode;
-    use crate::computed_value_flags::ComputedValueFlags;
-    use servo_arc::Arc;
-    use super::{ComputedValues, ComputedValuesInner, longhands, style_structs};
-
-    lazy_static! {
-        /// The initial values for all style structs as defined by the specification.
-        pub static ref INITIAL_SERVO_VALUES : Arc<ComputedValues> = Arc::new(ComputedValues {
-            inner: ComputedValuesInner {
-                % for style_struct in data.active_style_structs():
-                    ${style_struct.ident}: Arc::new(style_structs::${style_struct.name} {
-                        % for longhand in style_struct.longhands:
-                            % if not longhand.logical:
-                                ${longhand.ident}: longhands::${longhand.ident}::get_initial_value(),
-                            % endif
-                        % endfor
-                        % if style_struct.name == "InheritedText":
-                            text_decorations_in_effect:
-                                crate::values::computed::text::TextDecorationsInEffect::default(),
-                        % endif
-                        % if style_struct.name == "Font":
-                            hash: 0,
-                        % endif
-                        % if style_struct.name == "Box":
-                            original_display: longhands::display::get_initial_value(),
-                        % endif
-                    }),
-                % endfor
-                custom_properties: crate::custom_properties::ComputedCustomProperties::default(),
-                writing_mode: WritingMode::empty(),
-                rules: None,
-                visited_style: None,
-                effective_zoom: crate::values::computed::Zoom::ONE,
-                flags: ComputedValueFlags::empty(),
-            },
-            pseudo: None,
-        });
-    }
-}
-
 /// A per-longhand function that performs the CSS cascade for that longhand.
 pub type CascadePropertyFn =
     unsafe extern "Rust" fn(

style/servo/media_queries.rs

@@ -14,14 +14,16 @@ use crate::media_queries::MediaType;
 use crate::parser::ParserContext;
 use crate::properties::style_structs::Font;
 use crate::properties::ComputedValues;
-use crate::values::computed::{CSSPixelLength, Context, LineHeight, NonNegativeLength, Resolution};
+use crate::values::computed::{CSSPixelLength, Context, Length, LineHeight, NonNegativeLength, Resolution};
+use crate::values::computed::font::GenericFontFamily;
 use crate::values::specified::font::{FONT_MEDIUM_LINE_HEIGHT_PX, FONT_MEDIUM_PX};
 use crate::values::specified::ViewportVariant;
 use crate::values::KeyframesName;
 use app_units::{Au, AU_PER_PX};
 use euclid::default::Size2D as UntypedSize2D;
 use euclid::{Scale, SideOffsets2D, Size2D};
 use mime::Mime;
+use servo_arc::Arc;
 use std::fmt::Debug;
 use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use style_traits::{CSSPixel, DevicePixel};
@@ -38,6 +40,8 @@ pub trait FontMetricsProvider: Debug + Sync {
         in_media_query: bool,
         retrieve_math_scales: bool,
     ) -> FontMetrics;
+    /// Gets the base size given a generic font family.
+    fn base_size_for_generic(&self, generic: GenericFontFamily) -> Length;
 }
 
 /// A device is a structure that represents the current media a given document
@@ -88,6 +92,9 @@ pub struct Device {
     /// An implementation of a trait which implements support for querying font metrics.
     #[ignore_malloc_size_of = "Owned by embedder"]
     font_metrics_provider: Box<dyn FontMetricsProvider>,
+    /// The default computed values for this Device.
+    #[ignore_malloc_size_of = "Arc is shared"]
+    default_computed_values: Arc<ComputedValues>,
 }
 
 impl Device {
@@ -98,13 +105,13 @@ impl Device {
         viewport_size: Size2D<f32, CSSPixel>,
         device_pixel_ratio: Scale<f32, CSSPixel, DevicePixel>,
         font_metrics_provider: Box<dyn FontMetricsProvider>,
+        default_computed_values: Arc<ComputedValues>,
     ) -> Device {
         Device {
             media_type,
             viewport_size,
             device_pixel_ratio,
             quirks_mode,
-            // FIXME(bz): Seems dubious?
             root_font_size: AtomicU32::new(FONT_MEDIUM_PX.to_bits()),
             root_line_height: AtomicU32::new(FONT_MEDIUM_LINE_HEIGHT_PX.to_bits()),
             used_root_font_size: AtomicBool::new(false),
@@ -113,6 +120,7 @@ impl Device {
             used_viewport_units: AtomicBool::new(false),
             environment: CssEnvironment,
             font_metrics_provider,
+            default_computed_values,
         }
     }
 
@@ -124,10 +132,7 @@ impl Device {
 
     /// Return the default computed values for this device.
     pub fn default_computed_values(&self) -> &ComputedValues {
-        // FIXME(bz): This isn't really right, but it's no more wrong
-        // than what we used to do.  See
-        // https://github.com/servo/servo/issues/14773 for fixing it properly.
-        ComputedValues::initial_values()
+        &self.default_computed_values
     }
 
     /// Get the font size of the root element (for rem)
@@ -183,6 +188,11 @@ impl Device {
         // Servo doesn't implement this quirk (yet)
     }
 
+    /// Gets the base size given a generic font family.
+    pub fn base_size_for_generic(&self, generic: GenericFontFamily) -> Length {
+        self.font_metrics_provider.base_size_for_generic(generic)
+    }
+
     /// Whether a given animation name may be referenced from style.
     pub fn animation_name_may_be_referenced(&self, _: &KeyframesName) -> bool {
         // Assume it is, since we don't have any good way to prove it's not.

style/values/specified/font.rs

@@ -4,7 +4,6 @@
 
 //! Specified values for font properties
 
-#[cfg(feature = "gecko")]
 use crate::context::QuirksMode;
 use crate::parser::{Parse, ParserContext};
 use crate::values::computed::font::{FamilyName, FontFamilyList, SingleFontFamily};
@@ -775,50 +774,41 @@ pub const FONT_MEDIUM_PX: f32 = 16.0;
 pub const FONT_MEDIUM_LINE_HEIGHT_PX: f32 = FONT_MEDIUM_PX * 1.2;
 
 impl FontSizeKeyword {
-    #[inline]
-    #[cfg(feature = "servo")]
-    fn to_length(&self, _: &Context) -> NonNegativeLength {
-        let medium = Length::new(FONT_MEDIUM_PX);
-        // https://drafts.csswg.org/css-fonts-3/#font-size-prop
-        NonNegative(match *self {
-            FontSizeKeyword::XXSmall => medium * 3.0 / 5.0,
-            FontSizeKeyword::XSmall => medium * 3.0 / 4.0,
-            FontSizeKeyword::Small => medium * 8.0 / 9.0,
-            FontSizeKeyword::Medium => medium,
-            FontSizeKeyword::Large => medium * 6.0 / 5.0,
-            FontSizeKeyword::XLarge => medium * 3.0 / 2.0,
-            FontSizeKeyword::XXLarge => medium * 2.0,
-            FontSizeKeyword::XXXLarge => medium * 3.0,
-            #[cfg(feature="gecko")]
-            FontSizeKeyword::Math => unreachable!(),
-            FontSizeKeyword::None => unreachable!(),
-        })
-    }
-
-    #[cfg(feature = "gecko")]
     #[inline]
     fn to_length(&self, cx: &Context) -> NonNegativeLength {
         let font = cx.style().get_font();
+
+        #[cfg(feature = "servo")]
+        let family = &font.font_family.families;
+
+        #[cfg(feature = "gecko")]
         let family = &font.mFont.family.families;
+
         let generic = family
             .single_generic()
             .unwrap_or(computed::GenericFontFamily::None);
+
+        #[cfg(feature = "gecko")]
         let base_size = unsafe {
             Atom::with(font.mLanguage.mRawPtr, |language| {
                 cx.device().base_size_for_generic(language, generic)
             })
         };
+
+        #[cfg(feature = "servo")]
+        let base_size = cx.device().base_size_for_generic(generic);
+
         self.to_length_without_context(cx.quirks_mode, base_size)
     }
 
     /// Resolve a keyword length without any context, with explicit arguments.
-    #[cfg(feature = "gecko")]
     #[inline]
     pub fn to_length_without_context(
         &self,
         quirks_mode: QuirksMode,
         base_size: Length,
     ) -> NonNegativeLength {
+        #[cfg(feature = "gecko")]
         debug_assert_ne!(*self, FontSizeKeyword::Math);
         // The tables in this function are originally from
         // nsRuleNode::CalcFontPointSize in Gecko:

style_static_prefs/src/lib.rs

@@ -15,6 +15,9 @@ macro_rules! pref {
     ("layout.css.stylo-local-work-queue.in-worker") => {
         0
     };
+    ("layout.css.system-ui.enabled") => {
+        true
+    };
     ($string:literal) => {
         false
     };