Revert of Change fallback font collection in HarfBuzzShaper

Source/platform/fonts/shaping/HarfBuzzShaper.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. 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.
@@ skipping 466 matching lines @@
                 return charactersSoFar + index;
             }
             charactersSoFar += m_runs[i]->m_numCharacters;
             currentX = nextX;
         }
     }
 
     return charactersSoFar;
 }
 
-void ShapeResult::fallbackFonts(HashSet<const SimpleFontData*>* fallback) const
-{
-    ASSERT(fallback);
-    for (unsigned i = 0; i < m_runs.size(); ++i) {
-        if (m_runs[i]->m_fontData != m_primaryFont)
-            fallback->add(m_runs[i]->m_fontData);
-    }
-}
-
 unsigned ShapeResult::numberOfRunsForTesting() const
 {
     return m_runs.size();
 }
 
 bool ShapeResult::runInfoForTesting(unsigned runIndex, unsigned& startIndex,
     unsigned& numGlyphs, hb_script_t& script)
 {
     if (runIndex < m_runs.size() && m_runs[runIndex]) {
         startIndex = m_runs[runIndex]->m_startIndex;
@@ skipping 88 matching lines @@
         else if (Character::treatAsSpace(character) && character != tabulationCharacter)
             character = spaceCharacter;
         else if (Character::treatAsZeroWidthSpaceInComplexScript(character))
             character = zeroWidthSpaceCharacter;
 
         U16_APPEND(destination, *destinationLength, length, character, error);
         ASSERT_UNUSED(error, !error);
     }
 }
 
-HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run)
-    : Shaper(font, run)
+HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run,
+    HashSet<const SimpleFontData*>* fallbackFonts)
+    : Shaper(font, run, nullptr, fallbackFonts)
     , m_normalizedBufferLength(0)
     , m_wordSpacingAdjustment(font->fontDescription().wordSpacing())
     , m_letterSpacing(font->fontDescription().letterSpacing())
     , m_expansionOpportunityCount(0)
 {
+    // TODO(eae): Once SimpleShaper is gone the ownership of this should shift
+    // to HarfBuzzShaper.
+    ASSERT(fallbackFonts);
     m_normalizedBuffer = adoptArrayPtr(new UChar[m_textRun.length() + 1]);
     normalizeCharacters(m_textRun, m_textRun.length(), m_normalizedBuffer.get(), &m_normalizedBufferLength);
     setExpansion(m_textRun.expansion());
     setFontFeatures();
 }
 
 float HarfBuzzShaper::nextExpansionPerOpportunity()
 {
     if (!m_expansionOpportunityCount) {
         ASSERT_NOT_REACHED(); // failures indicate that the logic in HarfBuzzShaper does not match to the one in expansionOpportunityCount()
@@ skipping 129 matching lines @@
 }
 
 PassRefPtr<ShapeResult> HarfBuzzShaper::shapeResult()
 {
     if (!createHarfBuzzRuns())
         return nullptr;
 
     ShapeResult* result = new ShapeResult();
     result->m_numCharacters = m_normalizedBufferLength;
     result->m_direction = m_textRun.direction();
-    result->m_primaryFont = m_font->primaryFont();
 
     if (!shapeHarfBuzzRuns(result)) {
         delete result;
         return nullptr;
     }
 
     return adoptRef(result);
 }
 
 struct CandidateRun {
@@ skipping 202 matching lines @@
     hb_direction_t harfBuzzDirection = isVerticalAnyUpright(orientation) && !fontData->isTextOrientationFallback() ? HB_DIRECTION_TTB : HB_DIRECTION_LTR;
     return dir == RTL ? HB_DIRECTION_REVERSE(harfBuzzDirection) : harfBuzzDirection;
 }
 
 void HarfBuzzShaper::addHarfBuzzRun(unsigned startCharacter,
     unsigned endCharacter, const SimpleFontData* fontData,
     UScriptCode script)
 {
     ASSERT(endCharacter > startCharacter);
     ASSERT(script != USCRIPT_INVALID_CODE);
+    if (m_fallbackFonts)
+        trackNonPrimaryFallbackFont(fontData);
     return m_harfBuzzRuns.append(HarfBuzzRun::create(fontData,
         startCharacter, endCharacter - startCharacter,
         TextDirectionToHBDirection(m_textRun.direction(), m_font->fontDescription().orientation(), fontData),
         ICUScriptToHBScript(script)));
 }
 
 static const uint16_t* toUint16(const UChar* src)
 {
     // FIXME: This relies on undefined behavior however it works on the
     // current versions of all compilers we care about and avoids making
@@ skipping 135 matching lines @@
         totalAdvance += advance;
 
         FloatRect glyphBounds = currentFontData->boundsForGlyph(glyph);
         glyphBounds.move(glyphOrigin.x(), glyphOrigin.y());
         result->m_glyphBoundingBox.unite(glyphBounds);
         glyphOrigin += FloatSize(advance + offsetX, offsetY);
     }
 
     run->m_width = totalAdvance > 0.0 ? totalAdvance : 0.0;
     result->m_width += run->m_width;
+    result->m_fallbackFonts = *m_fallbackFonts;
 }
 
 float HarfBuzzShaper::adjustSpacing(ShapeResult::RunInfo* run, size_t glyphIndex, unsigned currentCharacterIndex, float& offset, float& totalAdvance)
 {
     float spacing = 0;
     UChar32 character = m_normalizedBuffer[currentCharacterIndex];
     if (m_letterSpacing && !Character::treatAsZeroWidthSpace(character))
         spacing += m_letterSpacing;
 
     bool treatAsSpace = Character::treatAsSpace(character);
@@ skipping 39 matching lines @@
             return spacing;
     }
 
     // Don't need to check m_textRun.allowsTrailingExpansion() since it's covered by !m_expansionOpportunityCount above
     spacing += nextExpansionPerOpportunity();
     m_isAfterExpansion = true;
     return spacing;
 }
 
 } // namespace blink