Don't use default GDI SkFontMgr in getFontFamilyForScript

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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/fonts/win/FontFallbackWin.h"
 
+#include "SkFontMgr.h"
 #include "SkTypeface.h"
 #include "wtf/HashMap.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/WTFString.h"
 #include <limits>
 #include <unicode/locid.h>
 #include <unicode/uchar.h>
 
 namespace WebCore {
 
 namespace {
 
-static inline bool isFontPresent(const UChar* fontName)
+static inline bool isFontPresent(const UChar* fontName, SkFontMgr* fontManager)
 {
     String family = fontName;
-    RefPtr<SkTypeface> tf = adoptRef(SkTypeface::CreateFromName(family.utf8().data(), SkTypeface::kNormal));
+    RefPtr<SkTypeface> tf = adoptRef(fontManager->legacyCreateTypeface(family.utf8().data(), SkTypeface::kNormal));
     if (!tf)
         return false;
 
     SkTypeface::LocalizedStrings* actualFamilies = tf->createFamilyNameIterator();
     bool matchesRequestedFamily = false;
     SkTypeface::LocalizedString actualFamily;
     while (actualFamilies->next(&actualFamily)) {
         if (equalIgnoringCase(family, AtomicString::fromUTF8(actualFamily.fString.c_str()))) {
             matchesRequestedFamily = true;
             break;
         }
     }
     actualFamilies->unref();
 
     return matchesRequestedFamily;
 }
 
 // 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];
 
-void initializeScriptFontMap(ScriptToFontMap& scriptFontMap)
+void initializeScriptFontMap(ScriptToFontMap& scriptFontMap, SkFontMgr* fontManager)
 {
     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"},
@@ skipping 74 matching lines @@
 
     // 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)) {
+            if (isFontPresent(*familyPtr, fontManager)) {
                 scriptFontMap[script] = *familyPtr;
                 break;
             }
             ++familyPtr;
         }
     }
 
     // Initialize the locale-dependent mapping.
     // Since Chrome synchronizes the ICU default locale with its UI locale,
     // this ICU locale tells the current UI locale of Chrome.
@@ skipping 70 matching lines @@
 //  - If the default font for a script is not available,
 //    try some more fonts known to support it. Finally, we can
 //    use EnumFontFamilies or similar APIs to come up with a list of
 //    fonts supporting the script and cache the result.
 //  - 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)
+    FontDescription::GenericFamilyType generic,
+    SkFontMgr* fontManager)
 {
     static ScriptToFontMap scriptFontMap;
     static bool initialized = false;
     if (!initialized) {
-        initializeScriptFontMap(scriptFontMap);
+        initializeScriptFontMap(scriptFontMap, fontManager);
         initialized = true;
     }
     if (script == USCRIPT_INVALID_CODE)
         return 0;
     ASSERT(script < USCRIPT_CODE_LIMIT);
     return scriptFontMap[script];
 }
 
 // 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
 const UChar* getFallbackFamily(UChar32 character,
     FontDescription::GenericFamilyType generic,
-    UScriptCode* scriptChecked)
+    UScriptCode* scriptChecked,
+    SkFontMgr* fontManager)
 {
     ASSERT(character);
     UScriptCode script = getScript(character);
 
     // For the full-width ASCII characters (U+FF00 - U+FF5E), use the font for
     // Han (determined in a locale-dependent way above). Full-width ASCII
     // characters are rather widely used in Japanese and Chinese documents and
     // they're fully covered by Chinese, Japanese and Korean fonts.
     if (0xFF00 < character && character < 0xFF5F)
         script = USCRIPT_HAN;
 
     if (script == USCRIPT_COMMON)
         script = getScriptBasedOnUnicodeBlock(character);
 
-    const UChar* family = getFontFamilyForScript(script, generic);
+    const UChar* family = getFontFamilyForScript(script, generic, fontManager);
     // Another lame work-around to cover non-BMP characters.
     // If the font family for script is not found or the character is
     // not in BMP (> U+FFFF), we resort to the hard-coded list of
     // fallback fonts for now.
     if (!family || character > 0xFFFF) {
         int plane = character >> 16;
         switch (plane) {
         case 1:
             family = L"code2001";
             break;
@@ skipping 11 matching lines @@
         default:
             family = L"lucida sans unicode";
         }
     }
 
     if (scriptChecked)
         *scriptChecked = script;
     return family;
 }
 
-
-const UChar* getFallbackFamilyForFirstNonCommonCharacter(const UChar* characters,
-    int length,
-    FontDescription::GenericFamilyType generic)
-{
-    ASSERT(characters && characters[0] && length > 0);
-    UScriptCode script = USCRIPT_COMMON;
-
-    // Sometimes characters common to script (e.g. space) is at
-    // the beginning of a string so that we need to skip them
-    // to get a font required to render the string.
-    int i = 0;
-    UChar32 ucs4 = 0;
-    while (i < length && script == USCRIPT_COMMON) {
-        U16_NEXT(characters, i, length, ucs4);
-        script = getScript(ucs4);
-    }
-
-    const UChar* family = getFallbackFamily(ucs4, generic, 0);
-
-    return family;
-}
-
 } // namespace WebCore