Change the system font fallback to take lang attributes into account on Windows

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 24 matching lines @@
 #include "SkTypeface.h"
 #include "wtf/HashMap.h"
 #include "wtf/StringExtras.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/WTFString.h"
 #include <limits>
 #include <unicode/uchar.h>
 
 namespace blink {
 
+static bool isUnambiguousUnifiedHanScript(UScriptCode script)
+{
+    // localeToScriptCodeForFontSelection() does not return these values.
+    ASSERT(script != USCRIPT_HIRAGANA && script != USCRIPT_KATAKANA);
+    return script == USCRIPT_KATAKANA_OR_HIRAGANA
+        || script == USCRIPT_SIMPLIFIED_HAN
+        || script == USCRIPT_TRADITIONAL_HAN
+        || script == USCRIPT_HANGUL;
+}
+
+static UScriptCode scriptCodeForUnifiedHanFromSubtag(const String& subtag)
+{
+    struct SubtagScript {
+        const char* subtag;
+        UScriptCode script;
+    };
+
+    static const SubtagScript subtagScriptList[] = {
+        { "cn", USCRIPT_SIMPLIFIED_HAN },
+        { "hans", USCRIPT_SIMPLIFIED_HAN },
+        { "hant", USCRIPT_TRADITIONAL_HAN },
+        { "hk", USCRIPT_TRADITIONAL_HAN },
+        { "jp", USCRIPT_HIRAGANA },
+        { "kr", USCRIPT_HANGUL },
+        { "tw", USCRIPT_TRADITIONAL_HAN },
+    };
+
+    typedef HashMap<String, UScriptCode> SubtagScriptMap;
+    DEFINE_STATIC_LOCAL(SubtagScriptMap, subtagScriptMap, ());
+    if (subtagScriptMap.isEmpty()) {
+        for (size_t i = 0; i < WTF_ARRAY_LENGTH(subtagScriptList); ++i)
+            subtagScriptMap.set(subtagScriptList[i].subtag, subtagScriptList[i].script);
+    }
+
+    const auto& it = subtagScriptMap.find(subtag.lower());
+    return it != subtagScriptMap.end() ? it->value : USCRIPT_COMMON;
+}
+
+UScriptCode scriptCodeForUnifiedHanFromSubtags(const String& locale)
+{
+    // Some sites emit lang="en-JP" when English is set as the preferred
+    // language. Use script/region subtags of the content locale to pick the
+    // fallback font for unified Han ideographs.
+    for (size_t delimiter = locale.find('-'); delimiter != kNotFound; ) {
+        ++delimiter;
+        size_t end = locale.find('-', delimiter);
+        UScriptCode script = scriptCodeForUnifiedHanFromSubtag(
+            locale.substring(delimiter,
+                end == kNotFound ? UINT_MAX : end - delimiter));
+        if (script != USCRIPT_COMMON)
+            return script;
+        delimiter = end;
+    }
+
+    // Fallback to the UI locale.
+    return USCRIPT_HAN;
+}
+
 UScriptCode scriptCodeForUnifiedHanFromLocale(const icu::Locale& locale)
 {
     // ICU default locale may have country as an empty string or differently.
     // Avoid fullName comparisons for Japanese and Korean where language()
     // can safely disambiguate.
     if (strcasecmp(locale.getLanguage(), icu::Locale::getJapanese().getLanguage()) == 0)
         return USCRIPT_HIRAGANA;
     if (strcasecmp(locale.getLanguage(), icu::Locale::getKorean().getLanguage()) == 0)
         return USCRIPT_HANGUL;
 
-    const icu::Locale& traditionalChinese = icu::Locale::getTraditionalChinese();
-    if (strcasecmp(locale.getLanguage(), traditionalChinese.getLanguage()) == 0
-        && (strcasecmp(locale.getCountry(), traditionalChinese.getCountry()) == 0
-            || strcasecmp(locale.getCountry(), "HK") == 0
-            || strcasecmp(locale.getScript(), "Hant") == 0)) {
-        return USCRIPT_TRADITIONAL_HAN;
-    }
+    // Chinese and non-CJK languages may be able to determine from subtags.
+    UScriptCode script = scriptCodeForUnifiedHanFromSubtag(locale.getScript());
+    if (script != USCRIPT_COMMON)
+        return script;
+    script = scriptCodeForUnifiedHanFromSubtag(locale.getCountry());
+    if (script != USCRIPT_COMMON)
+        return script;
 
     // For other locales, use the simplified Chinese font for Han.
     return USCRIPT_SIMPLIFIED_HAN;
 }
 
 namespace {
 
 static inline bool isFontPresent(const UChar* fontName, SkFontMgr* fontManager)
 {
     String family = fontName;
@@ skipping 322 matching lines @@
 // 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 contentScript,
+    const AtomicString& contentLocale,
     UScriptCode* scriptChecked,
     SkFontMgr* fontManager)
 {
     ASSERT(character);
     ASSERT(fontManager);
     const UChar* family = getFontBasedOnUnicodeBlock(character, fontManager);
     if (family) {
         if (scriptChecked)
             *scriptChecked = USCRIPT_INVALID_CODE;
         return family;
     }
 
     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);
 
+    // For unified-Han scripts, try the lang attribute.
+    if (script == USCRIPT_HAN) {
+        if (isUnambiguousUnifiedHanScript(contentScript))
+            script = contentScript;
+        else
+            script = scriptCodeForUnifiedHanFromSubtags(contentLocale);
+    }
+
     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";
@@ skipping 13 matching lines @@
             family = L"lucida sans unicode";
         }
     }
 
     if (scriptChecked)
         *scriptChecked = script;
     return family;
 }
 
 } // namespace blink