Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-09 11:25:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1739464 - Use first generic rather than only generic to determine fallback font family. r=jfkthame

Browse Source 
This seems like more sensible behavior. We have another use of
only_generic(), but that affects font sizing and other browsers agree
with us there:

  <div style="font-family: monospace">Should be 13px</div>
  <div style="font-family: something, monospace">Should be 16px</div>

So not touching that one.

Differential Revision: https://phabricator.services.mozilla.com/D130732
This commit is contained in:
Emilio Cobos Álvarez 2021-11-10 17:58:18 +00:00
parent a687f82538
commit 4dabed3c51
7 changed files with 33 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
layout/reftests/font-matching/reftest.list
View File

@ -164,6 +164,7 @@ random-if(/^Windows\x20NT\x206\.1/.test(http.oscpu)) == descriptor-ranges.html d
skip-if(Android) fuzzy-if(winWidget&&isCoverageBuild,255-255,2373-2373) == fallback-respects-generic-1.html fallback-respects-generic-1-ref.html # fonts present on Android are too unpredictable for easy testing
skip-if(Android) fails-if(winWidget&&isCoverageBuild) != system-ui-fallback.html system-ui-fallback-notref.html # Roboto supports the characters in the reftest, and that's better behavior.
== system-ui-fallback-2.html system-ui-fallback-2-ref.html
# Japanese monospace font on macOS is Osaka-mono
# If Osaka is present then Osaka-mono should also be available.

2
layout/reftests/font-matching/system-ui-fallback-2-ref.html Normal file
View File

@ -0,0 +1,2 @@
<!doctype html>
<h1 style="font-family: system-ui">&#1576;</h1>

2
layout/reftests/font-matching/system-ui-fallback-2.html Normal file
View File

@ -0,0 +1,2 @@
<!doctype html>
<h1 style="font-family: nonexistent, system-ui">&#1576;</h1>

19
layout/style/GeckoBindings.cpp
View File

@ -90,15 +90,15 @@ ServoTraversalStatistics ServoTraversalStatistics::sSingleton;
static StaticAutoPtr<RWLock> sServoFFILock;
static const nsFont* ThreadSafeGetDefaultFontHelper(
const Document& aDocument, nsAtom* aLanguage,
StyleGenericFontFamily aGenericId) {
static const nsFont* ThreadSafeGetDefaultVariableFont(const Document& aDocument,
nsAtom* aLanguage) {
bool needsCache = false;
const nsFont* retval;
auto GetDefaultFont = [&](bool* aNeedsToCache) {
auto* prefs = aDocument.GetFontPrefsForLang(aLanguage, aNeedsToCache);
return prefs ? prefs->GetDefaultFont(aGenericId) : nullptr;
return prefs ? prefs->GetDefaultFont(StyleGenericFontFamily::None)
: nullptr;
};
{
@ -978,8 +978,8 @@ void Gecko_ReleaseAtom(nsAtom* aAtom) { NS_RELEASE(aAtom); }
void Gecko_nsFont_InitSystem(nsFont* aDest, StyleSystemFont aFontId,
const nsStyleFont* aFont,
const Document* aDocument) {
const nsFont* defaultVariableFont = ThreadSafeGetDefaultFontHelper(
*aDocument, aFont->mLanguage, StyleGenericFontFamily::None);
const nsFont* defaultVariableFont =
ThreadSafeGetDefaultVariableFont(*aDocument, aFont->mLanguage);
// We have passed uninitialized memory to this function,
// initialize it. We can't simply return an nsFont because then
@ -994,11 +994,10 @@ void Gecko_nsFont_InitSystem(nsFont* aDest, StyleSystemFont aFontId,
void Gecko_nsFont_Destroy(nsFont* aDest) { aDest->~nsFont(); }
StyleGenericFontFamily Gecko_nsStyleFont_ComputeDefaultFontType(
const Document* aDoc, StyleGenericFontFamily aGenericId,
nsAtom* aLanguage) {
StyleGenericFontFamily Gecko_nsStyleFont_ComputeFallbackFontTypeForLanguage(
const Document* aDoc, nsAtom* aLanguage) {
const nsFont* defaultFont =
ThreadSafeGetDefaultFontHelper(*aDoc, aLanguage, aGenericId);
ThreadSafeGetDefaultVariableFont(*aDoc, aLanguage);
return defaultFont->family.families.fallback;
}

8
layout/style/GeckoBindings.h
View File

@ -474,10 +474,10 @@ void Gecko_nsStyleFont_CopyLangFrom(nsStyleFont* aFont,
mozilla::Length Gecko_nsStyleFont_ComputeMinSize(const nsStyleFont*,
const mozilla::dom::Document*);
// Computes the default generic font for a generic family and language.
mozilla::StyleGenericFontFamily Gecko_nsStyleFont_ComputeDefaultFontType(
const mozilla::dom::Document*,
mozilla::StyleGenericFontFamily generic_family, nsAtom* language);
// Computes the default generic font for a language.
mozilla::StyleGenericFontFamily
Gecko_nsStyleFont_ComputeFallbackFontTypeForLanguage(
const mozilla::dom::Document*, nsAtom* language);
mozilla::StyleDefaultFontSizes Gecko_GetBaseSize(nsAtom* lang);

12
servo/components/style/properties/cascade.rs
View File

@ -894,7 +894,6 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
return;
}
let use_document_fonts = static_prefs::pref!("browser.display.use_document_fonts") != 0;
let builder = &mut self.context.builder;
let (default_font_type, prioritize_user_fonts) = {
let font = builder.get_font().gecko();
@ -909,22 +908,23 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
return;
}
let generic = font.mFont.family.families.single_generic().unwrap_or(GenericFontFamily::None);
let default_font_type = unsafe {
bindings::Gecko_nsStyleFont_ComputeDefaultFontType(
bindings::Gecko_nsStyleFont_ComputeFallbackFontTypeForLanguage(
builder.device.document(),
generic,
font.mLanguage.mRawPtr,
)
};
let use_document_fonts = static_prefs::pref!("browser.display.use_document_fonts") != 0;
// We prioritize user fonts over document fonts if the pref is set,
// and we don't have a generic family already (or we're using
// cursive or fantasy, since they're ignored, see bug 789788), and
// we have a generic family to actually replace it with.
let prioritize_user_fonts = !use_document_fonts &&
let prioritize_user_fonts =
!use_document_fonts &&
default_font_type != GenericFontFamily::None &&
!generic.valid_for_user_font_prioritization();
font.mFont.family.families.needs_user_font_prioritization();
if !prioritize_user_fonts && default_font_type == font.mFont.family.families.fallback {
// Nothing to do.

10
servo/components/style/values/computed/font.rs
View File

@ -583,12 +583,20 @@ impl FontFamilyList {
self.list = crate::ArcSlice::from_iter(new_list.into_iter());
}
/// Returns whether we need to prioritize user fonts.
pub (crate) fn needs_user_font_prioritization(&self) -> bool {
self.iter().next().map_or(true, |f| match f {
SingleFontFamily::Generic(f) => !f.valid_for_user_font_prioritization(),
_ => true,
})
}
/// Return the generic ID if it is a single generic font
pub fn single_generic(&self) -> Option<GenericFontFamily> {
let mut iter = self.iter();
if let Some(SingleFontFamily::Generic(f)) = iter.next() {
if iter.next().is_none() {
return Some(f.clone());
return Some(*f);
}
}
None