blink fonts: Load Android SkFontMgr on Linux.

third_party/WebKit/Source/platform/fonts/skia/FontCacheSkia.cpp

 /*
  * Copyright (c) 2006, 2007, 2008, 2009 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 "SkFontMgr.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
+#include "platform/Language.h"
 #include "platform/fonts/AlternateFontFamily.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/fonts/FontFaceCreationParams.h"
 #include "platform/fonts/SimpleFontData.h"
 #include "public/platform/Platform.h"
 #include "public/platform/linux/WebSandboxSupport.h"
 #include "wtf/Assertions.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/CString.h"
@@ skipping 36 matching lines @@
     SkAutoTUnref<SkFontConfigInterface> fci(SkFontConfigInterface::RefGlobal());
     SkFontConfigInterface::FontIdentity fontIdentity;
     fontIdentity.fID = fontconfigInterfaceId;
     fontIdentity.fTTCIndex = ttcIndex;
     return adoptRef(fci->createTypeface(fontIdentity));
 }
 #endif
 
 namespace blink {
 
+// SkFontMgr requires script-based locale names, like "zh-Hant" and "zh-Hans",
+// instead of "zh-CN" and "zh-TW".
+static CString toSkFontMgrLocale(const String& locale)
+{
+    if (!locale.startsWith("zh", TextCaseInsensitive))
+        return locale.ascii();
+
+    switch (localeToScriptCodeForFontSelection(locale)) {
+    case USCRIPT_SIMPLIFIED_HAN:
+        return "zh-Hans";
+    case USCRIPT_TRADITIONAL_HAN:
+        return "zh-Hant";
+    default:
+        return locale.ascii();
+    }
+}
+
+#if OS(ANDROID) || OS(LINUX)

[eae, 2016/02/17 23:52:10]

Do we need this on Android? The only caller I can find is witihin a NOT(ANDROID)
&& LINUX block.

[Khushal, 2016/02/18 00:46:37]

Android calls it from FontCacheAndroid. The implementation for
FontCache::fallbackFontForCharacter for android is defined there.

+AtomicString FontCache::getFamilyNameForCharacter(SkFontMgr* fm, UChar32 c, const FontDescription& fontDescription)
+{
+    ASSERT(fm);
+    const char* bcp47Locales[2];
+    int localeCount = 0;
+    CString defaultLocale = toSkFontMgrLocale(defaultLanguage());
+    bcp47Locales[localeCount++] = defaultLocale.data();
+    CString fontLocale;
+    if (!fontDescription.locale().isEmpty()) {
+        fontLocale = toSkFontMgrLocale(fontDescription.locale());
+        bcp47Locales[localeCount++] = fontLocale.data();
+    }
+    RefPtr<SkTypeface> typeface = adoptRef(fm->matchFamilyStyleCharacter(0, SkFontStyle(), bcp47Locales, localeCount, c));
+    if (!typeface)
+        return emptyAtom;
+
+    SkString skiaFamilyName;
+    typeface->getFamilyName(&skiaFamilyName);
+    return skiaFamilyName.c_str();
+}
+#endif
+
 void FontCache::platformInit()
 {
 }
 
 PassRefPtr<SimpleFontData> FontCache::fallbackOnStandardFontStyle(
     const FontDescription& fontDescription, UChar32 character)
 {
     FontDescription substituteDescription(fontDescription);
     substituteDescription.setStyle(FontStyleNormal);
     substituteDescription.setWeight(FontWeightNormal);
 
     FontFaceCreationParams creationParams(substituteDescription.family().family());
     FontPlatformData* substitutePlatformData = getFontPlatformData(substituteDescription, creationParams);
     if (substitutePlatformData && substitutePlatformData->fontContainsCharacter(character)) {
         FontPlatformData platformData = FontPlatformData(*substitutePlatformData);
         platformData.setSyntheticBold(fontDescription.weight() >= FontWeight600);
         platformData.setSyntheticItalic(fontDescription.style() == FontStyleItalic || fontDescription.style() == FontStyleOblique);
         return fontDataFromFontPlatformData(&platformData, DoNotRetain);
     }
 
     return nullptr;
 }
 
 #if !OS(WIN) && !OS(ANDROID)
 PassRefPtr<SimpleFontData> FontCache::fallbackFontForCharacter(const FontDescription& fontDescription, UChar32 c, const SimpleFontData*)
 {
+#if OS(LINUX)
+    // Try the SkFontMgr first if we have one.
+    if (m_fontManager) {

[eae, 2016/02/17 23:52:10]

When would we not have a font manager? On windows we have this check (for now)
as we need to handle the GDI case where no font manager is available.

[Khushal, 2016/02/18 00:46:37]

On linux the default font manager is backed by an implementation of the
FontConfigInterface. We use SandboxSupport to query system fonts using IPC when
looking for fallback fonts. The response returned includes an
FontConfigInterface(fci) index which is understood by this font manager.

The m_fontManager check is for the case where the embedder needs to override the
default behaviour and ask blink to use a custom provided font manager instead.

Right now we need this for the case where we want linux to emulate android fonts
and need to pass in the android SkFontMgr. The override is done based on a
content switch in zygote_main_linux.cc.

+        AtomicString familyName = getFamilyNameForCharacter(m_fontManager.get(), c, fontDescription);
+        if (familyName.isEmpty())
+            return getLastResortFallbackFont(fontDescription, DoNotRetain);
+        return fontDataFromFontPlatformData(getFontPlatformData(fontDescription, FontFaceCreationParams(familyName)), DoNotRetain);
+    }
+#endif
+
     // First try the specified font with standard style & weight.
     if (fontDescription.style() == FontStyleItalic
         || fontDescription.weight() >= FontWeight600) {
         RefPtr<SimpleFontData> fontData = fallbackOnStandardFontStyle(
             fontDescription, c);
         if (fontData)
             return fontData;
     }
 
     FontCache::PlatformFallbackFont fallbackFont;
@@ skipping 144 matching lines @@
     }
 
     if (m_fontManager) {
         return adoptRef(useDirectWrite()
             ? m_fontManager->matchFamilyStyle(name.data(), fontStyle(fontDescription))
             : m_fontManager->legacyCreateTypeface(name.data(), style)
             );
     }
 #endif
 
+#if OS(LINUX)
+    if (m_fontManager)
+        return adoptRef(m_fontManager->legacyCreateTypeface(name.data(), style));
+#endif
+
     // FIXME: Use m_fontManager, SkFontStyle and matchFamilyStyle instead of
     // CreateFromName on all platforms.
     return adoptRef(SkTypeface::CreateFromName(name.data(), static_cast<SkTypeface::Style>(style)));
 }
 
 #if !OS(WIN)
 PassOwnPtr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription,
     const FontFaceCreationParams& creationParams, float fontSize)
 {
     CString name;
     RefPtr<SkTypeface> tf(createTypeface(fontDescription, creationParams, name));
     if (!tf)
         return nullptr;
 
     return adoptPtr(new FontPlatformData(tf,
         name.data(),
         fontSize,
         (fontDescription.weight() >= FontWeight600 && !tf->isBold()) || fontDescription.isSyntheticBold(),
         ((fontDescription.style() == FontStyleItalic || fontDescription.style() == FontStyleOblique) && !tf->isItalic()) || fontDescription.isSyntheticItalic(),
         fontDescription.orientation(),
         fontDescription.useSubpixelPositioning()));
 }
 #endif // !OS(WIN)
 
 } // namespace blink