style: Use a single system font definition rather than two

Follow the pattern we use for system colors.

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

components/style/properties/helpers.mako.rs

@@ -554,7 +554,7 @@
         keyword = keyword=Keyword(name, values, **keyword_kwargs)
     %>
     <%call expr="longhand(name, keyword=Keyword(name, values, **keyword_kwargs), **kwargs)">
-        use crate::properties::longhands::system_font::SystemFont;
+        use crate::values::specified::font::SystemFont;
 
         pub mod computed_value {
             #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]

components/style/properties/longhands/font.mako.rs

@@ -309,19 +309,13 @@ ${helpers.predefined_type(
     //! variable reference. We may want to improve this behavior at some
     //! point. See also https://github.com/w3c/csswg-drafts/issues/1586.
 
-        use cssparser::{Parser, ToCss};
     use crate::values::computed::font::GenericFontFamily;
     use crate::properties::longhands;
-        use std::fmt;
     use std::hash::{Hash, Hasher};
-        use style_traits::ParseError;
     use crate::values::computed::{ToComputedValue, Context};
+    use crate::values::specified::font::SystemFont;
 
     <%
-            system_fonts = """caption icon menu message-box small-caption status-bar
-                              -moz-window -moz-document -moz-workspace -moz-desktop
-                              -moz-info -moz-dialog -moz-button -moz-pull-down-menu
-                              -moz-list -moz-field""".split()
         kw_font_props = """font_variant_caps
                            font_kerning font_variant_position font_variant_ligatures
                            font_variant_east_asian font_variant_numeric
@@ -329,13 +323,6 @@ ${helpers.predefined_type(
         kw_cast = """font_variant_caps font_kerning font_variant_position
                      font_optical_sizing""".split()
     %>
-        #[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq,
-                 SpecifiedValueInfo, ToCss, ToShmem)]
-        pub enum SystemFont {
-            % for font in system_fonts:
-                ${to_camel_case(font)},
-            % endfor
-        }
 
     // ComputedValues are compared at times
     // so we need these impls. We don't want to
@@ -360,26 +347,18 @@ ${helpers.predefined_type(
 
         fn to_computed_value(&self, cx: &Context) -> Self::ComputedValue {
             use crate::gecko_bindings::bindings;
-                use crate::gecko_bindings::structs::{LookAndFeel_FontID, nsFont};
+            use crate::gecko_bindings::structs::nsFont;
             use std::mem;
             use crate::values::computed::Percentage;
             use crate::values::specified::font::KeywordInfo;
             use crate::values::computed::font::{FontFamily, FontSize, FontStretch, FontStyle, FontFamilyList};
             use crate::values::generics::NonNegative;
 
-                let id = match *self {
-                    % for font in system_fonts:
-                        SystemFont::${to_camel_case(font)} => {
-                            LookAndFeel_FontID::${to_camel_case(font.replace("-moz-", ""))}
-                        }
-                    % endfor
-                };
-
             let mut system = mem::MaybeUninit::<nsFont>::uninit();
             let system = unsafe {
                 bindings::Gecko_nsFont_InitSystem(
                     system.as_mut_ptr(),
-                        id as i32,
+                    *self,
                     cx.style().get_font().gecko(),
                     cx.device().document()
                 );
@@ -455,40 +434,6 @@ ${helpers.predefined_type(
         pub default_font_type: GenericFontFamily,
     }
 
-        impl SystemFont {
-            pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
-                try_match_ident_ignore_ascii_case! { input,
-                    % for font in system_fonts:
-                        "${font}" => Ok(SystemFont::${to_camel_case(font)}),
-                    % endfor
-                }
-            }
-        }
-
-        impl ToCss for SystemFont {
-            fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-                // We may want to do something better in the future, see
-                // w3c/csswg-drafts#1586.
-                dest.write_str("-moz-use-system-font")
-            }
-        }
-    }
-% else:
-    pub mod system_font {
-        use cssparser::Parser;
-
-        // We don't parse system fonts, but in the interest of not littering
-        // a lot of code with `if engine == "gecko"` conditionals, we have a
-        // dummy system font module that does nothing
-
-        #[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss, ToShmem)]
-        /// void enum for system font, can never exist
-        pub enum SystemFont {}
-        impl SystemFont {
-            pub fn parse(_: &mut Parser) -> Result<Self, ()> {
-                Err(())
-            }
-        }
 }
 % endif
 

components/style/properties/properties.mako.rs

@@ -32,7 +32,6 @@ use crate::computed_value_flags::*;
 use crate::hash::FxHashMap;
 use crate::media_queries::Device;
 use crate::parser::ParserContext;
-use crate::properties::longhands::system_font::SystemFont;
 use crate::selector_parser::PseudoElement;
 #[cfg(feature = "servo")] use servo_config::prefs;
 use style_traits::{CssWriter, KeywordsCollectFn, ParseError, ParsingMode};
@@ -44,6 +43,7 @@ use crate::values::generics::text::LineHeight;
 use crate::values::{computed, resolved};
 use crate::values::computed::NonNegativeLength;
 use crate::values::serialize_atom_name;
+use crate::values::specified::font::SystemFont;
 use crate::rule_tree::StrongRuleNode;
 use crate::Zero;
 use crate::str::{CssString, CssStringWriter};

components/style/properties/shorthands/font.mako.rs

@@ -34,11 +34,11 @@
     use crate::parser::Parse;
     use crate::properties::longhands::{font_family, font_style, font_weight, font_stretch};
     use crate::properties::longhands::font_variant_caps;
-    #[cfg(feature = "gecko")]
-    use crate::properties::longhands::system_font::SystemFont;
     use crate::values::specified::text::LineHeight;
     use crate::values::specified::FontSize;
     use crate::values::specified::font::{FontStretch, FontStretchKeyword};
+    #[cfg(feature = "gecko")]
+    use crate::values::specified::font::SystemFont;
 
     <%
         gecko_sub_properties = "kerning language_override size_adjust \
@@ -289,7 +289,7 @@
             % for p in subprops_for_value_info:
             ${p}::collect_completion_keywords(f);
             % endfor
-            <longhands::system_font::SystemFont as SpecifiedValueInfo>::collect_completion_keywords(f);
+            <SystemFont as SpecifiedValueInfo>::collect_completion_keywords(f);
         }
     }
 </%helpers:shorthand>

components/style/values/specified/font.rs

@@ -9,7 +9,6 @@ use crate::context::QuirksMode;
 #[cfg(feature = "gecko")]
 use crate::gecko_bindings::bindings;
 use crate::parser::{Parse, ParserContext};
-use crate::properties::longhands::system_font::SystemFont;
 use crate::values::computed::font::{FamilyName, FontFamilyList, FontStyleAngle, SingleFontFamily};
 use crate::values::computed::{font as computed, Length, NonNegativeLength};
 use crate::values::computed::{Angle as ComputedAngle, Percentage as ComputedPercentage};
@@ -65,6 +64,33 @@ macro_rules! system_font_methods {
     };
 }
 
+/// System fonts.
+#[repr(u8)]
+#[derive(
+    Clone, Copy, Debug, Eq, Hash, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToCss, ToShmem
+)]
+#[allow(missing_docs)]
+pub enum SystemFont {
+    Caption,
+    Icon,
+    Menu,
+    MessageBox,
+    SmallCaption,
+    StatusBar,
+    MozWindow,
+    MozDocument,
+    MozWorkspace,
+    MozDesktop,
+    MozInfo,
+    MozDialog,
+    MozButton,
+    MozPullDownMenu,
+    MozList,
+    MozField,
+    #[css(skip)]
+    End, // Just for indexing purposes.
+}
+
 const DEFAULT_SCRIPT_MIN_SIZE_PT: u32 = 8;
 const DEFAULT_SCRIPT_SIZE_MULTIPLIER: f64 = 0.71;