Avoid checking family name in getLastResortFallbackFont() on Windows

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 92 matching lines @@
 FontPlatformData* FontCache::systemFontPlatformData(
     const FontDescription& fontDescription) {
   const AtomicString& family = FontCache::systemFontFamily();
 #if OS(LINUX)
   if (family.isEmpty() || family == FontFamilyNames::system_ui)
     return nullptr;
 #else
   DCHECK(!family.isEmpty() && family != FontFamilyNames::system_ui);
 #endif
   return getFontPlatformData(fontDescription, FontFaceCreationParams(family),
-                             true);
+                             AlternateFontName::NoAlternate);
 }
 #endif
 
 FontPlatformData* FontCache::getFontPlatformData(
     const FontDescription& fontDescription,
     const FontFaceCreationParams& creationParams,
-    bool checkingAlternateName) {
+    AlternateFontName alternateFontName) {
   if (!gFontPlatformDataCache) {
     gFontPlatformDataCache = new FontPlatformDataCache;
     platformInit();
   }
 
 #if !OS(MACOSX)
   if (creationParams.creationType() == CreateFontByFamily &&
       creationParams.family() == FontFamilyNames::system_ui) {
     return systemFontPlatformData(fontDescription);
   }
@@ skipping 20 matching lines @@
              .storedValue->value;
     bool wasEmpty = sizedFonts->isEmpty();
 
     // Take a different size instance of the same font before adding an entry to
     // |sizedFont|.
     FontPlatformData* anotherSize =
         wasEmpty ? nullptr : sizedFonts->begin()->value.get();
     auto addResult = sizedFonts->insert(roundedSize, nullptr);
     std::unique_ptr<FontPlatformData>* found = &addResult.storedValue->value;
     if (addResult.isNewEntry) {
-      if (wasEmpty)
-        *found = createFontPlatformData(fontDescription, creationParams, size);
-      else if (anotherSize)
+      if (wasEmpty) {
+        *found = createFontPlatformData(fontDescription, creationParams, size,
+                                        alternateFontName);
+      } else if (anotherSize) {
         *found = scaleFontPlatformData(*anotherSize, fontDescription,
                                        creationParams, size);
+      }
     }
 
     result = found->get();
     foundResult = result || !addResult.isNewEntry;
   }
 
-  if (!foundResult && !checkingAlternateName &&
+  if (!foundResult && alternateFontName != AlternateFontName::NoAlternate &&
       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);
+      result = getFontPlatformData(fontDescription, createByAlternateFamily,
+                                   AlternateFontName::NoAlternate);
     }
     if (result) {
       // Cache the result under the old name.
       auto adding =
           &gFontPlatformDataCache->insert(key, SizedFontPlatformDataSet())
                .storedValue->value;
       adding->set(roundedSize, WTF::wrapUnique(new FontPlatformData(*result)));
     }
   }
 
@@ skipping 65 matching lines @@
 void FontCache::acceptLanguagesChanged(const String& acceptLanguages) {
   AcceptLanguagesResolver::acceptLanguagesChanged(acceptLanguages);
   fontCache()->invalidateShapeCache();
 }
 
 static FontDataCache* gFontDataCache = 0;
 
 PassRefPtr<SimpleFontData> FontCache::getFontData(
     const FontDescription& fontDescription,
     const AtomicString& family,
-    bool checkingAlternateName,
+    AlternateFontName alternameFontName,
     ShouldRetain shouldRetain) {
   if (FontPlatformData* platformData = getFontPlatformData(
           fontDescription, FontFaceCreationParams(
                                adjustFamilyNameToAvoidUnsupportedFonts(family)),
-          checkingAlternateName)) {
+          alternameFontName)) {
     return fontDataFromFontPlatformData(
         platformData, shouldRetain, fontDescription.subpixelAscentDescent());
   }
 
   return nullptr;
 }
 
 PassRefPtr<SimpleFontData> FontCache::fontDataFromFontPlatformData(
     const FontPlatformData* platformData,
     ShouldRetain shouldRetain,
     bool subpixelAscentDescent) {
   if (!gFontDataCache)
     gFontDataCache = new FontDataCache;
 
 #if DCHECK_IS_ON()
   if (shouldRetain == DoNotRetain)
     ASSERT(m_purgePreventCount);
 #endif
 
   return gFontDataCache->get(platformData, shouldRetain, subpixelAscentDescent);
 }
 
 bool FontCache::isPlatformFontAvailable(const FontDescription& fontDescription,
                                         const AtomicString& family) {
-  bool checkingAlternateName = true;
   return getFontPlatformData(
       fontDescription,
       FontFaceCreationParams(adjustFamilyNameToAvoidUnsupportedFonts(family)),
-      checkingAlternateName);
+      AlternateFontName::NoAlternate);
 }
 
 String FontCache::firstAvailableOrFirst(const String& families) {
   // The conversions involve at least two string copies, and more if non-ASCII.
   // For now we prefer shared code over the cost because a) inputs are
   // only from grd/xtb and all ASCII, and b) at most only a few times per
   // setting change/script.
   return String::fromUTF8(
       gfx::FontList::FirstAvailableOrFirst(families.utf8().data()).c_str());
 }
@@ skipping 169 matching lines @@
   for (iter = gFallbackListShaperCache->begin();
        iter != gFallbackListShaperCache->end(); ++iter) {
     shapeResultCacheSize += iter->value->byteSize();
   }
   dump->AddScalar("size", "bytes", shapeResultCacheSize);
   memoryDump->AddSuballocation(dump->guid(),
                                WTF::Partitions::kAllocatedObjectPoolName);
 }
 
 }  // namespace blink