Optimize complex text shaping

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 197 matching lines @@
 {
     DEFINE_STATIC_LOCAL(HarfBuzzRunCache, globalHarfBuzzRunCache, ());
     return globalHarfBuzzRunCache;
 }
 
 static inline float harfBuzzPositionToFloat(hb_position_t value)
 {
     return static_cast<float>(value) / (1 << 16);
 }
 
-static inline unsigned countGraphemesInCluster(const UChar* normalizedBuffer, unsigned normalizedBufferLength, uint16_t startIndex, uint16_t endIndex)
+static inline unsigned countGraphemesInCluster(const UChar* str, unsigned strLength, uint16_t startIndex, uint16_t endIndex)
 {
     if (startIndex > endIndex) {
         uint16_t tempIndex = startIndex;
         startIndex = endIndex;
         endIndex = tempIndex;
     }
     uint16_t length = endIndex - startIndex;
-    ASSERT(static_cast<unsigned>(startIndex + length) <= normalizedBufferLength);
-    TextBreakIterator* cursorPosIterator = cursorMovementIterator(&normalizedBuffer[startIndex], length);
+    ASSERT(static_cast<unsigned>(startIndex + length) <= strLength);
+    TextBreakIterator* cursorPosIterator = cursorMovementIterator(&str[startIndex], length);
 
     int cursorPos = cursorPosIterator->current();
     int numGraphemes = -1;
     while (0 <= cursorPos) {
         cursorPos = cursorPosIterator->next();
         numGraphemes++;
     }
     return numGraphemes < 0 ? 0 : numGraphemes;
 }
 
@@ skipping 101 matching lines @@
         position += m_advances[glyphIndex];
     } else {
         while (glyphIndex < m_numGlyphs && m_glyphToCharacterIndexes[glyphIndex] < offset) {
             position += m_advances[glyphIndex];
             ++glyphIndex;
         }
     }
     return position;
 }
 
-static void normalizeCharacters(const TextRun& run, unsigned length, UChar* destination, unsigned* destinationLength)
-{
-    unsigned position = 0;
-    bool error = false;
-    const UChar* source;
-    String stringFor8BitRun;
-    if (run.is8Bit()) {
-        stringFor8BitRun = String::make16BitFrom8BitSource(run.characters8(), run.length());
-        source = stringFor8BitRun.characters16();
-    } else {
-        source = run.characters16();
-    }
-
-    *destinationLength = 0;
-    while (position < length) {
-        UChar32 character;
-        U16_NEXT(source, position, length, character);
-        // Don't normalize tabs as they are not treated as spaces for word-end.
-        if (run.normalizeSpace() && Character::isNormalizedCanvasSpaceCharacter(character))
-            character = space;
-        else if (Character::treatAsSpace(character) && character != characterTabulation)
-            character = space;
-        else if (Character::treatAsZeroWidthSpaceInComplexScript(character))
-            character = zeroWidthSpace;
-
-        U16_APPEND(destination, *destinationLength, length, character, error);
-        ASSERT_UNUSED(error, !error);
-    }
-}
 
 HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run, ForTextEmphasisOrNot forTextEmphasis, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* bounds)
     : m_font(font)
