Introduce typeface cache in blink::FontCache

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

 /*
  * Copyright (C) 2013 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 26 matching lines @@
 namespace blink {
 
 #if !OS(ANDROID)
 const unsigned cMaxInactiveFontData = 250;
 const unsigned cTargetInactiveFontData = 200;
 #else
 const unsigned cMaxInactiveFontData = 225;
 const unsigned cTargetInactiveFontData = 200;
 #endif
 
-PassRefPtr<SimpleFontData> FontDataCache::get(const FontPlatformData* platformData, ShouldRetain shouldRetain)
+PassRefPtr<SimpleFontData> FontDataCache::get(const FontPlatformData* platformData, float fontSize, ShouldRetain shouldRetain)
 {
     if (!platformData)
         return nullptr;
 
     // TODO: crbug.com/446376 - This should not happen, but we currently
     // do not have a reproduction for the crash that an empty typeface()
     // causes downstream from here.
     if (!platformData->typeface()) {
         DLOG(ERROR) << "Empty typeface() in FontPlatformData when accessing FontDataCache.";
         return nullptr;
     }
 
-    Cache::iterator result = m_cache.find(*platformData);
-    if (result == m_cache.end()) {
-        std::pair<RefPtr<SimpleFontData>, unsigned> newValue(SimpleFontData::create(*platformData), shouldRetain == Retain ? 1 : 0);
-        m_cache.set(*platformData, newValue);
-        if (shouldRetain == DoNotRetain)
-            m_inactiveFontData.add(newValue.first);
-        return newValue.first.release();
-    }
+    InnerCache* innerCache = &m_cache.add(*platformData, InnerCache()).storedValue->value;
+    InnerCache::AddResult addResult = innerCache->add(fontSize, std::make_pair(nullptr, 0));
+    auto* value = &addResult.storedValue->value;
 
-    if (!result.get()->value.second) {
-        ASSERT(m_inactiveFontData.contains(result.get()->value.first));
-        m_inactiveFontData.remove(result.get()->value.first);
+    if (addResult.isNewEntry) {
+        value->first = SimpleFontData::create(*platformData, fontSize, nullptr, false);
+    } else if (!value->second) {
+        ASSERT(m_inactiveFontData.contains(value->first));
+        m_inactiveFontData.remove(value->first);
     }
 
     if (shouldRetain == Retain) {
-        result.get()->value.second++;
-    } else if (!result.get()->value.second) {
+        value->second++;
+    } else if (!value->second) {
         // If shouldRetain is DoNotRetain and count is 0, we want to remove the fontData from
         // m_inactiveFontData (above) and re-add here to update LRU position.
-        m_inactiveFontData.add(result.get()->value.first);
+        m_inactiveFontData.add(value->first);
     }
 
-    return result.get()->value.first;
+    return value->first;
 }
 
 bool FontDataCache::contains(const FontPlatformData* fontPlatformData) const
 {
     return m_cache.contains(*fontPlatformData);
 }
 
 void FontDataCache::release(const SimpleFontData* fontData)
 {
     ASSERT(!fontData->isCustomFont());
 
-    Cache::iterator it = m_cache.find(fontData->platformData());
-    ASSERT(it != m_cache.end());
-    if (it == m_cache.end())
+    Cache::iterator outer = m_cache.find(fontData->platformData());
+    ASSERT(outer != m_cache.end());
+    if (outer == m_cache.end())
         return;
 
-    ASSERT(it->value.second);
-    if (!--it->value.second)
-        m_inactiveFontData.add(it->value.first);
+    InnerCache::iterator inner = outer->value.find(fontData->size());
+    if (inner == outer->value.end())
+        return;
+
+    ASSERT(inner->value.second);
+    if (!--inner->value.second)
+        m_inactiveFontData.add(inner->value.first);
 }
 
 void FontDataCache::markAllVerticalData()
 {
-    Cache::iterator end = m_cache.end();
-    for (Cache::iterator fontData = m_cache.begin(); fontData != end; ++fontData) {
-        OpenTypeVerticalData* verticalData = const_cast<OpenTypeVerticalData*>(fontData->value.first->verticalData());
-        if (verticalData)
-            verticalData->setInFontCache(true);
+    for (auto& inner : m_cache) {
+        for (auto& fontData : inner.value) {
+            OpenTypeVerticalData* verticalData = const_cast<OpenTypeVerticalData*>(fontData.value.first->verticalData());
+            if (verticalData)
+                verticalData->setInFontCache(true);
+        }
     }
 }
 
 bool FontDataCache::purge(PurgeSeverity PurgeSeverity)
 {
     if (PurgeSeverity == ForcePurge)
         return purgeLeastRecentlyUsed(INT_MAX);
 
     if (m_inactiveFontData.size() > cMaxInactiveFontData)
         return purgeLeastRecentlyUsed(m_inactiveFontData.size() - cTargetInactiveFontData);
@@ skipping 30 matching lines @@
     bool didWork = fontDataToDelete.size();
 
     fontDataToDelete.clear();
 
     isPurging = false;
 
     return didWork;
 }
 
 } // namespace blink