Switch to HarfBuzz on Mac and remove CoreText shaper

Source/platform/fonts/mac/ComplexTextController.cpp

Index: Source/platform/fonts/mac/ComplexTextController.cpp
diff --git a/Source/platform/fonts/mac/ComplexTextController.cpp b/Source/platform/fonts/mac/ComplexTextController.cpp
deleted file mode 100644
index b3048b5c13eaa898f2fd4f271dbd44a426b2081e..0000000000000000000000000000000000000000
--- a/Source/platform/fonts/mac/ComplexTextController.cpp
+++ /dev/null
@@ -1,614 +0,0 @@
-/*
- * Copyright (C) 2007, 2008, 2009, 2010, 2011 Apple 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
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "platform/fonts/mac/ComplexTextController.h"
-
-#include "platform/fonts/Character.h"
-#include "platform/fonts/Font.h"
-#include "platform/fonts/GlyphBuffer.h"
-#include "platform/geometry/FloatSize.h"
-#include "platform/text/TextBreakIterator.h"
-#include "platform/text/TextRun.h"
-#include "wtf/StdLibExtras.h"
-#include "wtf/unicode/CharacterNames.h"
-#include <ApplicationServices/ApplicationServices.h>
-
-namespace blink {
-
-ComplexTextController::ComplexTextController(const Font* font, const TextRun& run, bool mayUseNaturalWritingDirection, HashSet<const SimpleFontData*>* fallbackFonts, bool forTextEmphasis)
-    : m_font(*font)
-    , m_run(run)
-    , m_isLTROnly(true)
-    , m_mayUseNaturalWritingDirection(mayUseNaturalWritingDirection)
-    , m_forTextEmphasis(forTextEmphasis)
-    , m_currentCharacter(0)
-    , m_end(run.length())
-    , m_totalWidth(0)
-    , m_runWidthSoFar(0)
-    , m_numGlyphsSoFar(0)
-    , m_currentRun(0)
-    , m_glyphInCurrentRun(0)
-    , m_characterInCurrentGlyph(0)
-    , m_expansion(run.expansion())
-    , m_leadingExpansion(0)
-    , m_afterExpansion(!run.allowsLeadingExpansion())
-    , m_fallbackFonts(fallbackFonts)
-    , m_minGlyphBoundingBoxX(std::numeric_limits<float>::max())
-    , m_maxGlyphBoundingBoxX(std::numeric_limits<float>::min())
-    , m_minGlyphBoundingBoxY(std::numeric_limits<float>::max())
-    , m_maxGlyphBoundingBoxY(std::numeric_limits<float>::min())
-{
-    if (!m_expansion)
-        m_expansionPerOpportunity = 0;
-    else {
-        bool isAfterExpansion = m_afterExpansion;
-        unsigned expansionOpportunityCount;
-        if (m_run.is8Bit())
-            expansionOpportunityCount = Character::expansionOpportunityCount(m_run.characters8(), m_end, m_run.direction(), isAfterExpansion);
-         else
-            expansionOpportunityCount = Character::expansionOpportunityCount(m_run.characters16(), m_end, m_run.direction(), isAfterExpansion);
-        if (isAfterExpansion && !m_run.allowsTrailingExpansion())
-            expansionOpportunityCount--;
-
-        if (!expansionOpportunityCount)
-            m_expansionPerOpportunity = 0;
-        else
-            m_expansionPerOpportunity = m_expansion / expansionOpportunityCount;
-    }
-
-    collectComplexTextRuns();
-    adjustGlyphsAndAdvances();
-
-    if (!m_isLTROnly) {
-        m_runIndices.reserveInitialCapacity(m_complexTextRuns.size());
-
-        m_glyphCountFromStartToIndex.reserveInitialCapacity(m_complexTextRuns.size());
-        unsigned glyphCountSoFar = 0;
-        for (unsigned i = 0; i < m_complexTextRuns.size(); ++i) {
-            m_glyphCountFromStartToIndex.uncheckedAppend(glyphCountSoFar);
-            glyphCountSoFar += m_complexTextRuns[i]->glyphCount();
-        }
-    }
-
-    m_runWidthSoFar = m_leadingExpansion;
-}
-
-int ComplexTextController::offsetForPosition(float h, bool includePartialGlyphs)
-{
-    if (h >= m_totalWidth)
-        return m_run.ltr() ? m_end : 0;
-
-    h -= m_leadingExpansion;
-    if (h < 0)
-        return m_run.ltr() ? 0 : m_end;
-
-    CGFloat x = h;
-
-    size_t runCount = m_complexTextRuns.size();
-    size_t offsetIntoAdjustedGlyphs = 0;
-
-    for (size_t r = 0; r < runCount; ++r) {
-        const ComplexTextRun& complexTextRun = *m_complexTextRuns[r];
-        for (unsigned j = 0; j < complexTextRun.glyphCount(); ++j) {
-            CGFloat adjustedAdvance = m_adjustedAdvances[offsetIntoAdjustedGlyphs + j].width;
-            if (x < adjustedAdvance) {
-                CFIndex hitGlyphStart = complexTextRun.indexAt(j);
-                CFIndex hitGlyphEnd;
-                if (m_run.ltr())
-                    hitGlyphEnd = std::max<CFIndex>(hitGlyphStart, j + 1 < complexTextRun.glyphCount() ? complexTextRun.indexAt(j + 1) : static_cast<CFIndex>(complexTextRun.indexEnd()));
-                else
-                    hitGlyphEnd = std::max<CFIndex>(hitGlyphStart, j > 0 ? complexTextRun.indexAt(j - 1) : static_cast<CFIndex>(complexTextRun.indexEnd()));
-
-                // FIXME: Instead of dividing the glyph's advance equally between the characters, this
-                // could use the glyph's "ligature carets". However, there is no Core Text API to get the
-                // ligature carets.
-                CFIndex hitIndex = hitGlyphStart + (hitGlyphEnd - hitGlyphStart) * (m_run.ltr() ? x / adjustedAdvance : 1 - x / adjustedAdvance);
-                int stringLength = complexTextRun.stringLength();
-                TextBreakIterator* cursorPositionIterator = cursorMovementIterator(complexTextRun.characters(), stringLength);
-                int clusterStart;
-                if (cursorPositionIterator->isBoundary(hitIndex))
-                    clusterStart = hitIndex;
-                else {
-                    clusterStart = cursorPositionIterator->preceding(hitIndex);
-                    if (clusterStart == TextBreakDone)
-                        clusterStart = 0;
-                }
-
-                if (!includePartialGlyphs)
-                    return complexTextRun.stringLocation() + clusterStart;
-
-                int clusterEnd = cursorPositionIterator->following(hitIndex);
-                if (clusterEnd == TextBreakDone)
-                    clusterEnd = stringLength;
-
-                CGFloat clusterWidth;
-                // FIXME: The search stops at the boundaries of complexTextRun. In theory, it should go on into neighboring ComplexTextRuns
-                // derived from the same CTLine. In practice, we do not expect there to be more than one CTRun in a CTLine, as no
-                // reordering and no font fallback should occur within a CTLine.
-                if (clusterEnd - clusterStart > 1) {
-                    clusterWidth = adjustedAdvance;
-                    int firstGlyphBeforeCluster = j - 1;
-                    while (firstGlyphBeforeCluster >= 0 && complexTextRun.indexAt(firstGlyphBeforeCluster) >= clusterStart && complexTextRun.indexAt(firstGlyphBeforeCluster) < clusterEnd) {
-                        CGFloat width = m_adjustedAdvances[offsetIntoAdjustedGlyphs + firstGlyphBeforeCluster].width;
-                        clusterWidth += width;
-                        x += width;
-                        firstGlyphBeforeCluster--;
-                    }
-                    unsigned firstGlyphAfterCluster = j + 1;
-                    while (firstGlyphAfterCluster < complexTextRun.glyphCount() && complexTextRun.indexAt(firstGlyphAfterCluster) >= clusterStart && complexTextRun.indexAt(firstGlyphAfterCluster) < clusterEnd) {
-                        clusterWidth += m_adjustedAdvances[offsetIntoAdjustedGlyphs + firstGlyphAfterCluster].width;
-                        firstGlyphAfterCluster++;
-                    }
-                } else {
-                    clusterWidth = adjustedAdvance / (hitGlyphEnd - hitGlyphStart);
-                    x -=  clusterWidth * (m_run.ltr() ? hitIndex - hitGlyphStart : hitGlyphEnd - hitIndex - 1);
-                }
-                if (x <= clusterWidth / 2)
-                    return complexTextRun.stringLocation() + (m_run.ltr() ? clusterStart : clusterEnd);
-                else
-                    return complexTextRun.stringLocation() + (m_run.ltr() ? clusterEnd : clusterStart);
-            }
-            x -= adjustedAdvance;
-        }
-        offsetIntoAdjustedGlyphs += complexTextRun.glyphCount();
-    }
-
-    ASSERT_NOT_REACHED();
-    return 0;
-}
-
-static bool advanceByCombiningCharacterSequence(const UChar*& iterator, const UChar* end, UChar32& baseCharacter, unsigned& markCount)
-{
-    ASSERT(iterator < end);
-
-    markCount = 0;
-
-    baseCharacter = *iterator++;
-
-    if (U16_IS_SURROGATE(baseCharacter)) {
-        if (!U16_IS_LEAD(baseCharacter))
-            return false;
-        if (iterator == end)
-            return false;
-        UChar trail = *iterator++;
-        if (!U16_IS_TRAIL(trail))
-            return false;
-        baseCharacter = U16_GET_SUPPLEMENTARY(baseCharacter, trail);
-    }
-
-    // Consume marks.
-    while (iterator < end) {
-        UChar32 nextCharacter;
-        int markLength = 0;
-        U16_NEXT(iterator, markLength, end - iterator, nextCharacter);
-        if (!(U_GET_GC_MASK(nextCharacter) & U_GC_M_MASK))
-            break;
-        markCount += markLength;
-        iterator += markLength;
-    }
-
-    return true;
-}
-
-void ComplexTextController::collectComplexTextRuns()
-{
-    if (!m_end)
-        return;
-
-    // We break up glyph run generation for the string by FontData.
-    const UChar* cp;
-
-    if (m_run.is8Bit()) {
-        String stringFor8BitRun = String::make16BitFrom8BitSource(m_run.characters8(), m_run.length());
-        cp = stringFor8BitRun.characters16();
-        m_stringsFor8BitRuns.append(stringFor8BitRun);
-    } else
-        cp = m_run.characters16();
-
-    if (m_font.fontDescription().variant() == FontVariantSmallCaps)
-        m_smallCapsBuffer.resize(m_end);
-
-    unsigned indexOfFontTransition = 0;
-    const UChar* curr = cp;
-    const UChar* end = cp + m_end;
-
-    const SimpleFontData* fontData;
-    bool isMissingGlyph;
-    const SimpleFontData* nextFontData;
-    bool nextIsMissingGlyph;
-
-    unsigned markCount;
-    const UChar* sequenceStart = curr;
-    UChar32 baseCharacter;
-    if (!advanceByCombiningCharacterSequence(curr, end, baseCharacter, markCount))
-        return;
-
-    UChar uppercaseCharacter = 0;
-
-    bool isSmallCaps;
-    bool nextIsSmallCaps = m_font.fontDescription().variant() == FontVariantSmallCaps && !(U_GET_GC_MASK(baseCharacter) & U_GC_M_MASK) && (uppercaseCharacter = u_toupper(baseCharacter)) != baseCharacter;
-
-    if (nextIsSmallCaps) {
-        m_smallCapsBuffer[sequenceStart - cp] = uppercaseCharacter;
-        for (unsigned i = 0; i < markCount; ++i)
-            m_smallCapsBuffer[sequenceStart - cp + i + 1] = sequenceStart[i + 1];
-    }
-
-    nextIsMissingGlyph = false;
-    nextFontData = m_font.fontDataForCombiningCharacterSequence(sequenceStart, curr - sequenceStart, nextIsSmallCaps ? SmallCapsVariant : NormalVariant);
-    if (!nextFontData)
-        nextIsMissingGlyph = true;
-
-    while (curr < end) {
-        fontData = nextFontData;
-        isMissingGlyph = nextIsMissingGlyph;
-        isSmallCaps = nextIsSmallCaps;
-        int index = curr - cp;
-
-        if (!advanceByCombiningCharacterSequence(curr, end, baseCharacter, markCount))
-            return;
-
-        if (m_font.fontDescription().variant()) {
-            nextIsSmallCaps = (uppercaseCharacter = u_toupper(baseCharacter)) != baseCharacter;
-            if (nextIsSmallCaps) {
-                m_smallCapsBuffer[index] = uppercaseCharacter;
-                for (unsigned i = 0; i < markCount; ++i)
-                    m_smallCapsBuffer[index + i + 1] = cp[index + i + 1];
-            }
-        }
-
-        nextIsMissingGlyph = false;
-        if (baseCharacter == zeroWidthJoiner)
-            nextFontData = fontData;
-        else {
-            nextFontData = m_font.fontDataForCombiningCharacterSequence(cp + index, curr - cp - index, nextIsSmallCaps ? SmallCapsVariant : NormalVariant);
-            if (!nextFontData)
-                nextIsMissingGlyph = true;
-        }
-
-        if (nextFontData != fontData || nextIsMissingGlyph != isMissingGlyph) {
-            int itemStart = static_cast<int>(indexOfFontTransition);
-            int itemLength = index - indexOfFontTransition;
-            collectComplexTextRunsForCharacters((isSmallCaps ? m_smallCapsBuffer.data() : cp) + itemStart, itemLength, itemStart, !isMissingGlyph ? fontData : 0);
-            indexOfFontTransition = index;
-        }
-    }
-
-    int itemLength = m_end - indexOfFontTransition;
-    if (itemLength) {
-        int itemStart = indexOfFontTransition;
-        collectComplexTextRunsForCharacters((nextIsSmallCaps ? m_smallCapsBuffer.data() : cp) + itemStart, itemLength, itemStart, !nextIsMissingGlyph ? nextFontData : 0);
-    }
-
-    if (!m_run.ltr())
-        m_complexTextRuns.reverse();
-}
-
-CFIndex ComplexTextController::ComplexTextRun::indexAt(size_t i) const
-{
-    return m_coreTextIndices[i];
-}
-
-void ComplexTextController::ComplexTextRun::setIsNonMonotonic()
-{
-    ASSERT(m_isMonotonic);
-    m_isMonotonic = false;
-
-    Vector<bool, 64> mappedIndices(m_stringLength);
-    for (size_t i = 0; i < m_glyphCount; ++i) {
-        ASSERT(indexAt(i) < static_cast<CFIndex>(m_stringLength));
-        mappedIndices[indexAt(i)] = true;
-    }
-
-    m_glyphEndOffsets.grow(m_glyphCount);
-    for (size_t i = 0; i < m_glyphCount; ++i) {
-        CFIndex nextMappedIndex = m_indexEnd;
-        for (size_t j = indexAt(i) + 1; j < m_stringLength; ++j) {
-            if (mappedIndices[j]) {
-                nextMappedIndex = j;
-                break;
-            }
-        }
-        m_glyphEndOffsets[i] = nextMappedIndex;
-    }
-}
-
-unsigned ComplexTextController::findNextRunIndex(unsigned runIndex) const
-{
-    const unsigned runOffset = stringEnd(*m_complexTextRuns[runIndex]);
-
-    // Finds the run with the lowest stringBegin() offset that starts at or
-    // after |runOffset|.
-    //
-    // Note that this can't just find a run whose stringBegin() equals the
-    // stringEnd() of the previous run because CoreText on Mac OS X 10.6 does
-    // not return runs covering BiDi control chars, so this has to handle the
-    // resulting gaps.
-    unsigned result = 0;
-    unsigned lowestOffset = UINT_MAX;
-    for (unsigned i = 0; i < m_complexTextRuns.size(); ++i) {
-        unsigned offset = stringBegin(*m_complexTextRuns[i]);
-        if (i != runIndex && offset >= runOffset && offset < lowestOffset) {
-            lowestOffset = offset;
-            result = i;
-        }
-    }
-
-    ASSERT(lowestOffset != UINT_MAX);
-    return result;
-}
-
-unsigned ComplexTextController::indexOfCurrentRun(unsigned& leftmostGlyph)
-{
-    leftmostGlyph = 0;
-
-    size_t runCount = m_complexTextRuns.size();
-    if (m_currentRun >= runCount)
-        return runCount;
-
-    if (m_isLTROnly) {
-        for (unsigned i = 0; i < m_currentRun; ++i)
-            leftmostGlyph += m_complexTextRuns[i]->glyphCount();
-        return m_currentRun;
-    }
-
-    if (m_runIndices.isEmpty()) {
-        unsigned firstRun = 0;
-        unsigned firstRunOffset = stringBegin(*m_complexTextRuns[0]);
-        for (unsigned i = 1; i < runCount; ++i) {
-            unsigned offset = stringBegin(*m_complexTextRuns[i]);
-            if (offset < firstRunOffset) {
-                firstRun = i;
-                firstRunOffset = offset;
-            }
-        }
-        m_runIndices.uncheckedAppend(firstRun);
-    }
-
-    while (m_runIndices.size() <= m_currentRun) {
-        m_runIndices.uncheckedAppend(findNextRunIndex(m_runIndices.last()));
-    }
-
-    unsigned currentRunIndex = m_runIndices[m_currentRun];
-    leftmostGlyph = m_glyphCountFromStartToIndex[currentRunIndex];
-    return currentRunIndex;
-}
-
-unsigned ComplexTextController::incrementCurrentRun(unsigned& leftmostGlyph)
-{
-    if (m_isLTROnly) {
-        leftmostGlyph += m_complexTextRuns[m_currentRun++]->glyphCount();
-        return m_currentRun;
-    }
-
-    m_currentRun++;
-    leftmostGlyph = 0;
-    return indexOfCurrentRun(leftmostGlyph);
-}
-
-void ComplexTextController::advance(unsigned offset, GlyphBuffer* glyphBuffer, GlyphIterationStyle iterationStyle, HashSet<const SimpleFontData*>* fallbackFonts)
-{
-    if (static_cast<int>(offset) > m_end)
-        offset = m_end;
-
-    if (offset <= m_currentCharacter) {
-        m_runWidthSoFar = m_leadingExpansion;
-        m_numGlyphsSoFar = 0;
-        m_currentRun = 0;
-        m_glyphInCurrentRun = 0;
-        m_characterInCurrentGlyph = 0;
-    }
-
-    m_currentCharacter = offset;
-
-    size_t runCount = m_complexTextRuns.size();
-
-    unsigned leftmostGlyph = 0;
-    unsigned currentRunIndex = indexOfCurrentRun(leftmostGlyph);
-    while (m_currentRun < runCount) {
-        const ComplexTextRun& complexTextRun = *m_complexTextRuns[currentRunIndex];
-        bool ltr = complexTextRun.isLTR();
-        size_t glyphCount = complexTextRun.glyphCount();
-        unsigned g = ltr ? m_glyphInCurrentRun : glyphCount - 1 - m_glyphInCurrentRun;
-        unsigned k = leftmostGlyph + g;
-        if (fallbackFonts && complexTextRun.fontData() != m_font.primaryFont())
-            fallbackFonts->add(complexTextRun.fontData());
-
-        while (m_glyphInCurrentRun < glyphCount) {
-            unsigned glyphStartOffset = complexTextRun.indexAt(g);
-            unsigned glyphEndOffset;
-            if (complexTextRun.isMonotonic()) {
-                if (ltr)
-                    glyphEndOffset = std::max<unsigned>(glyphStartOffset, static_cast<unsigned>(g + 1 < glyphCount ? complexTextRun.indexAt(g + 1) : complexTextRun.indexEnd()));
-                else
-                    glyphEndOffset = std::max<unsigned>(glyphStartOffset, static_cast<unsigned>(g > 0 ? complexTextRun.indexAt(g - 1) : complexTextRun.indexEnd()));
-            } else
-                glyphEndOffset = complexTextRun.endOffsetAt(g);
-
-            CGSize adjustedAdvance = m_adjustedAdvances[k];
-
-            if (glyphStartOffset + complexTextRun.stringLocation() >= m_currentCharacter)
-                return;
-
-            if (glyphBuffer && !m_characterInCurrentGlyph)
-                glyphBuffer->add(m_adjustedGlyphs[k], complexTextRun.fontData(), FloatSize(adjustedAdvance));
-
-            unsigned oldCharacterInCurrentGlyph = m_characterInCurrentGlyph;
-            m_characterInCurrentGlyph = std::min(m_currentCharacter - complexTextRun.stringLocation(), glyphEndOffset) - glyphStartOffset;
-            // FIXME: Instead of dividing the glyph's advance equally between the characters, this
-            // could use the glyph's "ligature carets". However, there is no Core Text API to get the
-            // ligature carets.
-            if (glyphStartOffset == glyphEndOffset) {
-                // When there are multiple glyphs per character we need to advance by the full width of the glyph.
-                ASSERT(m_characterInCurrentGlyph == oldCharacterInCurrentGlyph);
-                m_runWidthSoFar += adjustedAdvance.width;
-            } else if (iterationStyle == ByWholeGlyphs) {
-                if (!oldCharacterInCurrentGlyph)
-                    m_runWidthSoFar += adjustedAdvance.width;
-            } else
-                m_runWidthSoFar += adjustedAdvance.width * (m_characterInCurrentGlyph - oldCharacterInCurrentGlyph) / (glyphEndOffset - glyphStartOffset);
-
-            if (glyphEndOffset + complexTextRun.stringLocation() > m_currentCharacter)
-                return;
-
-            m_numGlyphsSoFar++;
-            m_glyphInCurrentRun++;
-            m_characterInCurrentGlyph = 0;
-            if (ltr) {
-                g++;
-                k++;
-            } else {
-                g--;
-                k--;
-            }
-        }
-        currentRunIndex = incrementCurrentRun(leftmostGlyph);
-        m_glyphInCurrentRun = 0;
-    }
-}
-
-void ComplexTextController::adjustGlyphsAndAdvances()
-{
-    CGFloat widthSinceLastCommit = 0;
-    size_t runCount = m_complexTextRuns.size();
-    bool hasExtraSpacing = (m_font.fontDescription().letterSpacing() || m_font.fontDescription().wordSpacing() || m_expansion) && !m_run.spacingDisabled();
-    for (size_t r = 0; r < runCount; ++r) {
-        ComplexTextRun& complexTextRun = *m_complexTextRuns[r];
-        unsigned glyphCount = complexTextRun.glyphCount();
-        const SimpleFontData* fontData = complexTextRun.fontData();
-
-        if (!complexTextRun.isLTR())
-            m_isLTROnly = false;
-
-        const CGGlyph* glyphs = complexTextRun.glyphs();
-        const CGSize* advances = complexTextRun.advances();
-
-        bool lastRun = r + 1 == runCount;
-        bool roundsAdvances = fontData->platformData().roundsGlyphAdvances();
-        float spaceWidth = fontData->spaceWidth() - fontData->syntheticBoldOffset();
-        const UChar* cp = complexTextRun.characters();
-        CGPoint glyphOrigin = CGPointZero;
-        CFIndex lastCharacterIndex = m_run.ltr() ? std::numeric_limits<CFIndex>::min() : std::numeric_limits<CFIndex>::max();
-        bool isMonotonic = true;
-
-        for (unsigned i = 0; i < glyphCount; i++) {
-            CFIndex characterIndex = complexTextRun.indexAt(i);
-            if (m_run.ltr()) {
-                if (characterIndex < lastCharacterIndex)
-                    isMonotonic = false;
-            } else {
-                if (characterIndex > lastCharacterIndex)
-                    isMonotonic = false;
-            }
-            UChar ch = *(cp + characterIndex);
-            bool lastGlyph = lastRun && i + 1 == glyphCount;
-            UChar nextCh;
-            if (lastGlyph)
-                nextCh = ' ';
-            else if (i + 1 < glyphCount)
-                nextCh = *(cp + complexTextRun.indexAt(i + 1));
-            else
-                nextCh = *(m_complexTextRuns[r + 1]->characters() + m_complexTextRuns[r + 1]->indexAt(0));
-
-            bool treatAsSpace = Character::treatAsSpace(ch);
-            CGGlyph glyph = treatAsSpace ? fontData->spaceGlyph() : glyphs[i];
-            CGSize advance = treatAsSpace ? CGSizeMake(spaceWidth, advances[i].height) : advances[i];
-
-            if (ch == '\t' && m_run.allowTabs()) {
-                advance.width = m_font.tabWidth(*fontData, m_run.tabSize(), m_run.xPos() + m_totalWidth + widthSinceLastCommit);
-            } else if (Character::treatAsZeroWidthSpace(ch) && !treatAsSpace) {
-                advance.width = 0;
-                glyph = fontData->spaceGlyph();
-            }
-
-            float roundedAdvanceWidth = roundf(advance.width);
-            if (roundsAdvances)
-                advance.width = roundedAdvanceWidth;
-
-            advance.width += fontData->syntheticBoldOffset();
-
-            if (hasExtraSpacing) {
-                // If we're a glyph with an advance, go ahead and add in letter-spacing.
-                // That way we weed out zero width lurkers.  This behavior matches the fast text code path.
-                if (advance.width && m_font.fontDescription().letterSpacing())
-                    advance.width += m_font.fontDescription().letterSpacing();
-
-                // Handle justification and word-spacing.
-                if (treatAsSpace || Character::isCJKIdeographOrSymbol(ch)) {
-                    // Distribute the run's total expansion evenly over all expansion opportunities in the run.
-                    if (m_expansion) {
-                        if (!treatAsSpace && !m_afterExpansion) {
-                            // Take the expansion opportunity before this ideograph.
-                            m_expansion -= m_expansionPerOpportunity;
-                            float expansionAtThisOpportunity = m_expansionPerOpportunity;
-                            m_totalWidth += expansionAtThisOpportunity;
-                            if (m_adjustedAdvances.isEmpty())
-                                m_leadingExpansion = expansionAtThisOpportunity;
-                            else
-                                m_adjustedAdvances.last().width += expansionAtThisOpportunity;
-                        }
-                        if (!lastGlyph || m_run.allowsTrailingExpansion()) {
-                            m_expansion -= m_expansionPerOpportunity;
-                            advance.width += m_expansionPerOpportunity;
-                            m_afterExpansion = true;
-                        }
-                    } else
-                        m_afterExpansion = false;
-
-                    // Account for word-spacing.
-                    if (treatAsSpace && (ch != '\t' || !m_run.allowTabs()) && (characterIndex > 0 || r > 0) && m_font.fontDescription().wordSpacing())
-                        advance.width += m_font.fontDescription().wordSpacing();
-                } else
-                    m_afterExpansion = false;
-            }
-
-            widthSinceLastCommit += advance.width;
-
-            // FIXME: Combining marks should receive a text emphasis mark if they are combine with a space.
-            if (m_forTextEmphasis && (!Character::canReceiveTextEmphasis(ch) || (U_GET_GC_MASK(ch) & U_GC_M_MASK)))
-                glyph = 0;
-
-            advance.height *= -1;
-            m_adjustedAdvances.append(advance);
-            m_adjustedGlyphs.append(glyph);
-
-            FloatRect glyphBounds = fontData->boundsForGlyph(glyph);
-            glyphBounds.move(glyphOrigin.x, glyphOrigin.y);
-            m_minGlyphBoundingBoxX = std::min(m_minGlyphBoundingBoxX, glyphBounds.x());
-            m_maxGlyphBoundingBoxX = std::max(m_maxGlyphBoundingBoxX, glyphBounds.maxX());
-            m_minGlyphBoundingBoxY = std::min(m_minGlyphBoundingBoxY, glyphBounds.y());
-            m_maxGlyphBoundingBoxY = std::max(m_maxGlyphBoundingBoxY, glyphBounds.maxY());
-            glyphOrigin.x += advance.width;
-            glyphOrigin.y += advance.height;
-
-            lastCharacterIndex = characterIndex;
-        }
-        if (!isMonotonic)
-            complexTextRun.setIsNonMonotonic();
-    }
-    m_totalWidth += widthSinceLastCommit;
-}
-
-} // namespace blink