-    , m_normalizedBufferLength(0)
     , m_run(run)
     , m_wordSpacingAdjustment(font->fontDescription().wordSpacing())
     , m_expansion(0)
     , m_letterSpacing(font->fontDescription().letterSpacing())
     , m_expansionPerOpportunity(0)
     , m_expansionOpportunityCount(0)
     , m_isAfterExpansion(!run.allowsLeadingExpansion())
     , m_fromIndex(0)
     , m_toIndex(m_run.length())
     , m_forTextEmphasis(forTextEmphasis)
     , m_glyphBoundingBox(bounds)
     , m_fallbackFonts(fallbackFonts)
 {
-    m_normalizedBuffer = adoptArrayPtr(new UChar[m_run.length() + 1]);
-    normalizeCharacters(m_run, m_run.length(), m_normalizedBuffer.get(), &m_normalizedBufferLength);
     setExpansion(m_run.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()
         return 0;
     }
@@ skipping 10 matching lines @@
 // WebKit uses this to justify text.
 void HarfBuzzShaper::setExpansion(float padding)
 {
     m_expansion = padding;
     if (!m_expansion)
         return;
 
     // If we have padding to distribute, then we try to give an equal
     // amount to each expansion opportunity.
     bool isAfterExpansion = m_isAfterExpansion;
-    m_expansionOpportunityCount = Character::expansionOpportunityCount(m_normalizedBuffer.get(), m_normalizedBufferLength, m_run.direction(), isAfterExpansion, m_run.textJustify());
+    if (m_run.is8Bit())
+        m_expansionOpportunityCount = Character::expansionOpportunityCount(m_run.characters8(), m_run.length(), m_run.direction(), isAfterExpansion, m_run.textJustify());
+    else
+        m_expansionOpportunityCount = Character::expansionOpportunityCount(m_run.characters16(), m_run.length(), m_run.direction(), isAfterExpansion, m_run.textJustify());
+
     if (isAfterExpansion && !m_run.allowsTrailingExpansion()) {
         ASSERT(m_expansionOpportunityCount > 0);
         --m_expansionOpportunityCount;
     }
 
     if (m_expansionOpportunityCount)
         m_expansionPerOpportunity = m_expansion / m_expansionOpportunityCount;
     else
         m_expansionPerOpportunity = 0;
 }
@@ skipping 99 matching lines @@
         feature.tag = HB_TAG(tag[0], tag[1], tag[2], tag[3]);
         feature.value = settings->at(i).value();
         feature.start = 0;
         feature.end = static_cast<unsigned>(-1);
         m_features.append(feature);
     }
 }
 
 bool HarfBuzzShaper::shape(GlyphBuffer* glyphBuffer)
 {
-    if (!createHarfBuzzRuns())
-        return false;
-
-    m_totalWidth = 0;
-    if (!shapeHarfBuzzRuns())
-        return false;
-
-    if (glyphBuffer && !fillGlyphBuffer(glyphBuffer))
-        return false;
-
-    return true;
+    if (m_run.is8Bit())
+        return shapeInternal<LChar>(glyphBuffer);
+    return shapeInternal<UChar>(glyphBuffer);
 }
 
 static inline int handleMultipleUChar(
     UChar32 character,
     unsigned clusterLength,
     const SimpleFontData* currentFontData,
     const UChar* currentCharacterPosition,
     const UChar* markCharactersEnd,
-    const UChar* normalizedBufferEnd)
+    const UChar* strEnd)
 {
     if (U_GET_GC_MASK(character) & U_GC_M_MASK) {
         int markLength = clusterLength;
-        while (markCharactersEnd < normalizedBufferEnd) {
+        while (markCharactersEnd < strEnd) {
             UChar32 nextCharacter;
             int nextCharacterLength = 0;
-            U16_NEXT(markCharactersEnd, nextCharacterLength, normalizedBufferEnd - markCharactersEnd, nextCharacter);
+            U16_NEXT(markCharactersEnd, nextCharacterLength, strEnd - markCharactersEnd, nextCharacter);
             if (!(U_GET_GC_MASK(nextCharacter) & U_GC_M_MASK))
                 break;
             markLength += nextCharacterLength;
             markCharactersEnd += nextCharacterLength;
         }
 
         if (currentFontData->canRenderCombiningCharacterSequence(currentCharacterPosition, markCharactersEnd - currentCharacterPosition)) {
             return markLength;
         }
     }
     return 0;
 }
 
 struct CandidateRun {
     UChar32 character;
     unsigned start;
     unsigned end;
     const SimpleFontData* fontData;
     UScriptCode script;
 };
 
-static inline bool collectCandidateRuns(const UChar* normalizedBuffer,
-    size_t bufferLength, const Font* font, Vector<CandidateRun>* runs, bool isSpaceNormalize)
+template<typename CharType>
+bool collectCandidateRuns(const TextRun& textRun,
+    const Font* font, Vector<CandidateRun>* runs, bool isSpaceNormalize)
 {
-    const UChar* normalizedBufferEnd = normalizedBuffer + bufferLength;
-    SurrogatePairAwareTextIterator iterator(normalizedBuffer, 0, bufferLength, bufferLength);
+    const CharType* str = textRun.characters16();
+    const CharType* strEnd = str + textRun.length();
+    SurrogatePairAwareTextIterator iterator(str, 0, textRun.length(), textRun.length());
     UChar32 character;
     unsigned clusterLength = 0;
     unsigned startIndexOfCurrentRun = 0;
 
     if (!iterator.consume(character, clusterLength))
         return false;
 
     const SimpleFontData* nextFontData = font->glyphDataForCharacter(character, false, isSpaceNormalize).fontData;
     UErrorCode errorCode = U_ZERO_ERROR;
     UScriptCode nextScript = uscript_getScript(character, &errorCode);
     if (U_FAILURE(errorCode))
         return false;
 
     do {
-        const UChar* currentCharacterPosition = iterator.characters();
+        const CharType* currentCharacterPosition = iterator.characters();
         const SimpleFontData* currentFontData = nextFontData;
         UScriptCode currentScript = nextScript;
 
         UChar32 lastCharacter = character;
         for (iterator.advance(clusterLength); iterator.consume(character, clusterLength); iterator.advance(clusterLength)) {
             if (Character::treatAsZeroWidthSpace(character))
                 continue;
 
-            int length = handleMultipleUChar(character, clusterLength, currentFontData, currentCharacterPosition, iterator.characters() + clusterLength, normalizedBufferEnd);
+            int length = handleMultipleUChar(character, clusterLength, currentFontData, currentCharacterPosition, iterator.characters() + clusterLength, strEnd);
             if (length) {
                 clusterLength = length;
                 continue;
             }
 
             nextFontData = font->glyphDataForCharacter(character, false, isSpaceNormalize).fontData;
             nextScript = uscript_getScript(character, &errorCode);
             if (U_FAILURE(errorCode))
                 return false;
             if (lastCharacter == zeroWidthJoiner)
                 currentFontData = nextFontData;
             if ((nextFontData != currentFontData) || ((currentScript != nextScript) && (nextScript != USCRIPT_INHERITED) && (!uscript_hasScript(character, currentScript))))
                 break;
             currentCharacterPosition = iterator.characters();
             lastCharacter = character;
         }
 
         CandidateRun run = { character, startIndexOfCurrentRun, iterator.currentCharacter(), currentFontData, currentScript };
         runs->append(run);
 
         startIndexOfCurrentRun = iterator.currentCharacter();
     } while (iterator.consume(character, clusterLength));
 
     return true;
 }
 
+template<>
+bool collectCandidateRuns<LChar>(const TextRun& textRun,
+    const Font* font, Vector<CandidateRun>* runs, bool isSpaceNormalize)
+{
+    const LChar* str = textRun.characters8();
+    UChar32 character = *str;
+    const SimpleFontData* fontData = font->glyphDataForCharacter(character,
+        false, isSpaceNormalize).fontData;
+
+    // For 8-bit runs we do not need to split based on script or check for
+    // clusters as the entire run is guaranteed to be latin-1.
+    CandidateRun run = { *str, 0, textRun.length(), fontData, USCRIPT_LATIN };
+    runs->append(run);
+    return true;
+}
+
 static inline bool matchesAdjacentRun(UScriptCode* scriptExtensions, int length,
     CandidateRun& adjacentRun)
 {
     for (int i = 0; i < length; i++) {
         if (scriptExtensions[i] == adjacentRun.script)
             return true;
     }
     return false;
 }
 
@@ skipping 69 matching lines @@
 
         i = std::max(i, nextResolvedRun);
     }
     return true;
 }
 
 // For ideographic (CJK) documents, 90-95% of calls from width() are one character length
 // because most characters have break opportunities both before and after.
 bool HarfBuzzShaper::createHarfBuzzRunsForSingleCharacter()
 {
-    ASSERT(m_normalizedBufferLength == 1);
-    UChar32 character = m_normalizedBuffer[0];
+    ASSERT(m_run.length() == 1);
+    UChar32 character = m_run[0];
     if (!U16_IS_SINGLE(character))
         return false;
-    const SimpleFontData* fontData = m_font->glyphDataForCharacter(character, false, m_run.normalizeSpace()).fontData;
+    const SimpleFontData* fontData = m_font->glyphDataForCharacter(character,
+        false, m_run.normalizeSpace()).fontData;
     UErrorCode errorCode = U_ZERO_ERROR;
     UScriptCode script = uscript_getScript(character, &errorCode);
     if (U_FAILURE(errorCode))
         return false;
     addHarfBuzzRun(0, 1, fontData, script);
     return true;
 }
 
