Fix font family based fallback font selection

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 59 matching lines @@
 bool FontCache::s_useSubpixelPositioning = false;
 #endif // OS(WIN)
 
 FontCache* FontCache::fontCache()
 {
     DEFINE_STATIC_LOCAL(FontCache, globalFontCache, ());
     return &globalFontCache;
 }
 
 FontPlatformData* FontCache::getFontPlatformData(const FontDescription& fontDescription,
-    const AtomicString& passedFamilyName, bool checkingAlternateName)
+    const FontFaceCreationParams& creationParams, bool checkingAlternateName)
 {
-#if OS(WIN) && ENABLE(OPENTYPE_VERTICAL)
-    // Leading "@" in the font name enables Windows vertical flow flag for the font.
-    // Because we do vertical flow by ourselves, we don't want to use the Windows feature.
-    // IE disregards "@" regardless of the orientatoin, so we follow the behavior.
-    const AtomicString& familyName = (passedFamilyName.isEmpty() || passedFamilyName[0] != '@') ?
-        passedFamilyName : AtomicString(passedFamilyName.impl()->substring(1));
-#else
-    const AtomicString& familyName = passedFamilyName;
-#endif
-
     if (!gFontPlatformDataCache) {
         gFontPlatformDataCache = new FontPlatformDataCache;
         platformInit();
     }
 
-    FontCacheKey key = fontDescription.cacheKey(familyName);
+    FontCacheKey key = fontDescription.cacheKey(creationParams);
     FontPlatformData* result = 0;
     bool foundResult;
     FontPlatformDataCache::iterator it = gFontPlatformDataCache->find(key);
     if (it == gFontPlatformDataCache->end()) {
-        result = createFontPlatformData(fontDescription, familyName, fontDescription.effectiveFontSize());
+        result = createFontPlatformData(fontDescription, creationParams, fontDescription.effectiveFontSize());
         gFontPlatformDataCache->set(key, adoptPtr(result));
         foundResult = result;
     } else {
         result = it->value.get();
         foundResult = true;
     }
 
-    if (!foundResult && !checkingAlternateName) {
+    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(familyName);
-        if (!alternateName.isEmpty())
-            result = getFontPlatformData(fontDescription, alternateName, true);
+        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.
     }
 
     return result;
 }
 
 #if ENABLE(OPENTYPE_VERTICAL)
 typedef HashMap<FontCache::FontFileKey, RefPtr<OpenTypeVerticalData>, WTF::IntHash<FontCache::FontFileKey>, WTF::UnsignedWithZeroKeyHashTraits<FontCache::FontFileKey> > FontVerticalDataCache;
 
@@ skipping 15 matching lines @@
         verticalData.clear();
     fontVerticalDataCache.set(key, verticalData);
     return verticalData;
 }
 #endif
 
 static FontDataCache* gFontDataCache = 0;
 
 PassRefPtr<SimpleFontData> FontCache::getFontData(const FontDescription& fontDescription, const AtomicString& family, bool checkingAlternateName, ShouldRetain shouldRetain)
 {
-    if (FontPlatformData* platformData = getFontPlatformData(fontDescription, adjustFamilyNameToAvoidUnsupportedFonts(family), checkingAlternateName))
+    if (FontPlatformData* platformData = getFontPlatformData(fontDescription, FontFaceCreationParams(adjustFamilyNameToAvoidUnsupportedFonts(family)), checkingAlternateName))
         return fontDataFromFontPlatformData(platformData, shouldRetain);
 
     return nullptr;
 }
 
 PassRefPtr<SimpleFontData> FontCache::fontDataFromFontPlatformData(const FontPlatformData* platformData, ShouldRetain shouldRetain)
 {
     if (!gFontDataCache)
         gFontDataCache = new FontDataCache;
 
 #if ASSERT_ENABLED
     if (shouldRetain == DoNotRetain)
         ASSERT(m_purgePreventCount);
 #endif
 
     return gFontDataCache->get(platformData, shouldRetain);
 }
 
 bool FontCache::isPlatformFontAvailable(const FontDescription& fontDescription, const AtomicString& family)
 {
     bool checkingAlternateName = true;
-    return getFontPlatformData(fontDescription, adjustFamilyNameToAvoidUnsupportedFonts(family), checkingAlternateName);
+    return getFontPlatformData(fontDescription, FontFaceCreationParams(adjustFamilyNameToAvoidUnsupportedFonts(family)), checkingAlternateName);
 }
 
 SimpleFontData* FontCache::getNonRetainedLastResortFallbackFont(const FontDescription& fontDescription)
 {
     return getLastResortFallbackFont(fontDescription, DoNotRetain).leakRef();
 }
 
 void FontCache::releaseFontData(const SimpleFontData* fontData)
 {
     ASSERT(gFontDataCache);
@@ skipping 111 matching lines @@
         clients.append(*it);
 
     ASSERT(numClients == clients.size());
     for (size_t i = 0; i < numClients; ++i)
         clients[i]->fontCacheInvalidated();
 
     purge(ForcePurge);
 }
 
 } // namespace WebCore