Introduce FontCache content scaling

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

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  *
  * 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.
@@ skipping 49 matching lines @@
 namespace blink {
 
 #if !OS(WIN) && !OS(LINUX)
 FontCache::FontCache()
     : m_purgePreventCount(0)
     , m_fontManager(nullptr)
 {
 }
 #endif // !OS(WIN) && !OS(LINUX)
 
-typedef HashMap<FontCacheKey, OwnPtr<FontPlatformData>, FontCacheKeyHash, FontCacheKeyTraits> FontPlatformDataCache;
+typedef HashMap<unsigned, OwnPtr<FontPlatformData>> SizedFontPlatformDataSet;
+typedef HashMap<FontCacheKey, SizedFontPlatformDataSet, FontCacheKeyHash, FontCacheKeyTraits> FontPlatformDataCache;

[drott, 2016/05/18 07:22:48]

Do we need to keep the rescaled sizes in a cache as well? It seems like the
scale operation is quite cheap, mostly copying the FontPlatformData object. I
wonder whether we can simplify this CL by not keeping track of the rescaled
versions, and keeping only the "one size fits all" FontPlatformData in the
cache.

[tzik, 2016/05/18 07:26:53]

It's not so cheap actually on Linux. The scaling ctor of FontPlatformData calls
FontRenderStyle::querySystem, and it issues another synchronous IPC, which is as
expensive as the font query itself.

 typedef HashMap<FallbackListCompositeKey, OwnPtr<ShapeCache>, FallbackListCompositeKeyHash, FallbackListCompositeKeyTraits> FallbackListShaperCache;
 
 static FontPlatformDataCache* gFontPlatformDataCache = nullptr;
 static FallbackListShaperCache* gFallbackListShaperCache = nullptr;
 
 SkFontMgr* FontCache::s_fontManager = nullptr;
 
 #if OS(WIN)
 bool FontCache::s_antialiasedTextEnabled = false;
 bool FontCache::s_lcdTextEnabled = false;
 float FontCache::s_deviceScaleFactor = 1.0;
 bool FontCache::s_useSkiaFontFallback = false;
 #endif // OS(WIN)
 
 FontCache* FontCache::fontCache()
 {
     DEFINE_STATIC_LOCAL(FontCache, globalFontCache, ());
     return &globalFontCache;
 }
 
 FontPlatformData* FontCache::getFontPlatformData(const FontDescription& fontDescription,
     const FontFaceCreationParams& creationParams, bool checkingAlternateName)
 {
     if (!gFontPlatformDataCache) {
         gFontPlatformDataCache = new FontPlatformDataCache;
         platformInit();
     }
 
+    float size = fontDescription.effectiveFontSize();
     FontCacheKey key = fontDescription.cacheKey(creationParams);
+
+    // Remove the font size from the cache key, and handle the font size separately in the inner
+    // HashMap. So that different size of FontPlatformData can share underlying SkTypeface.
+    key.clearFontSize();
+
     FontPlatformData* result;
     bool foundResult;
+
     {
         // addResult's scope must end before we recurse for alternate family names below,
         // to avoid trigering its dtor hash-changed asserts.
-        auto addResult = gFontPlatformDataCache->add(key, nullptr);
-        if (addResult.isNewEntry)
-            addResult.storedValue->value = createFontPlatformData(fontDescription, creationParams, fontDescription.effectiveFontSize());
+        SizedFontPlatformDataSet* sizedFonts = &gFontPlatformDataCache->add(key, SizedFontPlatformDataSet()).storedValue->value;
+        bool wasEmpty = sizedFonts->isEmpty();
 
-        result = addResult.storedValue->value.get();
+        // Take a different size instance of the same font before adding an entry to |sizedFont|.
+        FontPlatformData* anotherSize = wasEmpty ? nullptr : sizedFonts->begin()->value.get();
+
+        // Use -2 instead of 0 for the default size. We can not use 0 or -1 for HashMap key, since
+        // they are reserved for empty and deleted value.
+        unsigned roundedSize = (unsigned)size ? size * FontCacheKey::precisionMultiplier() : -2;
+        auto addResult = sizedFonts->add(roundedSize, nullptr);
+        OwnPtr<FontPlatformData>* found = &addResult.storedValue->value;
+        if (addResult.isNewEntry) {
+            if (wasEmpty)
+                *found = createFontPlatformData(fontDescription, creationParams, size);
+            else if (anotherSize)
+                *found = scaleFontPlatformData(*anotherSize, fontDescription, creationParams, size);
+        }
+
+        result = found->get();
         foundResult = result || !addResult.isNewEntry;
     }
 
     if (!foundResult && !checkingAlternateName && creationParams.creationType() == CreateFontByFamily) {
         // We were unable to find a font. We have a small set of fonts that we alias to other names,
         // e.g., Arial/Helvetica, Courier/Courier New, etc. Try looking up the font under the aliased name.
         const AtomicString& alternateName = alternateFamilyName(creationParams.family());
         if (!alternateName.isEmpty()) {
             FontFaceCreationParams createByAlternateFamily(alternateName);
             result = getFontPlatformData(fontDescription, createByAlternateFamily, true);
         }
-        if (result)
-            gFontPlatformDataCache->set(key, adoptPtr(new FontPlatformData(*result))); // Cache the result under the old name.
+        if (result) {
+            // Cache the result under the old name.
+            auto adding = &gFontPlatformDataCache->add(key, SizedFontPlatformDataSet()).storedValue->value;
+            adding->set(size, adoptPtr(new FontPlatformData(*result)));
+        }
     }
 
     return result;
 }
 
+PassOwnPtr<FontPlatformData> FontCache::scaleFontPlatformData(const FontPlatformData& fontPlatformData, const FontDescription& fontDescription, const FontFaceCreationParams& creationParams, float fontSize)
+{
+#if OS(MACOSX)
+    return createFontPlatformData(fontDescription, creationParams, fontSize);
+#else
+    return adoptPtr(new FontPlatformData(fontPlatformData, fontSize));
+#endif
+}
+
 ShapeCache* FontCache::getShapeCache(const FallbackListCompositeKey& key)
 {
     if (!gFallbackListShaperCache)
         gFallbackListShaperCache = new FallbackListShaperCache;
 
     FallbackListShaperCache::iterator it = gFallbackListShaperCache->find(key);
     ShapeCache* result = nullptr;
     if (it == gFallbackListShaperCache->end()) {
         result = new ShapeCache();
         gFallbackListShaperCache->set(key, adoptPtr(result));
@@ skipping 81 matching lines @@
     gFontDataCache->release(fontData);
 }
 
 static inline void purgePlatformFontDataCache()
 {
     if (!gFontPlatformDataCache)
         return;
 
     Vector<FontCacheKey> keysToRemove;
     keysToRemove.reserveInitialCapacity(gFontPlatformDataCache->size());
-    FontPlatformDataCache::iterator platformDataEnd = gFontPlatformDataCache->end();
-    for (FontPlatformDataCache::iterator platformData = gFontPlatformDataCache->begin(); platformData != platformDataEnd; ++platformData) {
-        if (platformData->value && !gFontDataCache->contains(platformData->value.get()))
-            keysToRemove.append(platformData->key);
+    for (auto& sizedFonts : *gFontPlatformDataCache) {
+        Vector<float> sizesToRemove;
+        sizesToRemove.reserveInitialCapacity(sizedFonts.value.size());
+        for (const auto& platformData : sizedFonts.value) {
+            if (platformData.value && !gFontDataCache->contains(platformData.value.get()))
+                sizesToRemove.append(platformData.key);
+        }
+        sizedFonts.value.removeAll(sizesToRemove);
+        if (sizedFonts.value.isEmpty())
+            keysToRemove.append(sizedFonts.key);
     }
     gFontPlatformDataCache->removeAll(keysToRemove);
 }
 
 static inline void purgeFontVerticalDataCache()
 {
     FontVerticalDataCache& fontVerticalDataCache = fontVerticalDataCacheInstance();
     if (!fontVerticalDataCache.isEmpty()) {
         // Mark & sweep unused verticalData
         FontVerticalDataCache::iterator verticalDataEnd = fontVerticalDataCache.end();
@@ skipping 139 matching lines @@
     case USCRIPT_SIMPLIFIED_HAN:
         return "zh-Hans";
     case USCRIPT_TRADITIONAL_HAN:
         return "zh-Hant";
     default:
         return locale.ascii();
     }
 }
 
 } // namespace blink