+template<typename CharType>
+bool HarfBuzzShaper::shapeInternal(GlyphBuffer* glyphBuffer)
+{
+    if (!createHarfBuzzRuns<CharType>())
+        return false;
+
+    m_totalWidth = 0;
+    if (!shapeHarfBuzzRuns<CharType>())
+        return false;
+
+    if (glyphBuffer && !fillGlyphBuffer(glyphBuffer))
+        return false;
+
+    return true;
+}
+
+template<typename CharType>
 bool HarfBuzzShaper::createHarfBuzzRuns()
 {
-    if (m_normalizedBufferLength == 1)
+    if (m_run.length() == 1)
         return createHarfBuzzRunsForSingleCharacter();
 
     Vector<CandidateRun> candidateRuns;
-    if (!collectCandidateRuns(m_normalizedBuffer.get(),
-        m_normalizedBufferLength, m_font, &candidateRuns, m_run.normalizeSpace()))
+    if (!collectCandidateRuns<CharType>(m_run, m_font, &candidateRuns,
+        m_run.normalizeSpace()))
         return false;
 
     if (!resolveCandidateRuns(candidateRuns))
         return false;
 
     size_t length = candidateRuns.size();
     for (size_t i = 0; i < length; ) {
         CandidateRun& run = candidateRuns[i];
         CandidateRun lastMatchingRun = run;
         for (i++; i < length; i++) {
             if (candidateRuns[i].script != run.script
                 || candidateRuns[i].fontData != run.fontData)
                 break;
             lastMatchingRun = candidateRuns[i];
         }
-        addHarfBuzzRun(run.start, lastMatchingRun.end, run.fontData, run.script);
+        if (lastMatchingRun.end > run.start)
+            addHarfBuzzRun(run.start, lastMatchingRun.end, run.fontData, run.script);
     }
     return !m_harfBuzzRuns.isEmpty();
 }
 
 // A port of hb_icu_script_to_script because harfbuzz on CrOS is built
 // without hb-icu. See http://crbug.com/356929
 static inline hb_script_t ICUScriptToHBScript(UScriptCode script)
 {
     if (UNLIKELY(script == USCRIPT_INVALID_CODE))
         return HB_SCRIPT_INVALID;
@@ skipping 14 matching lines @@
     ASSERT(endCharacter > startCharacter);
     ASSERT(script != USCRIPT_INVALID_CODE);
     if (m_fallbackFonts)
         m_fallbackFonts->add(fontData);
     return m_harfBuzzRuns.append(HarfBuzzRun::create(fontData,
         startCharacter, endCharacter - startCharacter,
         TextDirectionToHBDirection(m_run.direction(), m_font->fontDescription().orientation(), fontData),
         ICUScriptToHBScript(script)));
 }
 
