Use FontFallbackPriority Fonts in FontFallbackIterator

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/fonts/FontFallbackIterator.h"
 
 #include "platform/Logging.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/fonts/FontFallbackList.h"
 #include "platform/fonts/SegmentedFontData.h"
 #include "platform/fonts/SimpleFontData.h"
 
 namespace blink {
 
-PassRefPtr<FontFallbackIterator> FontFallbackIterator::create(const FontDescription& description, PassRefPtr<FontFallbackList> fallbackList)
+PassRefPtr<FontFallbackIterator> FontFallbackIterator::create(
+    const FontDescription& description,
+    PassRefPtr<FontFallbackList> fallbackList,
+    FontFallbackPriority fontFallbackPriority)
 {
-    return adoptRef(new FontFallbackIterator(description, fallbackList));
+    return adoptRef(new FontFallbackIterator(
+        description, fallbackList, fontFallbackPriority));
 }
 
-FontFallbackIterator::FontFallbackIterator(const FontDescription& description, PassRefPtr<FontFallbackList> fallbackList)
+FontFallbackIterator::FontFallbackIterator(const FontDescription& description,
+    PassRefPtr<FontFallbackList> fallbackList,
+    FontFallbackPriority fontFallbackPriority)
     : m_fontDescription(description)
     , m_fontFallbackList(fallbackList)
     , m_currentFontDataIndex(0)
     , m_segmentedIndex(0)
-    , m_fallbackStage(FontGroupFonts)
+    , m_fallbackStage(
+// Due to crbug.com/322658 we cannot reliably select Emoji fonts on Android at
+// the moment. Disabling this functionality on Android to avoid reports of
+// unreliable behavior until this issue is solved.
+#if !OS(ANDROID)
+    // Currently we have to push the Emoji font to the top of the list

[drott, 2016/02/05 13:29:18]

Looks like the windows failures indicate there is still some work required.
Overriding the font stack for symbols and math leads to unexpected results. So
it's better to address this issue first, then inserting the emoji and symbol
fonts before the system fonts in the fallback chain, but not before the CSS font
group fonts.

+    // due to https://github.com/behdad/harfbuzz/issues/217
+    isNonTextFallbackPriority(fontFallbackPriority)
+    ? FallbackPriorityFonts

[eae, 2016/02/17 18:55:17]

Indent line 40 and 41 one more level.

isNonTextFallbackPriority(fontFallbackPriority)
  ? FallbackPriorityFonts
  : FontGroupFonts

+    : FontGroupFonts
+#else
+    FontGroupFonts
+#endif
+    )
+    , m_fontFallbackPriority(fontFallbackPriority)
+    , m_symbolsFontCursor(0)
 {
 }
 
 bool FontFallbackIterator::needsHintList() const
 {
     if (m_fallbackStage != FontGroupFonts && m_fallbackStage != SegmentedFace) {
         return false;
     }
 
     const FontData* fontData = m_fontFallbackList->fontDataAt(m_fontDescription, m_currentFontDataIndex);
@@ skipping 27 matching lines @@
         return;
 
     selector->willUseRange(m_fontDescription, family, range);
 }
 
 const FontDataRange FontFallbackIterator::next(const Vector<UChar32>& hintList)
 {
     if (m_fallbackStage == OutOfLuck)
         return FontDataRange();
 
-    const FontData* fontData = m_fontFallbackList->fontDataAt(m_fontDescription, m_currentFontDataIndex);
+    if (m_fallbackStage == FallbackPriorityFonts) {
+        FontDataRange fallbackPriorityFont = nextFallbackPriorityFont();
+        if (!fallbackPriorityFont.isNull())
+            return fallbackPriorityFont;
+        // No more prioritized fallback fonts, proceed to processing the CSS
+        // defined fonts.
+        m_fallbackStage = FontGroupFonts;
+        return next(hintList);
+    }
 
-    // If there is no fontData coming from the fallback list, it means
-    // we have reached the system fallback stage.
-    if (!fontData) {
-        m_fallbackStage = SystemFonts;
+    if (m_fallbackStage == SystemFonts) {
         // We've reached pref + system fallback.
         ASSERT(hintList.size());
         RefPtr<SimpleFontData> systemFont = uniqueSystemFontForHint(hintList[0]);
         if (systemFont)
             return FontDataRange(systemFont);
 
         // If we don't have options from the system fallback anymore or had
         // previously returned them, we only have the last resort font left.
         // TODO: crbug.com/42217 Improve this by doing the last run with a last
         // resort font that has glyphs for everything, for example the Unicode
         // LastResort font, not just Times or Arial.
         FontCache* fontCache = FontCache::fontCache();
         m_fallbackStage = OutOfLuck;
         RefPtr<SimpleFontData> lastResort = fontCache->getLastResortFallbackFont(m_fontDescription).get();
         RELEASE_ASSERT(lastResort);
         return FontDataRange(lastResort);
     }
 
+    ASSERT(m_fallbackStage == FontGroupFonts
+        || m_fallbackStage == SegmentedFace);
+    const FontData* fontData = m_fontFallbackList->fontDataAt(
+        m_fontDescription, m_currentFontDataIndex);
+
+    if (!fontData) {
+        // If there is no fontData coming from the fallback list, it means
+        // we are now looking at system fonts, either for prioritized symbol
+        // or emoji fonts or by calling system fallback API.
+        m_fallbackStage = SystemFonts;
+        return next(hintList);
+    }
+
     // Otherwise we've received a fontData from the font-family: set of fonts,
     // and a non-segmented one in this case.
     if (!fontData->isSegmented()) {
         // Skip forward to the next font family for the next call to next().
         m_currentFontDataIndex++;
         if (!fontData->isLoading()) {
             RefPtr<SimpleFontData> nonSegmented = const_cast<SimpleFontData*>(toSimpleFontData(fontData));
             return FontDataRange(nonSegmented);
         }
         return next(hintList);
@@ skipping 22 matching lines @@
         if (currentRange.fontData()->customFontData())
             currentRange.fontData()->customFontData()->beginLoadIfNeeded();
         if (!currentRange.fontData()->isLoading())
             return currentRange;
         m_loadingCustomFontForRanges.append(currentRange);
     }
 
     return next(hintList);
 }
 
+FontDataRange FontFallbackIterator::nextFallbackPriorityFont()
+{
+    ASSERT(m_fontFallbackPriority != FontFallbackPriority::Invalid);
+    FontCache* fontCache = FontCache::fontCache();
+
+    const Vector<AtomicString>* priorityFontList =
+        fontCache->fontListForFallbackPriority(
+        m_fontDescription, m_fontFallbackPriority);
+
+    if (m_symbolsFontCursor == priorityFontList->size())
+        return FontDataRange();
+
+    RefPtr<SimpleFontData> priorityFont = fontCache->getFontData(
+        m_fontDescription,
+        priorityFontList->at(m_symbolsFontCursor));
+    m_symbolsFontCursor++;
+    return FontDataRange(priorityFont);
+}
+
 const PassRefPtr<SimpleFontData> FontFallbackIterator::uniqueSystemFontForHint(UChar32 hint)
 {
     FontCache* fontCache = FontCache::fontCache();
 
     // When we're asked for a fallback for the same characters again, we give up
     // because the shaper must have previously tried shaping with the font
     // already.
     if (m_visitedSystemFonts.find(hint) != m_visitedSystemFonts.end()) {
         return nullptr;
     }
 
     RefPtr<SimpleFontData> fallbackFont = fontCache->fallbackFontForCharacter(m_fontDescription, hint, m_fontFallbackList->primarySimpleFontData(m_fontDescription));
 
     return m_visitedSystemFonts.add(hint, fallbackFont).storedValue->value;
 }
 
 } // namespace blink