Always use user preference font before system fallback

third_party/WebKit/Source/platform/fonts/FontFallbackList.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 30 matching lines @@
 namespace blink {
 
 FontFallbackList::FontFallbackList()
     : m_pageZero(0)
     , m_cachedPrimarySimpleFontData(0)
     , m_fontSelector(nullptr)
     , m_fontSelectorVersion(0)
     , m_familyIndex(0)
     , m_generation(FontCache::fontCache()->generation())
     , m_hasLoadingFallback(false)
+    , m_hasNonBlankFontData(false)
 {
 }
 
 void FontFallbackList::invalidate(PassRefPtrWillBeRawPtr<FontSelector> fontSelector)
 {
     releaseFontData();
     m_fontList.clear();
     m_pageZero = 0;
     m_pages.clear();
     m_cachedPrimarySimpleFontData = 0;
     m_familyIndex = 0;
     m_hasLoadingFallback = false;
+    m_hasNonBlankFontData = false;
     if (m_fontSelector != fontSelector)
         m_fontSelector = fontSelector;
     m_fontSelectorVersion = m_fontSelector ? m_fontSelector->version() : 0;
     m_generation = FontCache::fontCache()->generation();
 }
 
 void FontFallbackList::releaseFontData()
 {
     unsigned numFonts = m_fontList.size();
     for (unsigned i = 0; i < numFonts; ++i) {
@@ skipping 75 matching lines @@
         // Begin to load the first custom font if needed.
         if (shouldLoadCustomFont) {
             shouldLoadCustomFont = false;
             fontDataForSpace->customFontData()->beginLoadIfNeeded();
         }
     }
 }
 
 PassRefPtr<FontData> FontFallbackList::getFontData(const FontDescription& fontDescription, int& familyIndex) const
 {
-    RefPtr<FontData> result;
+    const FontFamily* currFamily = &fontDescription.family();
+    for (int i = 0; currFamily && i < familyIndex; i++)
+        currFamily = currFamily->next();
 
-    int startIndex = familyIndex;
-    const FontFamily* startFamily = &fontDescription.family();
-    for (int i = 0; startFamily && i < startIndex; i++)
-        startFamily = startFamily->next();
-    const FontFamily* currFamily = startFamily;
-    while (currFamily && !result) {
+    for (; currFamily; currFamily = currFamily->next()) {
         familyIndex++;
         if (currFamily->family().length()) {
+            RefPtr<FontData> result;
             if (m_fontSelector)
                 result = m_fontSelector->getFontData(fontDescription, currFamily->family());
-
             if (!result)
                 result = FontCache::fontCache()->getFontData(fontDescription, currFamily->family());
+            if (result)
+                return result.release();
         }
-        currFamily = currFamily->next();
     }
+    familyIndex = cAllFamiliesScanned;
 
-    if (!currFamily)
-        familyIndex = cAllFamiliesScanned;
+    if (m_hasNonBlankFontData)
+        return nullptr;
 
-    if (result || startIndex)
-        return result.release();
-
-    // If it's the primary font that we couldn't find, we try the following. In all other cases, we will
-    // just use per-character system fallback.
+    // If we couldn't find any non-blank font data in the family list, we try
+    // the following. In all other cases, we will just use per-character system
+    // fallback.
 
     if (m_fontSelector) {
         // Try the user's preferred standard font.
         if (RefPtr<FontData> data = m_fontSelector->getFontData(fontDescription, FontFamilyNames::webkit_standard))
             return data.release();
     }
 
     // Still no result. Hand back our last resort fallback font.
     return FontCache::fontCache()->getLastResortFallbackFont(fontDescription);
 }
@@ skipping 36 matching lines @@
     // Ask the font cache for the font data.
     // We are obtaining this font for the first time.  We keep track of the families we've looked at before
     // in |m_familyIndex|, so that we never scan the same spot in the list twice.  getFontData will adjust our
     // |m_familyIndex| as it scans for the right font to make.
     ASSERT(FontCache::fontCache()->generation() == m_generation);
     RefPtr<FontData> result = getFontData(fontDescription, m_familyIndex);
     if (result) {
         m_fontList.append(result);
         if (result->isLoadingFallback())
             m_hasLoadingFallback = true;
+        else

[drott, 2015/12/01 09:36:22]

Is there a way we could avoid the additional flag? Could it be expressed through
a combination of familyIndex and m_hasLoadingfallback? It seems a bit odd to me
that the flag is set outside of getFontData based on getFontData's result, and
then used inside the getFontData function.

+            m_hasNonBlankFontData = true;
     }
     return result.get();
 }
 
 bool FontFallbackList::isValid() const
 {
     if (!m_fontSelector)
         return m_fontSelectorVersion == 0;
 
     return m_fontSelector->version() == m_fontSelectorVersion;
 }
 
 } // namespace blink