-static inline bool isValidCachedResult(const Font* font, hb_direction_t dir,
-    const String& localeString, const CachedShapingResults* cachedResults)
-{
-    ASSERT(cachedResults);
-    return cachedResults->dir == dir
-        && cachedResults->font == *font
-        && !cachedResults->font.loadingCustomFonts()
-        && !font->loadingCustomFonts()
-        && cachedResults->locale == localeString;
-}
-
 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
     // a copy of the string.
     static_assert(sizeof(UChar) == sizeof(uint16_t), "UChar should be the same size as uint16_t");
     return reinterpret_cast<const uint16_t*>(src);
 }
 
-static inline void addToHarfBuzzBufferInternal(hb_buffer_t* buffer,
-    const FontDescription& fontDescription, const UChar* normalizedBuffer,
+template<typename CharType>
+inline const CharType* charactersForRun(const TextRun& textRun,
+    unsigned startIndex)
+{
+    return textRun.data16(startIndex);
+}
+
+template<>
+inline const LChar* charactersForRun<LChar>(const TextRun& textRun,
+    unsigned startIndex)
+{
+    return textRun.data8(startIndex);
+}
+
+template<typename CharType>
+inline const CharType* charactersForString(const String& string)
+{
+    return string.characters16();
+}
+
+template<>
+inline const LChar* charactersForString<LChar>(const String& string)
+{
+    return string.characters8();
+}
+
+template<typename CharType>
+inline void addToHarfBuzzBufferInternal(hb_buffer_t* buffer,
+    const CharType* characters, unsigned length)
+{
+    hb_buffer_add_utf16(buffer, toUint16(characters), length, 0, length);
+}
+
+template<>
+inline void addToHarfBuzzBufferInternal<LChar>(hb_buffer_t* buffer,
+    const LChar* characters, unsigned length)
+{
+    // On linux we use the system version of harfbuzz so we cannot depend on
+    // hb_buffer_add_latin1 being available as it was only added in 0.9.38.
+    // FIXME: Remove this hack once all supported distros have HB >= 0.9.38.

[skobes, 2015/02/27 19:20:03]

Is there a bug # to associate this FIXME with?

+#if OS(LINUX)
+    String converted = String::make16BitFrom8BitSource(characters, length);
+    hb_buffer_add_utf16(buffer, toUint16(converted.characters16()),
+        length, 0, length);
+#else
+    hb_buffer_add_latin1(buffer, characters, length, 0, length);
+#endif
+}
+
+template<typename CharType>
+inline void addToHarfBuzzBuffer(hb_buffer_t* buffer,
+    const FontDescription& fontDescription, const TextRun& textRun,
     unsigned startIndex, unsigned numCharacters)
 {
     if (fontDescription.variant() == FontVariantSmallCaps
-        && u_islower(normalizedBuffer[startIndex])) {
-        String upperText = String(normalizedBuffer + startIndex, numCharacters)
-            .upper();
-        // TextRun is 16 bit, therefore upperText is 16 bit, even after we call
-        // makeUpper().
-        ASSERT(!upperText.is8Bit());
-        hb_buffer_add_utf16(buffer, toUint16(upperText.characters16()),
-            numCharacters, 0, numCharacters);
+        && u_islower(textRun[startIndex])) {
+        String upperText = String(charactersForRun<CharType>(
+            textRun, startIndex), numCharacters).upper();
+        // If TextRun is 16 bit upperText should be 16 bit too.
+        ASSERT(upperText.is8Bit() == textRun.is8Bit());
+        addToHarfBuzzBufferInternal<CharType>(buffer,
+            charactersForString<CharType>(upperText), numCharacters);
     } else {
-        hb_buffer_add_utf16(buffer, toUint16(normalizedBuffer + startIndex),
-            numCharacters, 0, numCharacters);
+        addToHarfBuzzBufferInternal(buffer,
+            charactersForRun<CharType>(textRun, startIndex), numCharacters);
     }
 }
 
+static inline UChar32 normalizeCharacter(UChar32 character,
+    bool normalizeSpace)
+{
+    if (normalizeSpace && Character::isNormalizedCanvasSpaceCharacter(character))
+        return space;
+    if (Character::treatAsSpace(character) && character != characterTabulation)
+        return space;
+    if (Character::treatAsZeroWidthSpaceInComplexScript(character))
+        return zeroWidthSpace;
+    return character;
+}
+
+static inline void normalizeHarfBuzzBuffer(hb_buffer_t* buffer,
+    bool normalizeSpace)
+{
+    unsigned length;
+    hb_glyph_info_t* glyphInfos = hb_buffer_get_glyph_infos(buffer, &length);
+    for (unsigned i = 0; i < length; i++) {
+        UChar32 character = glyphInfos[i].codepoint;
+        UChar32 normalized = normalizeCharacter(character, normalizeSpace);
+        if (character != normalized)
+            glyphInfos[i].codepoint = normalized;
+    }
+}
+
+static inline bool isValidCachedResult(const Font* font, hb_direction_t dir,
+    const String& localeString, const CachedShapingResults* cachedResults)
+{
+    ASSERT(cachedResults);
+    return cachedResults->dir == dir
+        && cachedResults->font == *font
+        && !cachedResults->font.loadingCustomFonts()
+        && !font->loadingCustomFonts()
+        && cachedResults->locale == localeString;
+}
+
+template<typename CharType>
 bool HarfBuzzShaper::shapeHarfBuzzRuns()
 {
     HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(), hb_buffer_destroy);
 
     HarfBuzzRunCache& runCache = harfBuzzRunCache();
     const FontDescription& fontDescription = m_font->fontDescription();
     const String& localeString = fontDescription.locale();
     CString locale = localeString.latin1();
     HarfBuzzRun* previousRun = nullptr;
 
     for (unsigned i = 0; i < m_harfBuzzRuns.size(); ++i) {
         unsigned runIndex = m_run.rtl() ? m_harfBuzzRuns.size() - i - 1 : i;
         HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
 
         const SimpleFontData* currentFontData = currentRun->fontData();
         FontPlatformData* platformData = const_cast<FontPlatformData*>(&currentFontData->platformData());
         HarfBuzzFace* face = platformData->harfBuzzFace();
         if (!face)
             return false;
 
         hb_buffer_set_language(harfBuzzBuffer.get(), hb_language_from_string(locale.data(), locale.length()));
         hb_buffer_set_script(harfBuzzBuffer.get(), currentRun->script());
         hb_buffer_set_direction(harfBuzzBuffer.get(), currentRun->direction());
 
-        const UChar* src = m_normalizedBuffer.get() + currentRun->startIndex();
+        const CharType* src = charactersForRun<CharType>(m_run, currentRun->startIndex());
         std::wstring key(src, src + currentRun->numCharacters());
 
         CachedShapingResults* cachedResults = runCache.find(key);
         if (cachedResults) {
             if (isValidCachedResult(m_font, currentRun->direction(),
                 localeString, cachedResults)) {
                 currentRun->applyShapeResult(cachedResults->buffer);
                 setGlyphPositionsForHarfBuzzRun(currentRun,
                     cachedResults->buffer, previousRun);
                 hb_buffer_clear_contents(harfBuzzBuffer.get());
                 runCache.moveToBack(cachedResults);
                 previousRun = currentRun;
                 continue;
             }
             runCache.remove(cachedResults);
         }
 
         // Add a space as pre-context to the buffer. This prevents showing dotted-circle
         // for combining marks at the beginning of runs.
         static const uint16_t preContext = space;
         hb_buffer_add_utf16(harfBuzzBuffer.get(), &preContext, 1, 1, 0);
 
-        addToHarfBuzzBufferInternal(harfBuzzBuffer.get(),
-            fontDescription, m_normalizedBuffer.get(), currentRun->startIndex(),
+        addToHarfBuzzBuffer<CharType>(harfBuzzBuffer.get(),
+            fontDescription, m_run, currentRun->startIndex(),
             currentRun->numCharacters());
+        normalizeHarfBuzzBuffer(harfBuzzBuffer.get(), m_run.normalizeSpace());
 
         if (fontDescription.orientation() == Vertical)
             face->setScriptForVerticalGlyphSubstitution(harfBuzzBuffer.get());
 
         HarfBuzzScopedPtr<hb_font_t> harfBuzzFont(face->createFont(), hb_font_destroy);
 
         hb_shape(harfBuzzFont.get(), harfBuzzBuffer.get(), m_features.isEmpty() ? 0 : m_features.data(), m_features.size());
         currentRun->applyShapeResult(harfBuzzBuffer.get());
         setGlyphPositionsForHarfBuzzRun(currentRun, harfBuzzBuffer.get(), previousRun);
 
@@ skipping 32 matching lines @@
     // HarfBuzz returns the shaping result in visual order. We need not to flip for RTL.
     for (size_t i = 0; i < numGlyphs; ++i) {
         bool runEnd = i + 1 == numGlyphs;
         uint16_t glyph = glyphInfos[i].codepoint;
         float offsetX = harfBuzzPositionToFloat(glyphPositions[i].x_offset);
         float offsetY = -harfBuzzPositionToFloat(glyphPositions[i].y_offset);
         // One out of x_advance and y_advance is zero, depending on
         // whether the buffer direction is horizontal or vertical.
         float advance = harfBuzzPositionToFloat(glyphPositions[i].x_advance - glyphPositions[i].y_advance);
 
-        unsigned currentCharacterIndex = currentRun->startIndex() + glyphInfos[i].cluster;
-        RELEASE_ASSERT(m_normalizedBufferLength > currentCharacterIndex);
+        int currentCharacterIndex = currentRun->startIndex() + glyphInfos[i].cluster;

[skobes, 2015/02/27 19:20:03]

Why is the index signed here, but unsigned in adjustSpacing?  Seems like we
should be consistent.

+        RELEASE_ASSERT(m_run.length() > currentCharacterIndex);
         bool isClusterEnd = runEnd || glyphInfos[i].cluster != glyphInfos[i + 1].cluster;
         float spacing = 0;
 
         glyphToCharacterIndexes[i] = glyphInfos[i].cluster;
 
         if (isClusterEnd)
             spacing += adjustSpacing(currentRun, i, currentCharacterIndex, previousRun, offsetX, totalAdvance);
 
         if (currentFontData->isZeroWidthSpaceGlyph(glyph)) {
             currentRun->setGlyphAndPositions(i, glyph, 0, 0, 0);
@@ skipping 19 matching lines @@
 
         totalAdvance += advance;
     }
     currentRun->setWidth(totalAdvance > 0.0 ? totalAdvance : 0.0);
     m_totalWidth += currentRun->width();
 }
 
 float HarfBuzzShaper::adjustSpacing(HarfBuzzRun* currentRun, size_t glyphIndex, unsigned currentCharacterIndex, HarfBuzzRun* previousRun, float& offsetX, float& totalAdvance)
 {
     float spacing = 0;
-    UChar32 character = m_normalizedBuffer[currentCharacterIndex];
+    UChar32 character = normalizeCharacter(m_run[currentCharacterIndex], m_run.normalizeSpace());
     if (m_letterSpacing && !Character::treatAsZeroWidthSpace(character))
         spacing += m_letterSpacing;
 
     bool treatAsSpace = Character::treatAsSpace(character);
     if (treatAsSpace && currentCharacterIndex && (character != '\t' || !m_run.allowTabs()))
         spacing += m_wordSpacingAdjustment;
 
     if (!m_expansionOpportunityCount)
         return spacing;
 
     if (treatAsSpace) {
         spacing += nextExpansionPerOpportunity();
         m_isAfterExpansion = true;
         return spacing;
     }
 
     if (m_run.textJustify() != TextJustify::TextJustifyAuto) {
         m_isAfterExpansion = false;
         return spacing;
     }
 
     // isCJKIdeographOrSymbol() has expansion opportunities both before and after each character.
     // http://www.w3.org/TR/jlreq/#line_adjustment
-    if (U16_IS_LEAD(character) && currentCharacterIndex + 1 < m_normalizedBufferLength && U16_IS_TRAIL(m_normalizedBuffer[currentCharacterIndex + 1]))
-        character = U16_GET_SUPPLEMENTARY(character, m_normalizedBuffer[currentCharacterIndex + 1]);
+    if (!m_run.is8Bit() && U16_IS_LEAD(character) && currentCharacterIndex + 1 < static_cast<unsigned>(m_run.charactersLength()) && U16_IS_TRAIL(m_run[currentCharacterIndex + 1]))
+        character = U16_GET_SUPPLEMENTARY(character, normalizeCharacter(m_run[currentCharacterIndex + 1], m_run.normalizeSpace()));
     if (!Character::isCJKIdeographOrSymbol(character)) {
         m_isAfterExpansion = false;
         return spacing;
     }
 
     if (!m_isAfterExpansion) {
         // Take the expansion opportunity before this ideograph.
         float expandBefore = nextExpansionPerOpportunity();
         if (expandBefore) {
             if (glyphIndex > 0) {
@@ skipping 95 matching lines @@
 
         clusterAdvance += advances[i];
 
         if (isClusterEnd) {
             uint16_t clusterEnd;
             if (m_run.rtl())
                 clusterEnd = currentCharacterIndex;
             else
                 clusterEnd = isRunEnd ? currentRun->startIndex() + currentRun->numCharacters() : currentRun->startIndex() + glyphToCharacterIndexes[i + 1];
 
-            graphemesInCluster = countGraphemesInCluster(m_normalizedBuffer.get(), m_normalizedBufferLength, clusterStart, clusterEnd);
+            graphemesInCluster = m_run.is8Bit() ? 1 : countGraphemesInCluster(m_run.characters16(), m_run.length(), clusterStart, clusterEnd);
             if (!graphemesInCluster || !clusterAdvance)
                 continue;
 
             float glyphAdvanceX = clusterAdvance / graphemesInCluster;
             for (unsigned j = 0; j < graphemesInCluster; ++j) {
                 // Do not put emphasis marks on space, separator, and control characters.
                 Glyph glyphToAdd = Character::canReceiveTextEmphasis(m_run[currentCharacterIndex]) ? 1 : 0;
                 // The emphasis code expects mid-glyph offsets.
                 glyphBuffer->add(glyphToAdd, currentRun->fontData(), advanceSoFar + glyphAdvanceX / 2);
                 advanceSoFar += glyphAdvanceX;
@@ skipping 23 matching lines @@
     }
     return glyphBuffer->size();
 }
 
 int HarfBuzzShaper::offsetForPosition(float targetX)
 {
     int charactersSoFar = 0;
     float currentX = 0;
 
     if (m_run.rtl()) {
-        charactersSoFar = m_normalizedBufferLength;
+        charactersSoFar = m_run.length();
         for (int i = m_harfBuzzRuns.size() - 1; i >= 0; --i) {
             charactersSoFar -= m_harfBuzzRuns[i]->numCharacters();
             float nextX = currentX + m_harfBuzzRuns[i]->width();
             float offsetForRun = targetX - currentX;
             if (offsetForRun >= 0 && offsetForRun <= m_harfBuzzRuns[i]->width()) {
                 // The x value in question is within this script run.
                 const unsigned index = m_harfBuzzRuns[i]->characterIndexForXPosition(offsetForRun);
                 return charactersSoFar + index;
             }
             currentX = nextX;
@@ skipping 57 matching lines @@
     // possibly invalid from, to arguments.
     if (!foundToX && !foundFromX)
         fromX = toX = 0;
 
     if (fromX < toX)
         return FloatRect(point.x() + fromX, point.y(), toX - fromX, height);
     return FloatRect(point.x() + toX, point.y(), fromX - toX, height);
 }
 
 } // namespace blink