diff --git a/components/style/font_metrics.rs b/components/style/font_metrics.rs index 15b5fd453e8..ab2468e5439 100644 --- a/components/style/font_metrics.rs +++ b/components/style/font_metrics.rs @@ -43,7 +43,7 @@ pub trait FontMetricsProvider { } /// Get default size of a given language and generic family. - fn get_size(&self, font_name: &Atom, font_family: u8) -> Au; + fn get_size(&self, font_name: &Atom, font_family: crate::values::computed::font::GenericFontFamily) -> Au; /// Construct from a shared style context fn create_from(context: &SharedStyleContext) -> Self diff --git a/components/style/gecko/wrapper.rs b/components/style/gecko/wrapper.rs index 46eaa427b3a..a3c1ebeec0b 100644 --- a/components/style/gecko/wrapper.rs +++ b/components/style/gecko/wrapper.rs @@ -69,6 +69,7 @@ use crate::selector_parser::{AttrValue, HorizontalDirection, Lang}; use crate::shared_lock::Locked; use crate::string_cache::{Atom, Namespace, WeakAtom, WeakNamespace}; use crate::stylist::CascadeData; +use crate::values::computed::font::GenericFontFamily; use crate::values::specified::length::FontBaseSize; use crate::CaseSensitivityExt; use app_units::Au; @@ -1041,7 +1042,7 @@ impl FontMetricsProvider for GeckoFontMetricsProvider { GeckoFontMetricsProvider::new() } - fn get_size(&self, font_name: &Atom, font_family: u8) -> Au { + fn get_size(&self, font_name: &Atom, font_family: GenericFontFamily) -> Au { let mut cache = self.font_size_cache.borrow_mut(); if let Some(sizes) = cache.iter().find(|el| el.0 == *font_name) { return sizes.1.size_for_generic(font_family); @@ -1100,16 +1101,17 @@ impl FontMetricsProvider for GeckoFontMetricsProvider { } impl structs::FontSizePrefs { - fn size_for_generic(&self, font_family: u8) -> Au { + fn size_for_generic(&self, font_family: GenericFontFamily) -> Au { Au(match font_family { - structs::kPresContext_DefaultVariableFont_ID => self.mDefaultVariableSize, - structs::kPresContext_DefaultFixedFont_ID => self.mDefaultFixedSize, - structs::kGenericFont_serif => self.mDefaultSerifSize, - structs::kGenericFont_sans_serif => self.mDefaultSansSerifSize, - structs::kGenericFont_monospace => self.mDefaultMonospaceSize, - structs::kGenericFont_cursive => self.mDefaultCursiveSize, - structs::kGenericFont_fantasy => self.mDefaultFantasySize, - _ => unreachable!("Unknown generic ID"), + GenericFontFamily::None => self.mDefaultVariableSize, + GenericFontFamily::Serif => self.mDefaultSerifSize, + GenericFontFamily::SansSerif => self.mDefaultSansSerifSize, + GenericFontFamily::Monospace => self.mDefaultMonospaceSize, + GenericFontFamily::Cursive => self.mDefaultCursiveSize, + GenericFontFamily::Fantasy => self.mDefaultFantasySize, + GenericFontFamily::MozEmoji => { + unreachable!("Should never get here, since this doesn't (yet) appear on font family") + }, }) } } diff --git a/components/style/properties/cascade.rs b/components/style/properties/cascade.rs index 7d4c8c6275c..1b76aefdd74 100644 --- a/components/style/properties/cascade.rs +++ b/components/style/properties/cascade.rs @@ -683,6 +683,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> { #[cfg(feature = "gecko")] fn recompute_default_font_family_type_if_needed(&mut self) { use crate::gecko_bindings::{bindings, structs}; + use crate::values::computed::font::GenericFontFamily; if !self.seen.contains(LonghandId::XLang) && !self.seen.contains(LonghandId::FontFamily) { @@ -697,7 +698,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> { // System fonts are all right, and should have the default font type // set to none already, so bail out early. if font.mFont.systemFont { - debug_assert_eq!(font.mFont.fontlist.mDefaultFontType, structs::FontFamilyType::eFamily_none); + debug_assert_eq!(font.mFont.fontlist.mDefaultFontType, GenericFontFamily::None); return; } @@ -717,11 +718,11 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> { !use_document_fonts && matches!( font.mGenericID, - structs::kGenericFont_NONE | - structs::kGenericFont_fantasy | - structs::kGenericFont_cursive + GenericFontFamily::None | + GenericFontFamily::Fantasy | + GenericFontFamily::Cursive ) && - default_font_type != structs::FontFamilyType::eFamily_none; + default_font_type != GenericFontFamily::None; if !prioritize_user_fonts && default_font_type == font.mFont.fontlist.mDefaultFontType { // Nothing to do. diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs index 17f10cd4552..3bb8264bf09 100644 --- a/components/style/properties/gecko.mako.rs +++ b/components/style/properties/gecko.mako.rs @@ -1984,20 +1984,20 @@ fn static_assert() { <% impl_font_settings("font_variation_settings", "gfxFontVariation", "VariationValue", "f32", "f32") %> pub fn set_font_family(&mut self, v: longhands::font_family::computed_value::T) { - use crate::gecko_bindings::structs::FontFamilyType; + use crate::values::computed::font::GenericFontFamily; let is_system_font = v.is_system_font; self.gecko.mFont.systemFont = is_system_font; self.gecko.mGenericID = if is_system_font { - structs::kGenericFont_NONE + GenericFontFamily::None } else { - v.families.single_generic().unwrap_or(structs::kGenericFont_NONE) + v.families.single_generic().unwrap_or(GenericFontFamily::None) }; self.gecko.mFont.fontlist.mFontlist.mBasePtr.set_move( v.families.shared_font_list().clone() ); // Fixed-up if needed in Cascade::fixup_font_stuff. - self.gecko.mFont.fontlist.mDefaultFontType = FontFamilyType::eFamily_none; + self.gecko.mFont.fontlist.mDefaultFontType = GenericFontFamily::None; } pub fn copy_font_family_from(&mut self, other: &Self) { @@ -2011,33 +2011,13 @@ fn static_assert() { } pub fn clone_font_family(&self) -> longhands::font_family::computed_value::T { - use crate::gecko_bindings::structs::FontFamilyType; use crate::values::computed::font::{FontFamily, SingleFontFamily, FontFamilyList}; let fontlist = &self.gecko.mFont.fontlist; let shared_fontlist = unsafe { fontlist.mFontlist.mBasePtr.to_safe() }; let families = if shared_fontlist.mNames.is_empty() { - let default = fontlist.mDefaultFontType; - let default = match default { - FontFamilyType::eFamily_serif => { - SingleFontFamily::Generic(atom!("serif")) - } - _ => { - // This can break with some combinations of user prefs, see - // bug 1442195 for example. It doesn't really matter in this - // case... - // - // FIXME(emilio): Probably should be storing the whole - // default font name instead though. - debug_assert_eq!( - default, - FontFamilyType::eFamily_sans_serif, - "Default generic should be serif or sans-serif" - ); - SingleFontFamily::Generic(atom!("sans-serif")) - } - }; + let default = SingleFontFamily::Generic(fontlist.mDefaultFontType); FontFamilyList::new(Box::new([default])) } else { FontFamilyList::SharedFontList(shared_fontlist) diff --git a/components/style/properties/longhands/font.mako.rs b/components/style/properties/longhands/font.mako.rs index a2eb9c3dcff..b253fde0b8d 100644 --- a/components/style/properties/longhands/font.mako.rs +++ b/components/style/properties/longhands/font.mako.rs @@ -326,7 +326,7 @@ ${helpers.predefined_type( use app_units::Au; use cssparser::{Parser, ToCss}; - use crate::gecko_bindings::structs::FontFamilyType; + use crate::values::computed::font::GenericFontFamily; use crate::properties::longhands; use std::fmt; use std::hash::{Hash, Hasher}; @@ -466,7 +466,7 @@ ${helpers.predefined_type( pub ${name}: longhands::${name}::computed_value::T, % endfor pub system_font: SystemFont, - pub default_font_type: FontFamilyType, + pub default_font_type: GenericFontFamily, } impl SystemFont { diff --git a/components/style/values/computed/font.rs b/components/style/values/computed/font.rs index 6bd8cae445b..c1d2f1b7425 100644 --- a/components/style/values/computed/font.rs +++ b/components/style/values/computed/font.rs @@ -157,10 +157,6 @@ impl FontSize { } } -/// XXXManishearth it might be better to -/// animate this as computed, however this complicates -/// clamping and might not be the right thing to do. -/// We should figure it out. impl ToAnimatedValue for FontSize { type AnimatedValue = NonNegativeLength; @@ -178,8 +174,8 @@ impl ToAnimatedValue for FontSize { } } -#[derive(Clone, Debug, Eq, Hash, PartialEq)] -#[cfg_attr(feature = "servo", derive(MallocSizeOf))] +#[derive(Clone, Debug, Eq, PartialEq)] +#[cfg_attr(feature = "servo", derive(Hash, MallocSizeOf))] /// Specifies a prioritized list of font family names or generic family names. pub struct FontFamily { /// The actual list of family names. @@ -193,7 +189,7 @@ impl FontFamily { /// Get default font family as `serif` which is a generic font-family pub fn serif() -> Self { FontFamily { - families: FontFamilyList::new(Box::new([SingleFontFamily::Generic(atom!("serif"))])), + families: FontFamilyList::new(Box::new([SingleFontFamily::Generic(GenericFontFamily::Serif)])), is_system_font: false, } } @@ -232,7 +228,7 @@ pub struct FamilyName { /// Name of the font family pub name: Atom, /// Syntax of the font family - pub syntax: FamilyNameSyntax, + pub syntax: FontFamilyNameSyntax, } impl ToCss for FamilyName { @@ -241,12 +237,12 @@ impl ToCss for FamilyName { W: fmt::Write, { match self.syntax { - FamilyNameSyntax::Quoted => { + FontFamilyNameSyntax::Quoted => { dest.write_char('"')?; write!(CssStringWriter::new(dest), "{}", self.name)?; dest.write_char('"') }, - FamilyNameSyntax::Identifiers => { + FontFamilyNameSyntax::Identifiers => { let mut first = true; for ident in self.name.to_string().split(' ') { if first { @@ -268,11 +264,12 @@ impl ToCss for FamilyName { } } -#[derive(Clone, Debug, Eq, Hash, MallocSizeOf, PartialEq, ToShmem)] +#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq, ToShmem)] #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))] /// Font family names must either be given quoted as strings, /// or unquoted as a sequence of one or more identifiers. -pub enum FamilyNameSyntax { +#[repr(u8)] +pub enum FontFamilyNameSyntax { /// The family name was specified in a quoted form, e.g. "Font Name" /// or 'Font Name'. Quoted, @@ -282,85 +279,79 @@ pub enum FamilyNameSyntax { Identifiers, } -#[derive(Clone, Debug, Eq, Hash, MallocSizeOf, PartialEq)] -#[cfg_attr(feature = "servo", derive(Deserialize, Serialize))] +#[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToCss)] +#[cfg_attr(feature = "servo", derive(Deserialize, Serialize, Hash))] /// A set of faces that vary in weight, width or slope. pub enum SingleFontFamily { /// The name of a font family of choice. FamilyName(FamilyName), /// Generic family name. - Generic(Atom), + Generic(GenericFontFamily), +} + +/// A generic font-family name. +/// +/// The order here is important, if you change it make sure that +/// `gfxPlatformFontList.h`s ranged array and `gfxFontFamilyList`'s +/// sSingleGenerics are updated as well. +#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq, Parse, ToCss)] +#[repr(u8)] +#[allow(missing_docs)] +pub enum GenericFontFamily { + /// No generic family specified, only for internal usage. + #[css(skip)] + None, + Serif, + SansSerif, + Monospace, + Cursive, + Fantasy, + /// This is basically monospace, but with different font prefs. We should + /// consider removing it in favor of just using the monospace.* prefs, since + /// in practice we don't override the monospace prefs at all. + #[cfg(feature = "gecko")] + MozFixed, + /// An internal value for emoji font selection. + #[css(skip)] + #[cfg(feature = "gecko")] + MozEmoji, +} + +// TODO(emilio): Derive this when we make -moz-fixed a parse alias of Monospace. +impl ToCss for GenericFontFamily { + fn to_css(&self, dest: &mut CssWriter) -> fmt::Result + where + W: fmt::Write, + { + dest.write_str(match *self { + GenericFontFamily::MozEmoji | + GenericFontFamily::Default => return Ok(()), + GenericFontFamily::MozFixed | + GenericFontFamily::Monospace => "monospace", + GenericFontFamily::Serif => "serif", + GenericFontFamily::SansSerif => "sans-serif", + GenericFontFamily::Cursive => "cursive", + GenericFontFamily::Fantasy => "fantasy", + }) + } } impl SingleFontFamily { - #[inline] - /// Get font family name as Atom - pub fn atom(&self) -> &Atom { - match *self { - SingleFontFamily::FamilyName(ref family_name) => &family_name.name, - SingleFontFamily::Generic(ref name) => name, - } - } - - #[inline] - #[cfg(not(feature = "gecko"))] // Gecko can't borrow atoms as UTF-8. - /// Get font family name - pub fn name(&self) -> &str { - self.atom() - } - - #[cfg(not(feature = "gecko"))] // Gecko can't borrow atoms as UTF-8. - /// Get the corresponding font-family with Atom - pub fn from_atom(input: Atom) -> SingleFontFamily { - match input { - atom!("serif") | - atom!("sans-serif") | - atom!("cursive") | - atom!("fantasy") | - atom!("monospace") => return SingleFontFamily::Generic(input), - _ => {}, - } - match_ignore_ascii_case! { &input, - "serif" => return SingleFontFamily::Generic(atom!("serif")), - "sans-serif" => return SingleFontFamily::Generic(atom!("sans-serif")), - "cursive" => return SingleFontFamily::Generic(atom!("cursive")), - "fantasy" => return SingleFontFamily::Generic(atom!("fantasy")), - "monospace" => return SingleFontFamily::Generic(atom!("monospace")), - _ => {} - } - - // We don't know if it's quoted or not. So we set it to - // quoted by default. - SingleFontFamily::FamilyName(FamilyName { - name: input, - syntax: FamilyNameSyntax::Quoted, - }) - } - - /// Parse a font-family value + /// Parse a font-family value. pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result> { if let Ok(value) = input.try(|i| i.expect_string_cloned()) { return Ok(SingleFontFamily::FamilyName(FamilyName { name: Atom::from(&*value), - syntax: FamilyNameSyntax::Quoted, + syntax: FontFamilyNameSyntax::Quoted, })); } - let first_ident = input.expect_ident()?.clone(); - // FIXME(bholley): The fast thing to do here would be to look up the - // string (as lowercase) in the static atoms table. We don't have an - // API to do that yet though, so we do the simple thing for now. - let mut css_wide_keyword = false; - match_ignore_ascii_case! { &first_ident, - "serif" => return Ok(SingleFontFamily::Generic(atom!("serif"))), - "sans-serif" => return Ok(SingleFontFamily::Generic(atom!("sans-serif"))), - "cursive" => return Ok(SingleFontFamily::Generic(atom!("cursive"))), - "fantasy" => return Ok(SingleFontFamily::Generic(atom!("fantasy"))), - "monospace" => return Ok(SingleFontFamily::Generic(atom!("monospace"))), - - #[cfg(feature = "gecko")] - "-moz-fixed" => return Ok(SingleFontFamily::Generic(atom!("-moz-fixed"))), + let first_ident = input.expect_ident_cloned()?; + if let Ok(generic) = GenericFontFamily::from_ident(&first_ident) { + return Ok(SingleFontFamily::Generic(generic)); + } + let reserved = match_ignore_ascii_case! { &first_ident, // https://drafts.csswg.org/css-fonts/#propdef-font-family // "Font family names that happen to be the same as a keyword value // (`inherit`, `serif`, `sans-serif`, `monospace`, `fantasy`, and `cursive`) @@ -368,18 +359,15 @@ impl SingleFontFamily { // The keywords ‘initial’ and ‘default’ are reserved for future use // and must also be quoted when used as font names. // UAs must not consider these keywords as matching the type." - "inherit" => css_wide_keyword = true, - "initial" => css_wide_keyword = true, - "unset" => css_wide_keyword = true, - "default" => css_wide_keyword = true, - _ => {} - } + "inherit" | "initial" | "unset" | "revert" | "default" => true, + _ => false, + }; let mut value = first_ident.as_ref().to_owned(); // These keywords are not allowed by themselves. // The only way this value can be valid with with another keyword. - if css_wide_keyword { + if reserved { let ident = input.expect_ident()?; value.push(' '); value.push_str(&ident); @@ -393,9 +381,9 @@ impl SingleFontFamily { // `font-family: \ a\ \ b\ \ c\ ;`, it is tricky to serialize them // as identifiers correctly. Just mark them quoted so we don't need // to worry about them in serialization code. - FamilyNameSyntax::Quoted + FontFamilyNameSyntax::Quoted } else { - FamilyNameSyntax::Identifiers + FontFamilyNameSyntax::Identifiers }; Ok(SingleFontFamily::FamilyName(FamilyName { name: Atom::from(value), @@ -403,94 +391,18 @@ impl SingleFontFamily { })) } - #[cfg(feature = "gecko")] - /// Return the generic ID for a given generic font name - pub fn generic(name: &Atom) -> (structs::FontFamilyType, u8) { - use crate::gecko_bindings::structs::FontFamilyType; - if *name == atom!("serif") { - (FontFamilyType::eFamily_serif, structs::kGenericFont_serif) - } else if *name == atom!("sans-serif") { - ( - FontFamilyType::eFamily_sans_serif, - structs::kGenericFont_sans_serif, - ) - } else if *name == atom!("cursive") { - ( - FontFamilyType::eFamily_cursive, - structs::kGenericFont_cursive, - ) - } else if *name == atom!("fantasy") { - ( - FontFamilyType::eFamily_fantasy, - structs::kGenericFont_fantasy, - ) - } else if *name == atom!("monospace") { - ( - FontFamilyType::eFamily_monospace, - structs::kGenericFont_monospace, - ) - } else if *name == atom!("-moz-fixed") { - ( - FontFamilyType::eFamily_moz_fixed, - structs::kGenericFont_moz_fixed, - ) - } else { - panic!("Unknown generic {}", name); - } - } - #[cfg(feature = "gecko")] /// Get the corresponding font-family with family name fn from_font_family_name(family: &structs::FontFamilyName) -> SingleFontFamily { - use crate::gecko_bindings::structs::FontFamilyType; - - match family.mType { - FontFamilyType::eFamily_sans_serif => SingleFontFamily::Generic(atom!("sans-serif")), - FontFamilyType::eFamily_serif => SingleFontFamily::Generic(atom!("serif")), - FontFamilyType::eFamily_monospace => SingleFontFamily::Generic(atom!("monospace")), - FontFamilyType::eFamily_cursive => SingleFontFamily::Generic(atom!("cursive")), - FontFamilyType::eFamily_fantasy => SingleFontFamily::Generic(atom!("fantasy")), - FontFamilyType::eFamily_moz_fixed => SingleFontFamily::Generic(atom!("-moz-fixed")), - FontFamilyType::eFamily_named => { - let name = unsafe { Atom::from_raw(family.mName.mRawPtr) }; - SingleFontFamily::FamilyName(FamilyName { - name, - syntax: FamilyNameSyntax::Identifiers, - }) - }, - FontFamilyType::eFamily_named_quoted => { - let name = unsafe { Atom::from_raw(family.mName.mRawPtr) }; - SingleFontFamily::FamilyName(FamilyName { - name, - syntax: FamilyNameSyntax::Quoted, - }) - }, - _ => panic!("Found unexpected font FontFamilyType"), - } - } -} - -impl ToCss for SingleFontFamily { - fn to_css(&self, dest: &mut CssWriter) -> fmt::Result - where - W: fmt::Write, - { - match *self { - SingleFontFamily::FamilyName(ref name) => name.to_css(dest), - - // All generic values accepted by the parser are known to not require escaping. - SingleFontFamily::Generic(ref name) => { - #[cfg(feature = "gecko")] - { - // We should treat -moz-fixed as monospace - if name == &atom!("-moz-fixed") { - return dest.write_str("monospace"); - } - } - - write!(dest, "{}", name) - }, + if family.mName.mRawPtr.is_null() { + debug_assert_ne!(family.mGeneric, GenericFontFamily::None); + return SingleFontFamily::Generic(family.mGeneric); } + let name = unsafe { Atom::from_raw(family.mName.mRawPtr) }; + SingleFontFamily::FamilyName(FamilyName { + name, + syntax: family.mSyntax, + }) } } @@ -506,7 +418,7 @@ pub enum FontFamilyList { /// A strong reference to a Gecko SharedFontList object. SharedFontList(RefPtr), /// A font-family generic ID. - Generic(structs::FontFamilyType), + Generic(GenericFontFamily), } #[cfg(feature = "gecko")] @@ -514,38 +426,19 @@ impl ToShmem for FontFamilyList { fn to_shmem(&self, _builder: &mut SharedMemoryBuilder) -> ManuallyDrop { // In practice, the only SharedFontList objects we create from shared // style sheets are ones with a single generic entry. - ManuallyDrop::new(match self { - FontFamilyList::SharedFontList(r) => { + ManuallyDrop::new(match *self { + FontFamilyList::SharedFontList(ref r) => { assert!( r.mNames.len() == 1 && r.mNames[0].mName.mRawPtr.is_null(), "ToShmem failed for FontFamilyList: cannot handle non-generic families", ); - FontFamilyList::Generic(r.mNames[0].mType) + FontFamilyList::Generic(r.mNames[0].mGeneric) }, - FontFamilyList::Generic(t) => FontFamilyList::Generic(*t), + FontFamilyList::Generic(t) => FontFamilyList::Generic(t), }) } } -#[cfg(feature = "gecko")] -impl Hash for FontFamilyList { - fn hash(&self, state: &mut H) - where - H: Hasher, - { - use crate::string_cache::WeakAtom; - - for name in self.shared_font_list().mNames.iter() { - name.mType.hash(state); - if !name.mName.mRawPtr.is_null() { - unsafe { - WeakAtom::new(name.mName.mRawPtr).hash(state); - } - } - } - } -} - #[cfg(feature = "gecko")] impl PartialEq for FontFamilyList { fn eq(&self, other: &FontFamilyList) -> bool { @@ -556,7 +449,8 @@ impl PartialEq for FontFamilyList { return false; } for (a, b) in self_list.mNames.iter().zip(other_list.mNames.iter()) { - if a.mType != b.mType || a.mName.mRawPtr != b.mName.mRawPtr { + if a.mSyntax != b.mSyntax || a.mName.mRawPtr != b.mName.mRawPtr || + a.mGeneric != b.mGeneric { return false; } } @@ -588,19 +482,17 @@ impl FontFamilyList { for family in families.iter() { match *family { SingleFontFamily::FamilyName(ref f) => { - let quoted = matches!(f.syntax, FamilyNameSyntax::Quoted); unsafe { bindings::Gecko_nsTArray_FontFamilyName_AppendNamed( names, f.name.as_ptr(), - quoted, + f.syntax, ); } }, - SingleFontFamily::Generic(ref name) => { - let (family_type, _generic) = SingleFontFamily::generic(name); + SingleFontFamily::Generic(family) => { unsafe { - bindings::Gecko_nsTArray_FontFamilyName_AppendGeneric(names, family_type); + bindings::Gecko_nsTArray_FontFamilyName_AppendGeneric(names, family); } }, } @@ -625,12 +517,11 @@ impl FontFamilyList { } /// Return the generic ID if it is a single generic font - #[cfg(feature = "gecko")] - pub fn single_generic(&self) -> Option { + pub fn single_generic(&self) -> Option { let mut iter = self.iter(); - if let Some(SingleFontFamily::Generic(ref name)) = iter.next() { + if let Some(SingleFontFamily::Generic(f)) = iter.next() { if iter.next().is_none() { - return Some(SingleFontFamily::generic(name).1); + return Some(f); } } None @@ -639,13 +530,12 @@ impl FontFamilyList { /// Return a reference to the Gecko SharedFontList. #[cfg(feature = "gecko")] pub fn shared_font_list(&self) -> &RefPtr { - match self { - FontFamilyList::SharedFontList(r) => r, + match *self { + FontFamilyList::SharedFontList(ref r) => r, FontFamilyList::Generic(t) => { unsafe { // TODO(heycam): Should really add StaticRefPtr sugar. - let index = - (*t as usize) - (structs::FontFamilyType::eFamily_generic_first as usize); + let index = t as usize; mem::transmute::< &structs::StaticRefPtr, &RefPtr, diff --git a/components/style/values/specified/font.rs b/components/style/values/specified/font.rs index 03896bc9c0b..1e19ebe7a08 100644 --- a/components/style/values/specified/font.rs +++ b/components/style/values/specified/font.rs @@ -515,7 +515,8 @@ impl From for FontSize { } /// Specifies a prioritized list of font family names or generic family names. -#[derive(Clone, Debug, Eq, Hash, PartialEq, ToCss, ToShmem)] +#[derive(Clone, Debug, Eq, PartialEq, ToCss, ToShmem)] +#[cfg_attr(feature = "servo", derive(Hash))] pub enum FontFamily { /// List of `font-family` #[css(comma)]