Reland "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 146 matching lines @@
 
 void ShapeResult::RunInfo::setGlyphAndPositions(unsigned index,
     uint16_t glyphId, float advance, float offsetX, float offsetY)
 {
     HarfBuzzRunGlyphData& data = m_glyphData[index];
     data.glyph = glyphId;
     data.advance = advance;
     data.offset = FloatSize(offsetX, offsetY);
 }
 
-ShapeResult::ShapeResult(unsigned numCharacters, TextDirection direction)
+ShapeResult::ShapeResult(const Font* font, unsigned numCharacters, TextDirection direction)
     : m_width(0)
+    , m_primaryFont(const_cast<SimpleFontData*>(font->primaryFont()))
     , m_numCharacters(numCharacters)
     , m_numGlyphs(0)
     , m_direction(direction)
 {
 }
 
 ShapeResult::~ShapeResult()
 {
 }
 
@@ skipping 297 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);
+    ASSERT(m_primaryFont);
+    for (unsigned i = 0; i < m_runs.size(); ++i) {
+        if (m_runs[i] && m_runs[i]->m_fontData != m_primaryFont)
+            fallback->add(m_runs[i]->m_fontData.get());
+    }
+}
+
 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 66 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,
-    HashSet<const SimpleFontData*>* fallbackFonts)
-    : Shaper(font, run, nullptr, fallbackFonts)
+HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run)
+    : Shaper(font, run)
     , 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 340 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);
 
     hb_direction_t direction = TextDirectionToHBDirection(m_textRun.direction(),
         m_font->fontDescription().orientation(), fontData);
     HarfBuzzRun harfBuzzRun = {
         fontData, startCharacter, endCharacter - startCharacter,
         direction, ICUScriptToHBScript(script)
     };
     m_harfBuzzRuns.append(harfBuzzRun);
 }
 
@@ skipping 20 matching lines @@
         hb_buffer_add_utf16(buffer, toUint16(upperText.characters16()),
             numCharacters, 0, numCharacters);
     } else {
         hb_buffer_add_utf16(buffer, toUint16(normalizedBuffer + startIndex),
             numCharacters, 0, numCharacters);
     }
 }
 
 PassRefPtr<ShapeResult> HarfBuzzShaper::shapeHarfBuzzRuns()
 {
-    RefPtr<ShapeResult> result = ShapeResult::create(
+    RefPtr<ShapeResult> result = ShapeResult::create(m_font,
         m_normalizedBufferLength, m_textRun.direction());
     HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(), hb_buffer_destroy);
 
     const FontDescription& fontDescription = m_font->fontDescription();
     const String& localeString = fontDescription.locale();
     CString locale = localeString.latin1();
     const hb_language_t language = hb_language_from_string(locale.data(), locale.length());
 
     result->m_runs.resize(m_harfBuzzRuns.size());
     for (unsigned i = 0; i < m_harfBuzzRuns.size(); ++i) {
@@ skipping 97 matching lines @@
         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_numGlyphs += numGlyphs;
     result->m_runs[index] = run.release();
-    for (auto& fallbackFont : *m_fallbackFonts)
-        result->m_fallbackFonts.add(const_cast<SimpleFontData*>(fallbackFont));
 }
 
 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