Revert of Change fallback font collection in HarfBuzzShaper

Source/platform/fonts/shaping/CachingWordShapeIterator.h

 /*
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 18 matching lines @@
 #include "platform/fonts/SimpleFontData.h"
 #include "platform/fonts/shaping/CachingWordShapeIterator.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/fonts/shaping/ShapeCache.h"
 #include "wtf/text/CharacterNames.h"
 
 namespace blink {
 
 class CachingWordShapeIterator {
 public:
-    CachingWordShapeIterator(ShapeCache* cache, const TextRun& run
-        , const Font* font)
-        : m_shapeCache(cache), m_textRun(run), m_font(font), m_startIndex(0)
+    CachingWordShapeIterator(ShapeCache* cache, const TextRun& run,
+        const Font* font, HashSet<const SimpleFontData*>* fallbackFonts)
+        : m_shapeCache(cache), m_textRun(run), m_font(font)
+        , m_fallbackFonts(fallbackFonts), m_startIndex(0)
     {
         ASSERT(font);
         const FontDescription& fontDescription = font->fontDescription();
 
         // Word and letter spacing can change the width of a word, as can tabs
         // as we segment solely based on on space characters.
         // If expansion is used (for justified text) the spacing between words
         // change and thus we need to shape the entire run.
         m_wordResultCachable = !fontDescription.wordSpacing()
             && !fontDescription.letterSpacing() && !run.allowTabs()
             && m_textRun.expansion() == 0.0f;
 
         // Shaping word by word is faster as each word is cached. If we cannot
         // use the cache or if the font doesn't support word by word shaping
         // fall back on shaping the entire run.
         m_shapeByWord = m_wordResultCachable && m_font->canShapeWordByWord();
     }
 
     bool next(RefPtr<ShapeResult>* wordResult)
     {
         if (!m_shapeByWord) {
             if (m_startIndex)
                 return false;
-            *wordResult = shapeWord(m_textRun, m_font);
+            *wordResult = shapeWord(m_textRun, m_font, m_fallbackFonts);
             m_startIndex = 1;
             return *wordResult;
         }
 
         unsigned length = m_textRun.length();
         if (m_startIndex < length) {
             if (m_textRun[m_startIndex] == spaceCharacter) {
                 TextRun wordRun = m_textRun.subRun(m_startIndex, 1);
-                *wordResult = shapeWord(wordRun, m_font);
+                *wordResult = shapeWord(wordRun, m_font, m_fallbackFonts);
                 m_startIndex++;
                 return true;
             }
 
             for (unsigned i = m_startIndex; ; i++) {
                 if (i == length || m_textRun[i] == spaceCharacter) {
                     TextRun wordRun = m_textRun.subRun(m_startIndex,
                         i - m_startIndex);
-                    *wordResult = shapeWord(wordRun, m_font);
+                    *wordResult = shapeWord(wordRun, m_font, m_fallbackFonts);
                     m_startIndex = i;
                     return true;
                 }
             }
         }
         return false;
     }
 
 private:
-    PassRefPtr<ShapeResult> shapeWord(const TextRun& wordRun, const Font* font)
+    void setFallbackFonts(const ShapeResult* wordResult,
+        HashSet<const SimpleFontData*>* fallbackFonts)
+    {
+        if (fallbackFonts) {
+            const HashSet<const SimpleFontData*>* fontsForWord =
+                wordResult->fallbackFonts();
+            HashSet<const SimpleFontData*>::const_iterator it;
+            for (it = fontsForWord->begin(); it != fontsForWord->end(); ++it)
+                fallbackFonts->add(*it);
+        }
+    }
+
+    PassRefPtr<ShapeResult> shapeWord(const TextRun& wordRun,
+        const Font* font, HashSet<const SimpleFontData*>* fallbackFonts)
     {
         ShapeCacheEntry* cacheEntry = m_wordResultCachable
             ? m_shapeCache->add(wordRun, ShapeCacheEntry())
             : nullptr;
-        if (cacheEntry && cacheEntry->m_shapeResult)
+        if (cacheEntry && cacheEntry->m_shapeResult) {
+            setFallbackFonts(cacheEntry->m_shapeResult.get(), fallbackFonts);
             return cacheEntry->m_shapeResult;
+        }
 
-        HarfBuzzShaper shaper(font, wordRun);
+        HashSet<const SimpleFontData*> fallbackFontsForWord;
+        HarfBuzzShaper shaper(font, wordRun, &fallbackFontsForWord);
         RefPtr<ShapeResult> shapeResult = shaper.shapeResult();
         if (!shapeResult)
             return nullptr;
 
         if (cacheEntry)
             cacheEntry->m_shapeResult = shapeResult;
 
+        setFallbackFonts(shapeResult.get(), fallbackFonts);
         return shapeResult.release();
     }
 
     ShapeCache* m_shapeCache;
     const TextRun& m_textRun;
     const Font* m_font;
+    HashSet<const SimpleFontData*>* m_fallbackFonts;
     unsigned m_startIndex : 30;
     unsigned m_wordResultCachable : 1;
     unsigned m_shapeByWord : 1;
 };
 
 } // namespace blink
 
 #endif // CachingWordShapeIterator_h