Remove unnecessary font loading when loading font fallbacks.

third_party/WebKit/Source/platform/fonts/win/FontFallbackWin.cpp

 /*
  * Copyright (c) 2006, 2007, 2008, 2009, 2010, 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 50 matching lines @@
         if (equalIgnoringCase(family, AtomicString::fromUTF8(actualFamily.fString.c_str()))) {
             matchesRequestedFamily = true;
             break;
         }
     }
     actualFamilies->unref();
 
     return matchesRequestedFamily;
 }
 
+struct FontMapping {
+    const UChar* familyName;
+    const UChar** candidateFamilyNames;
+};
 // A simple mapping from UScriptCode to family name. This is a sparse array,
 // which works well since the range of UScriptCode values is small.
-typedef const UChar* ScriptToFontMap[USCRIPT_CODE_LIMIT];
+typedef FontMapping ScriptToFontMap[USCRIPT_CODE_LIMIT];
 
-void initializeScriptMonospaceFontMap(ScriptToFontMap& scriptFontMap, SkFontMgr* fontManager)
+const UChar* findMonospaceFontForScript(UScriptCode script)
 {
     struct FontMap {
         UScriptCode script;
         const UChar* family;
     };
 
     static const FontMap fontMap[] = {
         { USCRIPT_HEBREW, L"courier new" },
         { USCRIPT_ARABIC, L"courier new" },
     };
 
-    for (size_t i = 0; i < WTF_ARRAY_LENGTH(fontMap); ++i)
-        scriptFontMap[fontMap[i].script] = fontMap[i].family;
+    for (const auto& fontFamily : fontMap) {
+        if (fontFamily.script == script)
+            return fontFamily.family;
+    }
+    return nullptr;
 }
 
-void initializeScriptFontMap(ScriptToFontMap& scriptFontMap, SkFontMgr* fontManager)
+void initializeScriptFontMap(ScriptToFontMap& scriptFontMap)
 {
-    struct FontMap {
-        UScriptCode script;
-        const UChar* family;
-    };
-
-    static const FontMap fontMap[] = {
-        { USCRIPT_LATIN, L"Times New Roman" },
-        { USCRIPT_GREEK, L"Times New Roman" },
-        { USCRIPT_CYRILLIC, L"Times New Roman" },
-        // For USCRIPT_COMMON, we map blocks to scripts when
-        // that makes sense.
-    };
-
     struct ScriptToFontFamilies {
         UScriptCode script;
         const UChar** families;
     };
 
     // For the following scripts, multiple fonts may be listed. They are tried
     // in order. The first slot is preferred but the font may not be available,
     // if so the remaining slots are tried in order.
     // In general the order is the Windows 10 font follow by the 8.1, 8.0 and
     // finally the font for Windows 7.
     // For scripts where an optional or region specific font may be available
     // that should be listed before the generic one.
     // Based on the "Script and Font Support in Windows" MSDN documentation [1]
     // with overrides and additional fallbacks as needed.
     // 1: https://msdn.microsoft.com/en-us/goglobal/bb688099.aspx
     static const UChar* arabicFonts[] = { L"Tahoma", L"Segoe UI", 0 };
     static const UChar* armenianFonts[] = { L"Segoe UI", L"Sylfaen", 0 };
     static const UChar* bengaliFonts[] = { L"Nirmala UI", L"Vrinda", 0 };
     static const UChar* brahmiFonts[] = { L"Segoe UI Historic", 0 };
     static const UChar* brailleFonts[] = { L"Segoe UI Symbol", 0 };
     static const UChar* bugineseFonts[] = { L"Leelawadee UI", 0 };
     static const UChar* canadianAaboriginalFonts[] = { L"Gadugi",
         L"Euphemia", 0 };
     static const UChar* carianFonts[] = { L"Segoe UI Historic", 0 };
     static const UChar* cherokeeFonts[] = { L"Gadugi", L"Plantagenet", 0 };
     static const UChar* copticFonts[] = { L"Segoe UI Symbol", 0 };
     static const UChar* cuneiformFonts[] = { L"Segoe UI Historic", 0 };
     static const UChar* cypriotFonts[] = { L"Segoe UI Historic", 0 };
+    static const UChar* cyrillicFonts[] = { L"Times New Roman", 0 };
     static const UChar* deseretFonts[] = { L"Segoe UI Symbol", 0 };
     static const UChar* devanagariFonts[] = { L"Nirmala UI", L"Mangal", 0 };
     static const UChar* egyptianHieroglyphsFonts[] = { L"Segoe UI Historic",
         0 };
     static const UChar* ethiopicFonts[] = { L"Nyala", L"Abyssinica SIL",
         L"Ethiopia Jiret", L"Visual Geez Unicode", L"GF Zemen Unicode",
         L"Ebrima", 0 };
     static const UChar* georgianFonts[] = { L"Sylfaen", L"Segoe UI", 0 };
     static const UChar* glagoliticFonts[] = { L"Segoe UI Historic",
         L"Segoe UI Symbol", 0 };
     static const UChar* gothicFonts[] = { L"Segoe UI Historic",
         L"Segoe UI Symbol", 0 };
+    static const UChar* greekFonts[] = { L"Times New Roman", 0 };
     static const UChar* gujaratiFonts[] = { L"Nirmala UI", L"Shruti", 0 };
     static const UChar* gurmukhiFonts[] = { L"Nirmala UI", L"Raavi", 0 };
     static const UChar* hangulFonts[] = { L"Malgun Gothic", L"Gulim", 0 };
     static const UChar* hebrewFonts[] = { L"David", L"Segoe UI", 0 };
     static const UChar* imperialAramaicFonts[] = { L"Segoe UI Historic", 0 };
     static const UChar* inscriptionalPahlaviFonts[] = { L"Segoe UI Historic",
         0 };
     static const UChar* inscriptionalParthianFonts[] = { L"Segoe UI Historic",
         0 };
     static const UChar* javaneseFonts[] = { L"Javanese Text", 0 };
     static const UChar* kannadaFonts[] = { L"Tunga", L"Nirmala UI", 0 };
     static const UChar* katakanaOrHiraganaFonts[] = { L"Meiryo", L"Yu Gothic",
         L"MS PGothic", L"Microsoft YaHei", 0 };
     static const UChar* kharoshthiFonts[] = { L"Segoe UI Historic", 0 };
     // Try Khmer OS before Vista fonts as it goes along better with Latin
     // and looks better/larger for the same size.
     static const UChar* khmerFonts[] = { L"Leelawadee UI", L"Khmer UI",
         L"Khmer OS", L"MoolBoran", L"DaunPenh", 0 };
     static const UChar* laoFonts[] = { L"Leelawadee UI", L"Lao UI",
         L"DokChampa", L"Saysettha OT", L"Phetsarath OT", L"Code2000", 0 };
+    static const UChar* latinFonts[] = { L"Times New Roman", 0 };
     static const UChar* lisuFonts[] = { L"Segoe UI", 0 };
     static const UChar* lycianFonts[] = { L"Segoe UI Historic", 0 };
     static const UChar* lydianFonts[] = { L"Segoe UI Historic", 0 };
     static const UChar* malayalamFonts[] = { L"Nirmala UI", L"Kartika", 0 };
     static const UChar* meroiticCursiveFonts[] = { L"Segoe UI Historic",
         L"Segoe UI Symbol", 0 };
     static const UChar* mongolianFonts[] = { L"Mongolian Baiti", 0 };
     static const UChar* myanmarFonts[] = { L"Myanmar Text", L"Padauk",
         L"Parabaik", L"Myanmar3", L"Code2000", 0 };
     static const UChar* newTaiLueFonts[] = { L"Microsoft New Tai Lue", 0 };
@@ skipping 43 matching lines @@
         { USCRIPT_BENGALI, bengaliFonts },
         { USCRIPT_BRAHMI, brahmiFonts },
         { USCRIPT_BRAILLE, brailleFonts },
         { USCRIPT_BUGINESE, bugineseFonts },
         { USCRIPT_CANADIAN_ABORIGINAL, canadianAaboriginalFonts },
         { USCRIPT_CARIAN, carianFonts },
         { USCRIPT_CHEROKEE, cherokeeFonts },
         { USCRIPT_COPTIC, copticFonts },
         { USCRIPT_CUNEIFORM, cuneiformFonts },
         { USCRIPT_CYPRIOT, cypriotFonts },
+        { USCRIPT_CYRILLIC, cyrillicFonts },
         { USCRIPT_DESERET, deseretFonts },
         { USCRIPT_DEVANAGARI, devanagariFonts },
         { USCRIPT_EGYPTIAN_HIEROGLYPHS, egyptianHieroglyphsFonts },
         { USCRIPT_ETHIOPIC, ethiopicFonts },
         { USCRIPT_GEORGIAN, georgianFonts },
         { USCRIPT_GLAGOLITIC, glagoliticFonts },
         { USCRIPT_GOTHIC, gothicFonts },
+        { USCRIPT_GREEK, greekFonts },
         { USCRIPT_GUJARATI, gujaratiFonts },
         { USCRIPT_GURMUKHI, gurmukhiFonts },
         { USCRIPT_HANGUL, hangulFonts },
         { USCRIPT_HEBREW, hebrewFonts },
         { USCRIPT_HIRAGANA, katakanaOrHiraganaFonts },
         { USCRIPT_IMPERIAL_ARAMAIC, imperialAramaicFonts },
         { USCRIPT_INSCRIPTIONAL_PAHLAVI, inscriptionalPahlaviFonts },
         { USCRIPT_INSCRIPTIONAL_PARTHIAN, inscriptionalParthianFonts },
         { USCRIPT_JAVANESE, javaneseFonts },
         { USCRIPT_KANNADA, kannadaFonts },
         { USCRIPT_KATAKANA, katakanaOrHiraganaFonts },
         { USCRIPT_KATAKANA_OR_HIRAGANA, katakanaOrHiraganaFonts },
         { USCRIPT_KHAROSHTHI, kharoshthiFonts },
         { USCRIPT_KHMER, khmerFonts },
         { USCRIPT_LAO, laoFonts },
+        { USCRIPT_LATIN, latinFonts },
         { USCRIPT_LISU, lisuFonts },
         { USCRIPT_LYCIAN, lycianFonts },
         { USCRIPT_LYDIAN, lydianFonts },
         { USCRIPT_MALAYALAM, malayalamFonts },
         { USCRIPT_MEROITIC_CURSIVE, meroiticCursiveFonts },
         { USCRIPT_MONGOLIAN, mongolianFonts },
         { USCRIPT_MYANMAR, myanmarFonts },
         { USCRIPT_NEW_TAI_LUE, newTaiLueFonts },
         { USCRIPT_NKO, nkoFonts },
         { USCRIPT_OGHAM, oghamFonts },
@@ skipping 17 matching lines @@
         { USCRIPT_TELUGU, teluguFonts },
         { USCRIPT_THAANA, thaanaFonts },
         { USCRIPT_THAI, thaiFonts },
         { USCRIPT_TIBETAN, tibetanFonts },
         { USCRIPT_TIFINAGH, tifinaghFonts },
         { USCRIPT_TRADITIONAL_HAN, traditionalHanFonts },
         { USCRIPT_VAI, vaiFonts },
         { USCRIPT_YI, yiFonts }
     };
 
-    for (size_t i = 0; i < WTF_ARRAY_LENGTH(fontMap); ++i)
-        scriptFontMap[fontMap[i].script] = fontMap[i].family;
-
-    // FIXME: Instead of scanning the hard-coded list, we have to
-    // use EnumFont* to 'inspect' fonts to pick up fonts covering scripts
-    // when it's possible (e.g. using OS/2 table). If we do that, this
-    // had better be pulled out of here.
-    for (size_t i = 0; i < WTF_ARRAY_LENGTH(scriptToFontFamilies); ++i) {
-        UScriptCode script = scriptToFontFamilies[i].script;
-        scriptFontMap[script] = 0;
-        const UChar** familyPtr = scriptToFontFamilies[i].families;
-        while (*familyPtr) {
-            if (isFontPresent(*familyPtr, fontManager)) {
-                scriptFontMap[script] = *familyPtr;
-                break;
-            }
-            ++familyPtr;
-        }
+    for (const auto& fontFamily : scriptToFontFamilies) {
+        scriptFontMap[fontFamily.script].candidateFamilyNames = fontFamily.families;
     }
 
     // Initialize the locale-dependent mapping from system locale.
     UScriptCode hanScript = LayoutLocale::getSystem().scriptForHan();
-    if (const UChar* localeFamily = scriptFontMap[hanScript])
-        scriptFontMap[USCRIPT_HAN] = localeFamily;
+    DCHECK(hanScript != USCRIPT_HAN);
+    if (scriptFontMap[hanScript].candidateFamilyNames) {
+        scriptFontMap[USCRIPT_HAN].candidateFamilyNames = scriptFontMap[hanScript].candidateFamilyNames;
+    }
+}
+
+void findFirstExistingCandidateFont(FontMapping& scriptFontMapping, SkFontMgr* fontManager)
+{
+    for (const UChar** familyPtr = scriptFontMapping.candidateFamilyNames; *familyPtr; familyPtr++) {
+        if (isFontPresent(*familyPtr, fontManager)) {
+            scriptFontMapping.familyName = *familyPtr;
+            break;
+        }
+    }
+    scriptFontMapping.candidateFamilyNames = nullptr;
 }
 
 // There are a lot of characters in USCRIPT_COMMON that can be covered
 // by fonts for scripts closely related to them. See
 // http://unicode.org/cldr/utility/list-unicodeset.jsp?a=[:Script=Common:]
 // FIXME: make this more efficient with a wider coverage
 UScriptCode getScriptBasedOnUnicodeBlock(int ucs4)
 {
     UBlockCode block = ublock_getCode(ucs4);
     switch (block) {
@@ skipping 107 matching lines @@
 //  - Consider using UnicodeSet (or UnicodeMap) converted from
 //    GLYPHSET (BMP) or directly read from truetype cmap tables to
 //    keep track of which character is supported by which font
 //  - Update script_font_cache in response to WM_FONTCHANGE
 
 const UChar* getFontFamilyForScript(UScriptCode script,
     FontDescription::GenericFamilyType generic,
     SkFontMgr* fontManager)
 {
     static ScriptToFontMap scriptFontMap;
-    static ScriptToFontMap scriptMonospaceFontMap;
     static bool initialized = false;
     if (!initialized) {
-        initializeScriptFontMap(scriptFontMap, fontManager);
-        initializeScriptMonospaceFontMap(scriptMonospaceFontMap, fontManager);
+        initializeScriptFontMap(scriptFontMap);
         initialized = true;
     }
+
     if (script == USCRIPT_INVALID_CODE)
         return 0;
     ASSERT(script < USCRIPT_CODE_LIMIT);
-    if (generic == FontDescription::MonospaceFamily && scriptMonospaceFontMap[script])
-        return scriptMonospaceFontMap[script];
-    return scriptFontMap[script];
+    if (generic == FontDescription::MonospaceFamily) {
+        const UChar* monospaceFamily = findMonospaceFontForScript(script);
+        if (monospaceFamily)
+            return monospaceFamily;
+    }
+    if (scriptFontMap[script].candidateFamilyNames)
+        findFirstExistingCandidateFont(scriptFontMap[script], fontManager);
+    return scriptFontMap[script].familyName;
 }
 
 // FIXME:
 //  - Handle 'Inherited', 'Common' and 'Unknown'
 //    (see http://www.unicode.org/reports/tr24/#Usage_Model )
 //    For 'Inherited' and 'Common', perhaps we need to
 //    accept another parameter indicating the previous family
 //    and just return it.
 //  - All the characters (or characters up to the point a single
 //    font can cover) need to be taken into account
@@ skipping 62 matching lines @@
             family = L"lucida sans unicode";
         }
     }
 
     if (scriptChecked)
         *scriptChecked = script;
     return family;
 }
 
 } // namespace blink