Shape unicode-range: font faces in only one iteration

third_party/WebKit/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 257 matching lines @@
     } else {
         hb_buffer_add_utf16(buffer, toUint16(normalizedBuffer),
             normalizedBufferLength, startIndex, numCharacters);
     }
 }
 
 inline bool HarfBuzzShaper::shapeRange(hb_buffer_t* harfBuzzBuffer,
     unsigned startIndex,
     unsigned numCharacters,
     const SimpleFontData* currentFont,
-    unsigned currentFontRangeFrom,
-    unsigned currentFontRangeTo,
+    PassRefPtr<UnicodeRangeSet> currentFontRangeSet,
     UScriptCode currentRunScript,
     hb_language_t language)
 {
     const FontPlatformData* platformData = &(currentFont->platformData());
     HarfBuzzFace* face = platformData->harfBuzzFace();
     if (!face) {
         WTF_LOG_ERROR("Could not create HarfBuzzFace from FontPlatformData.");
         return false;
     }
 
     hb_buffer_set_language(harfBuzzBuffer, language);
     hb_buffer_set_script(harfBuzzBuffer, ICUScriptToHBScript(currentRunScript));
     hb_buffer_set_direction(harfBuzzBuffer, TextDirectionToHBDirection(m_textRun.direction(),
         m_font->getFontDescription().orientation(), currentFont));
 
     addToHarfBuzzBufferInternal(harfBuzzBuffer,
         m_font->getFontDescription(), m_normalizedBuffer.get(), m_normalizedBufferLength,
         startIndex, numCharacters);
 
-    HarfBuzzScopedPtr<hb_font_t> harfBuzzFont(face->createFont(currentFontRangeFrom, currentFontRangeTo), hb_font_destroy);
+    HarfBuzzScopedPtr<hb_font_t> harfBuzzFont(face->createFont(currentFontRangeSet), hb_font_destroy);
     hb_shape(harfBuzzFont.get(), harfBuzzBuffer, m_features.isEmpty() ? 0 : m_features.data(), m_features.size());
 
     return true;
 }
 
 bool HarfBuzzShaper::extractShapeResults(hb_buffer_t* harfBuzzBuffer,
     ShapeResult* shapeResult,
     bool& fontCycleQueued, const HolesQueueItem& currentQueueItem,
     const SimpleFontData* currentFont,
     UScriptCode currentRunScript,
@@ skipping 195 matching lines @@
     // segmentation plays a role here, does the new scriptRuniterator handle that correctly?
     while (runSegmenter.consume(&segmentRange)) {
         RefPtr<FontFallbackIterator> fallbackIterator =
             m_font->createFontFallbackIterator(
             segmentRange.fontFallbackPriority);
 
         appendToHolesQueue(HolesQueueNextFont, 0, 0);
         appendToHolesQueue(HolesQueueRange, segmentRange.start, segmentRange.end - segmentRange.start);
 
         const SimpleFontData* currentFont = nullptr;
-        unsigned currentFontRangeFrom = 0;
-        unsigned currentFontRangeTo = 0;
+        RefPtr<UnicodeRangeSet> currentFontRangeSet;
 
         bool fontCycleQueued = false;
         while (m_holesQueue.size()) {
             HolesQueueItem currentQueueItem = m_holesQueue.takeFirst();
 
             if (currentQueueItem.m_action == HolesQueueNextFont) {
                 // For now, we're building a character list with which we probe
                 // for needed fonts depending on the declared unicode-range of a
                 // segmented CSS font. Alternatively, we can build a fake font
                 // for the shaper and check whether any glyphs were found, or
                 // define a new API on the shaper which will give us coverage
                 // information?
                 if (!collectFallbackHintChars(fallbackCharsHint, fallbackIterator->needsHintList())) {
                     // Give up shaping since we cannot retrieve a font fallback
                     // font without a hintlist.
                     m_holesQueue.clear();
                     break;
                 }
 
-                FontDataRange nextFontDataRange = fallbackIterator->next(fallbackCharsHint);
-                currentFont = nextFontDataRange.fontData().get();
-                currentFontRangeFrom = nextFontDataRange.from();
-                currentFontRangeTo = nextFontDataRange.to();
+                FontDataForRangeSet nextFontDataForRangeSet = fallbackIterator->next(fallbackCharsHint);
+                currentFont = nextFontDataForRangeSet.fontData().get();
+                currentFontRangeSet = nextFontDataForRangeSet.ranges();
+
                 if (!currentFont) {
                     ASSERT(!m_holesQueue.size());
                     break;
                 }
                 fontCycleQueued = false;
                 continue;
             }
 
             // TODO crbug.com/522964: Only use smallCapsFontData when the font does not support true smcp.  The spec
             // says: "To match the surrounding text, a font may provide alternate glyphs for caseless characters when
             // these features are enabled but when a user agent simulates small capitals, it must not attempt to
             // simulate alternates for codepoints which are considered caseless."
             const SimpleFontData* smallcapsAdjustedFont = segmentRange.smallCapsBehavior == SmallCapsIterator::SmallCapsUppercaseNeeded
                 ? currentFont->smallCapsFontData(fontDescription).get()
                 : currentFont;
 
             // Compatibility with SimpleFontData approach of keeping a flag for overriding drawing direction.
             // TODO: crbug.com/506224 This should go away in favor of storing that information elsewhere, for example in
             // ShapeResult.
             const SimpleFontData* directionAndSmallCapsAdjustedFont = fontDataAdjustedForOrientation(smallcapsAdjustedFont,
                 m_font->getFontDescription().orientation(),
                 segmentRange.renderOrientation);
 
             if (!shapeRange(harfBuzzBuffer.get(),
                 currentQueueItem.m_startIndex,
                 currentQueueItem.m_numCharacters,
                 directionAndSmallCapsAdjustedFont,
-                currentFontRangeFrom,
-                currentFontRangeTo,
+                currentFontRangeSet,
                 segmentRange.script,
                 language))
                 WTF_LOG_ERROR("Shaping range failed.");
 
             if (!extractShapeResults(harfBuzzBuffer.get(),
                 result.get(),
                 fontCycleQueued,
                 currentQueueItem,
                 directionAndSmallCapsAdjustedFont,
                 segmentRange.script,
@@ skipping 103 matching lines @@
     result->m_width = run->m_width;
     result->m_numGlyphs = count;
     ASSERT(result->m_numGlyphs == count); // no overflow
     result->m_hasVerticalOffsets = fontData->platformData().isVerticalAnyUpright();
     result->m_runs.append(run.release());
     return result.release();
 }
 
 
 } // namespace blink