Attachment #300740 for bug #167833

View Details Raw Unified Return to Bug 167833

| Differences between



2017-02-06  Myles C. Maxfield  <mmaxfield@apple.com>

        Migrate ComplexTextController to use platform-independent types
        https://bugs.webkit.org/show_bug.cgi?id=167833

        Reviewed by NOBODY (OOPS!).

        ComplexTextController will eventually be used on all ports to perform complex text layout.
        This is a mechanical patch which migrates the shared parts of ComplexTextController away from
        using CoreGraphics and CoreFoundation types in favor of WebCore/platform types. Eventually,
        ComplexTextController will get moved to PAL but there is a layering violation (TextLayout) to
        fix first.

        No new tests because there is no behavior change.

        * platform/graphics/GlyphBuffer.h:
        (WebCore::GlyphBufferAdvance::GlyphBufferAdvance):
        * platform/graphics/mac/ComplexTextController.cpp:
        (WebCore::ComplexTextController::offsetForPosition):
        (WebCore::advanceByCombiningCharacterSequence):
        (WebCore::ComplexTextController::ComplexTextRun::indexAt):
        (WebCore::ComplexTextController::ComplexTextRun::setIsNonMonotonic):
        (WebCore::ComplexTextController::advance):
        (WebCore::ComplexTextController::adjustGlyphsAndAdvances):
        * platform/graphics/mac/ComplexTextController.h:
        (WebCore::ComplexTextController::ComplexTextRun::create):
        (WebCore::ComplexTextController::ComplexTextRun::stringLength):
        (WebCore::ComplexTextController::ComplexTextRun::indexBegin):
        (WebCore::ComplexTextController::ComplexTextRun::indexEnd):
        (WebCore::ComplexTextController::ComplexTextRun::endOffsetAt):
        (WebCore::ComplexTextController::ComplexTextRun::glyphs):
        (WebCore::ComplexTextController::ComplexTextRun::growInitialAdvanceHorizontally):
        (WebCore::ComplexTextController::ComplexTextRun::initialAdvance):
        (WebCore::ComplexTextController::ComplexTextRun::baseAdvances):
        (WebCore::ComplexTextController::ComplexTextRun::glyphOrigins):
        (WebCore::ComplexTextController::glyphOrigin):
        (WebCore::ComplexTextController::ComplexTextRun::createForTesting): Deleted.
        * platform/graphics/mac/ComplexTextControllerCoreText.mm:
        (SOFT_LINK):
        (WebCore::ComplexTextController::ComplexTextRun::ComplexTextRun):
        (WebCore::ComplexTextController::collectComplexTextRunsForCharacters):

2017-02-06  Said Abou-Hallawa  <sabouhallawa@apple.com>

        Rename AnimationController to CSSAnimationController

Lines 62-68 typedef Glyph GlyphBufferGlyph; a/Source/WebCore/platform/graphics/GlyphBuffer.h_sec1
- a/Source/WebCore/platform/graphics/GlyphBuffer.h -1 / +6 lines
62	struct GlyphBufferAdvance : CGSize {	62	struct GlyphBufferAdvance : CGSize {
63	public:	63	public:
64	GlyphBufferAdvance() : CGSize(CGSizeZero) { }	64	GlyphBufferAdvance() : CGSize(CGSizeZero) { }
65	GlyphBufferAdvance(CGSize size) : CGSize(size)	65	GlyphBufferAdvance(CGSize size)
		66	: CGSize(size)
		67	{
		68	}
		69	GlyphBufferAdvance(float width, float height)
		70	: CGSize(CGSizeMake(width, height))
66	{	71	{
67	}	72	}
68		73



    if (h < 0)
        return m_run.ltr() ? 0 : m_end;

    float x = h;

    size_t runCount = m_complexTextRuns.size();
    unsigned offsetIntoAdjustedGlyphs = 0;

    for (size_t r = 0; r < runCount; ++r) {
        const ComplexTextRun& complexTextRun = *m_complexTextRuns[r];
        for (unsigned j = 0; j < complexTextRun.glyphCount(); ++j) {
            unsigned index = offsetIntoAdjustedGlyphs + j;
            float adjustedAdvance = m_adjustedBaseAdvances[index].width();
            if (x < adjustedAdvance) {
                unsigned hitGlyphStart = complexTextRun.indexAt(j);
                unsigned hitGlyphEnd;
                if (m_run.ltr())
                    hitGlyphEnd = std::max(hitGlyphStart, j + 1 < complexTextRun.glyphCount() ? complexTextRun.indexAt(j + 1) : complexTextRun.indexEnd());
                else
                    hitGlyphEnd = std::max(hitGlyphStart, j > 0 ? complexTextRun.indexAt(j - 1) : complexTextRun.indexEnd());

                // FIXME: Instead of dividing the glyph's advance equally between the characters, this
                // could use the glyph's "ligature carets". This is available in CoreText via CTFontGetLigatureCaretPositions().
                unsigned hitIndex = hitGlyphStart + (hitGlyphEnd - hitGlyphStart) * (m_run.ltr() ? x / adjustedAdvance : 1 - x / adjustedAdvance);
                unsigned stringLength = complexTextRun.stringLength();
                UBreakIterator* cursorPositionIterator = cursorMovementIterator(StringView(complexTextRun.characters(), stringLength));
                unsigned clusterStart;
                if (ubrk_isBoundary(cursorPositionIterator, hitIndex))
                    clusterStart = hitIndex;
                else {
                    int preceeding = ubrk_preceding(cursorPositionIterator, hitIndex);
                    clusterStart = preceeding == UBRK_DONE ? 0 : preceeding;
                        clusterStart = 0;
                }

                if (!includePartialGlyphs)
                    return complexTextRun.stringLocation() + clusterStart;

                int following = ubrk_following(cursorPositionIterator, hitIndex);
                unsigned clusterEnd = following == UBRK_DONE ? stringLength : following;
                    clusterEnd = stringLength;

                float 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;
                    if (j) {
                        unsigned firstGlyphBeforeCluster = j - 1;
                        while (complexTextRun.indexAt(firstGlyphBeforeCluster) >= clusterStart && complexTextRun.indexAt(firstGlyphBeforeCluster) < clusterEnd) {
                            float width = m_adjustedBaseAdvances[offsetIntoAdjustedGlyphs + firstGlyphBeforeCluster].width();
                            clusterWidth += width;
                            x += width;
                            if (!firstGlyphBeforeCluster)
                                break;
                            firstGlyphBeforeCluster--;
                        }
                    }
                    unsigned firstGlyphAfterCluster = j + 1;
                    while (firstGlyphAfterCluster < complexTextRun.glyphCount() && complexTextRun.indexAt(firstGlyphAfterCluster) >= clusterStart && complexTextRun.indexAt(firstGlyphAfterCluster) < clusterEnd) {
                        clusterWidth += m_adjustedBaseAdvances[offsetIntoAdjustedGlyphs + firstGlyphAfterCluster].width();
                        firstGlyphAfterCluster++;
                    }
                } else {

                }
                if (x <= clusterWidth / 2)
                    return complexTextRun.stringLocation() + (m_run.ltr() ? clusterStart : clusterEnd);
                return complexTextRun.stringLocation() + (m_run.ltr() ? clusterEnd : clusterStart);
                    return complexTextRun.stringLocation() + (m_run.ltr() ? clusterEnd : clusterStart);
            }
            x -= adjustedAdvance;
        }

    bool sawJoiner = false;
    while (iterator < end) {
        UChar32 nextCharacter;
        unsigned markLength = 0;
        bool shouldContinue = false;
        ASSERT(end >= iterator);
        U16_NEXT(iterator, markLength, static_cast<unsigned>(end - iterator), nextCharacter);

        if (isVariationSelector(nextCharacter) || isEmojiFitzpatrickModifier(nextCharacter))
            shouldContinue = true;

        m_complexTextRuns.reverse();
}

unsigned ComplexTextController::ComplexTextRun::indexAt(unsigned i) const
{
    ASSERT(i < m_glyphCount);


    m_isMonotonic = false;

    Vector<bool, 64> mappedIndices(m_stringLength, false);
    for (unsigned i = 0; i < m_glyphCount; ++i) {
        ASSERT(indexAt(i) < m_stringLength);
        mappedIndices[indexAt(i)] = true;
    }

    m_glyphEndOffsets.grow(m_glyphCount);
    for (unsigned i = 0; i < m_glyphCount; ++i) {
        unsigned nextMappedIndex = m_indexEnd;
        for (unsigned j = indexAt(i) + 1; j < m_stringLength; ++j) {
            if (mappedIndices[j]) {
                nextMappedIndex = j;
                break;

    while (m_currentRun < runCount) {
        const ComplexTextRun& complexTextRun = *m_complexTextRuns[currentRunIndex];
        bool ltr = complexTextRun.isLTR();
        unsigned glyphCount = complexTextRun.glyphCount();
        unsigned glyphIndexIntoCurrentRun = ltr ? m_glyphInCurrentRun : glyphCount - 1 - m_glyphInCurrentRun;
        unsigned glyphIndexIntoComplexTextController = indexOfLeftmostGlyphInCurrentRun + glyphIndexIntoCurrentRun;
        if (fallbackFonts && &complexTextRun.font() != &m_font.primaryFont())

        // When leftmostGlyph is 0, it represents the first glyph to draw, taking into
        // account the text direction.
        if (!indexOfLeftmostGlyphInCurrentRun && glyphBuffer)
            glyphBuffer->setInitialAdvance(GlyphBufferAdvance(complexTextRun.initialAdvance().width(), complexTextRun.initialAdvance().height()));

        while (m_glyphInCurrentRun < glyphCount) {
            unsigned glyphStartOffset = complexTextRun.indexAt(glyphIndexIntoCurrentRun);
            unsigned glyphEndOffset;
            if (complexTextRun.isMonotonic()) {
                if (ltr)
                    glyphEndOffset = std::max(glyphStartOffset, glyphIndexIntoCurrentRun + 1 < glyphCount ? complexTextRun.indexAt(glyphIndexIntoCurrentRun + 1) : complexTextRun.indexEnd());
                else
                    glyphEndOffset = std::max(glyphStartOffset, glyphIndexIntoCurrentRun > 0 ? complexTextRun.indexAt(glyphIndexIntoCurrentRun - 1) : complexTextRun.indexEnd());
            } else
                glyphEndOffset = complexTextRun.endOffsetAt(glyphIndexIntoCurrentRun);

            FloatSize adjustedBaseAdvance = m_adjustedBaseAdvances[glyphIndexIntoComplexTextController];

            if (glyphStartOffset + complexTextRun.stringLocation() >= m_currentCharacter)
                return;

            if (glyphBuffer && !m_characterInCurrentGlyph) {
                auto currentGlyphOrigin = glyphOrigin(glyphIndexIntoComplexTextController);
                GlyphBufferAdvance paintAdvance(adjustedBaseAdvance);
                if (!glyphIndexIntoCurrentRun) {
                    // The first layout advance of every run includes the "initial layout advance." However, here, we need
                    // paint advances, so subtract it out before transforming the layout advance into a paint advance.
                    paintAdvance.setWidth(paintAdvance.width() - (complexTextRun.initialAdvance().width() - currentGlyphOrigin.x()));
                    paintAdvance.setHeight(paintAdvance.height() - (complexTextRun.initialAdvance().height() - currentGlyphOrigin.y()));
                }
                paintAdvance.setWidth(paintAdvance.width() + glyphOrigin(glyphIndexIntoComplexTextController + 1).x() - currentGlyphOrigin.x());
                paintAdvance.setHeight(paintAdvance.height() + glyphOrigin(glyphIndexIntoComplexTextController + 1).y() - currentGlyphOrigin.y());
                if (glyphIndexIntoCurrentRun == glyphCount - 1 && currentRunIndex + 1 < runCount) {
                    // Our paint advance points to the end of the run. However, the next run may have an
                    // initial advance, and our paint advance needs to point to the location of the next
                    // glyph. So, we need to add in the next run's initial advance.
                    paintAdvance.setWidth(paintAdvance.width() - glyphOrigin(glyphIndexIntoComplexTextController + 1).x() + m_complexTextRuns[currentRunIndex + 1]->initialAdvance().width());
                    paintAdvance.setHeight(paintAdvance.height() - glyphOrigin(glyphIndexIntoComplexTextController + 1).y() + m_complexTextRuns[currentRunIndex + 1]->initialAdvance().height());
                }
                paintAdvance.setHeight(-paintAdvance.height()); // Increasing y points down
                glyphBuffer->add(m_adjustedGlyphs[glyphIndexIntoComplexTextController], &complexTextRun.font(), paintAdvance, complexTextRun.indexAt(m_glyphInCurrentRun));


            unsigned oldCharacterInCurrentGlyph = m_characterInCurrentGlyph;
            m_characterInCurrentGlyph = std::min(m_currentCharacter - complexTextRun.stringLocation(), glyphEndOffset) - glyphStartOffset;
            m_runWidthSoFar += adjustedBaseAdvance.width() * runWidthSoFarFraction(glyphStartOffset, glyphEndOffset, oldCharacterInCurrentGlyph, iterationStyle);

            if (glyphEndOffset + complexTextRun.stringLocation() > m_currentCharacter)
                return;

void ComplexTextController::adjustGlyphsAndAdvances()
{
    bool afterExpansion = (m_run.expansionBehavior() & LeadingExpansionMask) == ForbidLeadingExpansion;
    float widthSinceLastCommit = 0;
    size_t runCount = m_complexTextRuns.size();
    bool hasExtraSpacing = (m_font.letterSpacing() || m_font.wordSpacing() || m_expansion) && !m_run.spacingDisabled();
    bool runForcesLeadingExpansion = (m_run.expansionBehavior() & LeadingExpansionMask) == ForceLeadingExpansion;

            m_isLTROnly = false;

        const CGGlyph* glyphs = complexTextRun.glyphs();
        const FloatSize* advances = complexTextRun.baseAdvances();

        bool lastRun = runIndex + 1 == runCount;
        float spaceWidth = font.spaceWidth() - font.syntheticBoldOffset();
        const UChar* cp = complexTextRun.characters();
        FloatPoint glyphOrigin;
        unsigned lastCharacterIndex = m_run.ltr() ? std::numeric_limits<unsigned>::min() : std::numeric_limits<unsigned>::max();
        bool isMonotonic = true;

        for (unsigned i = 0; i < glyphCount; i++) {
            unsigned characterIndex = complexTextRun.indexAt(i);
            if (m_run.ltr()) {
                if (characterIndex < lastCharacterIndex)
                    isMonotonic = false;


            bool treatAsSpace = FontCascade::treatAsSpace(ch);
            CGGlyph glyph = treatAsSpace ? font.spaceGlyph() : glyphs[i];
            FloatSize advance = treatAsSpace ? FloatSize(spaceWidth, advances[i].height()) : advances[i];

            if (ch == '\t' && m_run.allowTabs())
                advance.setWidth(m_font.tabWidth(font, m_run.tabSize(), m_run.xPos() + m_totalWidth + widthSinceLastCommit));
            else if (FontCascade::treatAsZeroWidthSpace(ch) && !treatAsSpace) {
                advance.setWidth(0);
                glyph = font.spaceGlyph();
            }

            if (!i) {
                advance.expand(complexTextRun.initialAdvance().width(), complexTextRun.initialAdvance().height());
                if (auto* origins = complexTextRun.glyphOrigins())
                    advance.expand(-origins[0].x(), -origins[0].y());
                    advance.width -= origins[0].x;
                    advance.height -= origins[0].y;
                }
            }

            advance.expand(font.syntheticBoldOffset(), 0);

            if (hasExtraSpacing) {
                // If we're a glyph with an advance, add in letter-spacing.
                // That way we weed out zero width lurkers. This behavior matches the fast text code path.
                if (advance.width())
                    advance.expand(m_font.letterSpacing(), 0);

                unsigned characterIndexInRun = characterIndex + complexTextRun.stringLocation();
                bool isFirstCharacter = !(characterIndex + complexTextRun.stringLocation());
                bool isLastCharacter = characterIndexInRun + 1 == m_run.length() || (U16_IS_LEAD(ch) && characterIndexInRun + 2 == m_run.length() && U16_IS_TRAIL(*(cp + characterIndex + 1)));

                bool forceLeadingExpansion = false; // On the left, regardless of m_run.ltr()
                bool forceTrailingExpansion = false; // On the right, regardless of m_run.ltr()

                        bool expandLeft, expandRight;
                        std::tie(expandLeft, expandRight) = expansionLocation(ideograph, treatAsSpace, m_run.ltr(), afterExpansion, forbidLeadingExpansion, forbidTrailingExpansion, forceLeadingExpansion, forceTrailingExpansion);
                        m_expansion -= m_expansionPerOpportunity;
                        advance.expand(m_expansionPerOpportunity, 0);
                        if (expandLeft) {
                            // Increase previous width
                            if (m_adjustedBaseAdvances.isEmpty())
                                complexTextRun.growInitialAdvanceHorizontally(m_expansionPerOpportunity);
                            else
                                m_adjustedBaseAdvances.last().expand(m_expansionPerOpportunity, 0);
                        }
                        if (expandRight)
                            afterExpansion = true;


                    // Account for word-spacing.
                    if (treatAsSpace && (ch != '\t' || !m_run.allowTabs()) && (characterIndex > 0 || runIndex > 0) && m_font.wordSpacing())
                        advance.expand(m_font.wordSpacing(), 0);
                } else
                    afterExpansion = false;
            }

            widthSinceLastCommit += advance.width();

            // FIXME: Combining marks should receive a text emphasis mark if they are combine with a space.
            if (m_forTextEmphasis && (!FontCascade::canReceiveTextEmphasis(ch) || (U_GET_GC_MASK(ch) & U_GC_M_MASK)))

            m_adjustedGlyphs.append(glyph);
            
            FloatRect glyphBounds = font.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.move(advance);
            glyphOrigin.y += advance.height;
            
            lastCharacterIndex = characterIndex;
        }



 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once
#define ComplexTextController_h

#include "FloatPoint.h"
#include "GlyphBuffer.h"
#include <wtf/HashSet.h>
#include <wtf/RefCounted.h>

typedef const struct __CTRun * CTRunRef;
typedef const struct __CTLine * CTLineRef;

namespace WTF {
template<> struct VectorTraits<CGPoint> : SimpleClassVectorTraits { };
}

namespace WebCore {

class FontCascade;


    class ComplexTextRun : public RefCounted<ComplexTextRun> {
    public:
        static Ref<ComplexTextRun> create(CTRunRef ctRun, const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd)
        {
            return adoptRef(*new ComplexTextRun(ctRun, font, characters, stringLocation, stringLength, indexBegin, indexEnd));
        }

        static Ref<ComplexTextRun> create(const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr)
        {
            return adoptRef(*new ComplexTextRun(font, characters, stringLocation, stringLength, indexBegin, indexEnd, ltr));
        }

        static Ref<ComplexTextRun> create(const Vector<FloatSize>& advances, const Vector<FloatPoint>& origins, const Vector<Glyph>& glyphs, const Vector<unsigned>& stringIndices, FloatSize initialAdvance, const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr)
        {
            return adoptRef(*new ComplexTextRun(advances, origins, glyphs, stringIndices, initialAdvance, font, characters, stringLocation, stringLength, indexBegin, indexEnd, ltr));
        }

        unsigned glyphCount() const { return m_glyphCount; }
        const Font& font() const { return m_font; }
        const UChar* characters() const { return m_characters; }
        unsigned stringLocation() const { return m_stringLocation; }
        unsigned stringLength() const { return m_stringLength; }
        ALWAYS_INLINE unsigned indexAt(unsigned) const;
        unsigned indexBegin() const { return m_indexBegin; }
        unsigned indexEnd() const { return m_indexEnd; }
        unsigned endOffsetAt(unsigned i) const { ASSERT(!m_isMonotonic); return m_glyphEndOffsets[i]; }
        const CGGlyph* glyphs() const { return m_glyphs.data(); }

        /*
         * This is the format of the information CoreText gives us about each run:

         *                X--------------------------------------------------X--------------------------X--------------------------X
         * (text position ^)                (layout advance)                       (layout advance)           (layout advance)
         */
        void growInitialAdvanceHorizontally(float delta) { m_initialAdvance.expand(delta, 0); }
        FloatSize initialAdvance() const { return m_initialAdvance; }
        const FloatSize* baseAdvances() const { return m_baseAdvances.data(); }
        const FloatPoint* glyphOrigins() const { return m_glyphOrigins.size() == glyphCount() ? m_glyphOrigins.data() : nullptr; }
        bool isLTR() const { return m_isLTR; }
        bool isMonotonic() const { return m_isMonotonic; }
        void setIsNonMonotonic();

    private:
        ComplexTextRun(CTRunRef, const Font&, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd);
        ComplexTextRun(const Font&, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr);
        WEBCORE_EXPORT ComplexTextRun(const Vector<FloatSize>& advances, const Vector<FloatPoint>& origins, const Vector<Glyph>& glyphs, const Vector<unsigned>& stringIndices, FloatSize initialAdvance, const Font&, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr);

        Vector<FloatSize, 64> m_baseAdvances;
        Vector<FloatPoint, 64> m_glyphOrigins;
        Vector<CGGlyph, 64> m_glyphs;
        Vector<unsigned, 64> m_glyphEndOffsets;
        Vector<unsigned, 64> m_coreTextIndices;
        FloatSize m_initialAdvance;
        const Font& m_font;
        const UChar* m_characters;
        unsigned m_stringLength;
        unsigned m_indexBegin;
        unsigned m_indexEnd;
        const CGSize* m_baseAdvances;
        CFIndex m_indexBegin;
        CFIndex m_indexEnd;
        unsigned m_glyphCount;
        unsigned m_stringLocation;
        bool m_isLTR;


    float runWidthSoFarFraction(unsigned glyphStartOffset, unsigned glyphEndOffset, unsigned oldCharacterInCurrentGlyph, GlyphIterationStyle) const;

    FloatPoint glyphOrigin(unsigned index) const { return index < m_glyphOrigins.size() ? m_glyphOrigins[index] : FloatPoint(); }

    Vector<FloatSize, 256> m_adjustedBaseAdvances;
    Vector<FloatPoint, 256> m_glyphOrigins;
    Vector<CGGlyph, 256> m_adjustedGlyphs;

    Vector<UChar, 256> m_smallCapsBuffer;


    const FontCascade& m_font;
    const TextRun& m_run;

    unsigned m_currentCharacter { 0 };
    unsigned m_end { 0 };


};

} // namespace WebCore

#endif // ComplexTextController_h




#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED < 90000)
SOFT_LINK_FRAMEWORK(CoreText);
SOFT_LINK(CoreText, CTRunGetBaseAdvancesAndOrigins, void, (CTRunRef run, CFRange range, FloatSize baseAdvances[], FloatPoint origins[]), (run, range, baseAdvances, origins))
#endif


// Note: CTFontDescriptorRefs can live forever in caches inside CoreText, so this object can too.
@interface WebCascadeList : NSArray {
    @private


namespace WebCore {

ComplexTextController::ComplexTextRun::ComplexTextRun(CTRunRef ctRun, const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd)
    : m_initialAdvance(CTRunGetInitialAdvance(ctRun))
    , m_font(font)
    , m_characters(characters)
    , m_stringLength(stringLength)
    , m_indexBegin(indexBegin)
    , m_indexEnd(indexEnd)
    , m_indexBegin(runRange.location)
    , m_indexEnd(runRange.location + runRange.length)
    , m_glyphCount(CTRunGetGlyphCount(ctRun))
    , m_stringLocation(stringLocation)
    , m_isLTR(!(CTRunGetStatus(ctRun) & kCTRunStatusRightToLeft))
{
    const CFIndex* coreTextIndicesPtr = CTRunGetStringIndicesPtr(ctRun);
    Vector<CFIndex> coreTextIndices;
    if (!coreTextIndicesPtr) {
        coreTextIndices.grow(m_glyphCount);
        CTRunGetStringIndices(ctRun, CFRangeMake(0, 0), coreTextIndices.data());
        coreTextIndicesPtr = coreTextIndices.data();
    }
    m_coreTextIndices.reserveInitialCapacity(m_glyphCount);
    for (unsigned i = 0; i < m_glyphCount; ++i)
        m_coreTextIndices.uncheckedAppend(coreTextIndicesPtr[i]);

    const CGGlyph* glyphsPtr = CTRunGetGlyphsPtr(ctRun);
    Vector<CGGlyph> glyphs;
    if (!glyphsPtr) {
        glyphs.grow(m_glyphCount);
        CTRunGetGlyphs(ctRun, CFRangeMake(0, 0), glyphs.data());
        glyphsPtr = glyphs.data();
    }
    m_glyphs.reserveInitialCapacity(m_glyphCount);
    for (unsigned i = 0; i < m_glyphCount; ++i)
        m_glyphs.uncheckedAppend(glyphsPtr[i]);

#if USE_LAYOUT_SPECIFIC_ADVANCES
    if (CTRunGetStatus(ctRun) & kCTRunStatusHasOrigins) {
        Vector<CGSize> baseAdvances(m_glyphCount);
        Vector<CGPoint> glyphOrigins(m_glyphCount);
        CTRunGetBaseAdvancesAndOrigins(ctRun, CFRangeMake(0, 0), baseAdvances.data(), glyphOrigins.data());
        m_baseAdvances.reserveInitialCapacity(m_glyphCount);
        m_glyphOrigins.reserveInitialCapacity(m_glyphCount);
        for (unsigned i = 0; i < m_glyphCount; ++i) {
            m_baseAdvances.uncheckedAppend(baseAdvances[i]);
            m_glyphOrigins.uncheckedAppend(glyphOrigins[i]);
        }
    } else
#endif
    {
        const CGSize* baseAdvances = CTRunGetAdvancesPtr(ctRun);
        Vector<CGSize> baseAdvancesVector;
        if (!baseAdvances) {
            baseAdvancesVector.grow(m_glyphCount);
            CTRunGetAdvances(ctRun, CFRangeMake(0, 0), baseAdvancesVector.data());
            baseAdvances = baseAdvancesVector.data();
        }
        m_baseAdvances.reserveInitialCapacity(m_glyphCount);
        for (unsigned i = 0; i < m_glyphCount; ++i)
            m_baseAdvances.uncheckedAppend(baseAdvances[i]);
    }
}

// Missing glyphs run constructor. Core Text will not generate a run of missing glyphs, instead falling back on
// glyphs from LastResort. We want to use the primary font's missing glyph in order to match the fast text code path.
ComplexTextController::ComplexTextRun::ComplexTextRun(const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr)
    : m_font(font)
    , m_font(font)
    , m_characters(characters)
    , m_stringLength(stringLength)
    , m_indexBegin(indexBegin)
    , m_indexEnd(indexEnd)
    , m_stringLocation(stringLocation)
    , m_isLTR(ltr)
{
    auto runLengthInCodeUnits = m_indexEnd - m_indexBegin;
    m_coreTextIndices.reserveInitialCapacity(runLengthInCodeUnits);
    unsigned r = m_indexBegin;
    while (r < m_indexEnd) {
        m_coreTextIndices.uncheckedAppend(r);
        UChar32 character;
        U16_NEXT(m_characters, r, m_stringLength, character);
    }
    m_glyphCount = m_coreTextIndices.size();
    if (!ltr) {
        for (unsigned r = 0, end = m_glyphCount - 1; r < m_glyphCount / 2; ++r, --end)
            std::swap(m_coreTextIndices[r], m_coreTextIndices[end]);
    }
    m_coreTextIndices = m_coreTextIndicesVector.data();

    // Synthesize a run of missing glyphs.
    m_glyphs.fill(0, m_glyphCount);
    m_baseAdvances.fill(FloatSize(m_font.widthForGlyph(0), 0), m_glyphCount);
    m_baseAdvancesVector.fill(CGSizeMake(m_font.widthForGlyph(0), 0), m_glyphCount);
    m_baseAdvances = m_baseAdvancesVector.data();
}


ComplexTextController::ComplexTextRun::ComplexTextRun(const Vector<FloatSize>& advances, const Vector<FloatPoint>& origins, const Vector<Glyph>& glyphs, const Vector<unsigned>& stringIndices, FloatSize initialAdvance, const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr)
    : m_baseAdvances(advances)
    , m_glyphOrigins(origins)
    , m_glyphs(glyphs)
    , m_coreTextIndices(stringIndices)
    , m_initialAdvance(initialAdvance)
    , m_font(font)
    , m_characters(characters)
    , m_stringLength(stringLength)
    , m_indexBegin(indexBegin)
    , m_indexEnd(indexEnd)
    , m_baseAdvances(m_baseAdvancesVector.data())
    , m_indexBegin(runRange.location)
    , m_indexEnd(runRange.location + runRange.length)
    , m_glyphCount(glyphs.size())
    , m_stringLocation(stringLocation)
    , m_isLTR(ltr)

{
    if (!font) {
        // Create a run of missing glyphs from the primary font.
        m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFont(), cp, stringLocation, length, 0, length, m_run.ltr()));
        return;
    }


                    // NSFontRenderingMode.
                    RetainPtr<CFStringRef> fontName = adoptCF(CTFontCopyPostScriptName(runCTFont));
                    if (CFEqual(fontName.get(), CFSTR("LastResort"))) {
                        m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFont(), cp, stringLocation, length, runRange.location, runRange.location + runRange.length, m_run.ltr()));
                        continue;
                    }
                    auto& fontCache = FontCache::singleton();

        if (m_fallbackFonts && runFont != &m_font.primaryFont())
            m_fallbackFonts->add(font);

        m_complexTextRuns.append(ComplexTextRun::create(ctRun, *runFont, cp, stringLocation, length, runRange.location, runRange.location + runRange.length));
    }
}




2017-02-06  Myles C. Maxfield  <mmaxfield@apple.com>

        Migrate ComplexTextController to use platform-independent types
        https://bugs.webkit.org/show_bug.cgi?id=167833

        Rebaseline tiny rounding result.

        Reviewed by NOBODY (OOPS!).

        * platform/mac/fast/text/complex-text-opacity-expected.txt:

2017-02-06  Ryan Haddad  <ryanhaddad@apple.com>

        Unreviewed, rolling out r211722.



          text run at (139,4) width 7: " "
        RenderText {#text} at (188,4) size 7x29
          text run at (188,4) width 7: " "
        RenderText {#text} at (236,4) size 8x29
          text run at (236,4) width 8: " "
        RenderText {#text} at (285,4) size 7x29
          text run at (285,4) width 7: " "
        RenderText {#text} at (334,4) size 7x29

Return to Bug 167833

Lines 22-30 a/Source/WebCore/platform/graphics/mac/ComplexTextController.h_sec1
- a/Source/WebCore/platform/graphics/mac/ComplexTextController.h -44 / +35 lines
22	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	22	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23	*/	23	*/
24		24
25	#ifndef ComplexTextController_h	25	#pragma once
26	#define ComplexTextController_h
27		26
		27	#include "FloatPoint.h"
28	#include "GlyphBuffer.h"	28	#include "GlyphBuffer.h"
29	#include <wtf/HashSet.h>	29	#include <wtf/HashSet.h>
30	#include <wtf/RefCounted.h>	30	#include <wtf/RefCounted.h>
Lines 39-48 typedef unsigned short CGGlyph; a/Source/WebCore/platform/graphics/mac/ComplexTextController.h_sec2
39	typedef const struct __CTRun * CTRunRef;	39	typedef const struct __CTRun * CTRunRef;
40	typedef const struct __CTLine * CTLineRef;	40	typedef const struct __CTLine * CTLineRef;
41		41
42	namespace WTF {
43	template<> struct VectorTraits<CGPoint> : SimpleClassVectorTraits { };
44	}
45
46	namespace WebCore {	42	namespace WebCore {
47		43
48	class FontCascade;	44	class FontCascade;
Lines 78-108 public: a/Source/WebCore/platform/graphics/mac/ComplexTextController.h_sec3
78		74
79	class ComplexTextRun : public RefCounted<ComplexTextRun> {	75	class ComplexTextRun : public RefCounted<ComplexTextRun> {
80	public:	76	public:
81	static Ref<ComplexTextRun> create(CTRunRef ctRun, const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange)	77	static Ref<ComplexTextRun> create(CTRunRef ctRun, const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd)
82	{	78	{
83	return adoptRef(*new ComplexTextRun(ctRun, font, characters, stringLocation, stringLength, runRange));	79	return adoptRef(*new ComplexTextRun(ctRun, font, characters, stringLocation, stringLength, indexBegin, indexEnd));
84	}	80	}
85		81
86	static Ref<ComplexTextRun> create(const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr)	82	static Ref<ComplexTextRun> create(const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr)
87	{	83	{
88	return adoptRef(*new ComplexTextRun(font, characters, stringLocation, stringLength, ltr));	84	return adoptRef(*new ComplexTextRun(font, characters, stringLocation, stringLength, indexBegin, indexEnd, ltr));
89	}	85	}
90		86
91	static Ref<ComplexTextRun> createForTesting(const Vector<CGSize>& advances, const Vector<CGPoint>& origins, const Vector<CGGlyph>& glyphs, const Vector<CFIndex>& stringIndices, CGSize initialAdvance, const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange, bool ltr)	87	static Ref<ComplexTextRun> create(const Vector<FloatSize>& advances, const Vector<FloatPoint>& origins, const Vector<Glyph>& glyphs, const Vector<unsigned>& stringIndices, FloatSize initialAdvance, const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr)
92	{	88	{
93	return adoptRef(*new ComplexTextRun(advances, origins, glyphs, stringIndices, initialAdvance, font, characters, stringLocation, stringLength, runRange, ltr));	89	return adoptRef(*new ComplexTextRun(advances, origins, glyphs, stringIndices, initialAdvance, font, characters, stringLocation, stringLength, indexBegin, indexEnd, ltr));
94	}	90	}
95		91
96	unsigned glyphCount() const { return m_glyphCount; }	92	unsigned glyphCount() const { return m_glyphCount; }
97	const Font& font() const { return m_font; }	93	const Font& font() const { return m_font; }
98	const UChar* characters() const { return m_characters; }	94	const UChar* characters() const { return m_characters; }
99	unsigned stringLocation() const { return m_stringLocation; }	95	unsigned stringLocation() const { return m_stringLocation; }
100	size_t stringLength() const { return m_stringLength; }	96	unsigned stringLength() const { return m_stringLength; }
101	ALWAYS_INLINE CFIndex indexAt(size_t i) const;	97	ALWAYS_INLINE unsigned indexAt(unsigned) const;
102	CFIndex indexBegin() const { return m_indexBegin; }	98	unsigned indexBegin() const { return m_indexBegin; }
103	CFIndex indexEnd() const { return m_indexEnd; }	99	unsigned indexEnd() const { return m_indexEnd; }
104	CFIndex endOffsetAt(size_t i) const { ASSERT(!m_isMonotonic); return m_glyphEndOffsets[i]; }	100	unsigned endOffsetAt(unsigned i) const { ASSERT(!m_isMonotonic); return m_glyphEndOffsets[i]; }
105	const CGGlyph* glyphs() const { return m_glyphs; }	101	const CGGlyph* glyphs() const { return m_glyphs.data(); }
106		102
107	/*	103	/*
108	* This is the format of the information CoreText gives us about each run:	104	* This is the format of the information CoreText gives us about each run:
Lines 131-163 public: a/Source/WebCore/platform/graphics/mac/ComplexTextController.h_sec4
131	* X--------------------------------------------------X--------------------------X--------------------------X	127	* X--------------------------------------------------X--------------------------X--------------------------X
132	* (text position ^) (layout advance) (layout advance) (layout advance)	128	* (text position ^) (layout advance) (layout advance) (layout advance)
133	*/	129	*/
134	void growInitialAdvanceHorizontally(CGFloat delta) { m_initialAdvance.width += delta; }	130	void growInitialAdvanceHorizontally(float delta) { m_initialAdvance.expand(delta, 0); }
135	CGSize initialAdvance() const { return m_initialAdvance; }	131	FloatSize initialAdvance() const { return m_initialAdvance; }
136	const CGSize* baseAdvances() const { return m_baseAdvances; }	132	const FloatSize* baseAdvances() const { return m_baseAdvances.data(); }
137	const CGPoint* glyphOrigins() const { return m_glyphOrigins.size() == glyphCount() ? m_glyphOrigins.data() : nullptr; }	133	const FloatPoint* glyphOrigins() const { return m_glyphOrigins.size() == glyphCount() ? m_glyphOrigins.data() : nullptr; }
138	bool isLTR() const { return m_isLTR; }	134	bool isLTR() const { return m_isLTR; }
139	bool isMonotonic() const { return m_isMonotonic; }	135	bool isMonotonic() const { return m_isMonotonic; }
140	void setIsNonMonotonic();	136	void setIsNonMonotonic();
141		137
142	private:	138	private:
143	ComplexTextRun(CTRunRef, const Font&, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange);	139	ComplexTextRun(CTRunRef, const Font&, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd);
144	ComplexTextRun(const Font&, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr);	140	ComplexTextRun(const Font&, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr);
145	WEBCORE_EXPORT ComplexTextRun(const Vector<CGSize>& advances, const Vector<CGPoint>& origins, const Vector<CGGlyph>& glyphs, const Vector<CFIndex>& stringIndices, CGSize initialAdvance, const Font&, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange, bool ltr);	141	WEBCORE_EXPORT ComplexTextRun(const Vector<FloatSize>& advances, const Vector<FloatPoint>& origins, const Vector<Glyph>& glyphs, const Vector<unsigned>& stringIndices, FloatSize initialAdvance, const Font&, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr);
146		142
147	Vector<CGSize, 64> m_baseAdvancesVector;	143	Vector<FloatSize, 64> m_baseAdvances;
148	Vector<CGPoint, 64> m_glyphOrigins;	144	Vector<FloatPoint, 64> m_glyphOrigins;
149	Vector<CGGlyph, 64> m_glyphsVector;	145	Vector<CGGlyph, 64> m_glyphs;
150	Vector<CFIndex, 64> m_glyphEndOffsets;	146	Vector<unsigned, 64> m_glyphEndOffsets;
151	Vector<CFIndex, 64> m_coreTextIndicesVector;	147	Vector<unsigned, 64> m_coreTextIndices;
152	CGSize m_initialAdvance;	148	FloatSize m_initialAdvance;
153	const Font& m_font;	149	const Font& m_font;
154	const UChar* m_characters;	150	const UChar* m_characters;
155	size_t m_stringLength;	151	unsigned m_stringLength;
156	const CFIndex* m_coreTextIndices;	152	unsigned m_indexBegin;
157	const CGGlyph* m_glyphs;	153	unsigned m_indexEnd;
158	const CGSize* m_baseAdvances;
159	CFIndex m_indexBegin;
160	CFIndex m_indexEnd;
161	unsigned m_glyphCount;	154	unsigned m_glyphCount;
162	unsigned m_stringLocation;	155	unsigned m_stringLocation;
163	bool m_isLTR;	156	bool m_isLTR;
Lines 180-189 private: a/Source/WebCore/platform/graphics/mac/ComplexTextController.h_sec5
180		173
181	float runWidthSoFarFraction(unsigned glyphStartOffset, unsigned glyphEndOffset, unsigned oldCharacterInCurrentGlyph, GlyphIterationStyle) const;	174	float runWidthSoFarFraction(unsigned glyphStartOffset, unsigned glyphEndOffset, unsigned oldCharacterInCurrentGlyph, GlyphIterationStyle) const;
182		175
183	CGPoint glyphOrigin(unsigned index) const { return index < m_glyphOrigins.size() ? m_glyphOrigins[index] : CGPointZero; }	176	FloatPoint glyphOrigin(unsigned index) const { return index < m_glyphOrigins.size() ? m_glyphOrigins[index] : FloatPoint(); }
184		177
185	Vector<CGSize, 256> m_adjustedBaseAdvances;	178	Vector<FloatSize, 256> m_adjustedBaseAdvances;
186	Vector<CGPoint, 256> m_glyphOrigins;	179	Vector<FloatPoint, 256> m_glyphOrigins;
187	Vector<CGGlyph, 256> m_adjustedGlyphs;	180	Vector<CGGlyph, 256> m_adjustedGlyphs;
188		181
189	Vector<UChar, 256> m_smallCapsBuffer;	182	Vector<UChar, 256> m_smallCapsBuffer;
Lines 210-216 private: a/Source/WebCore/platform/graphics/mac/ComplexTextController.h_sec6
210		203
211	const FontCascade& m_font;	204	const FontCascade& m_font;
212	const TextRun& m_run;	205	const TextRun& m_run;
213		206
214	unsigned m_currentCharacter { 0 };	207	unsigned m_currentCharacter { 0 };
215	unsigned m_end { 0 };	208	unsigned m_end { 0 };
216		209
Lines 234-238 private: a/Source/WebCore/platform/graphics/mac/ComplexTextController.h_sec7
234	};	227	};
235		228
236	} // namespace WebCore	229	} // namespace WebCore
237
238	#endif // ComplexTextController_h

Lines 42-51 a/Source/WebCore/platform/graphics/mac/ComplexTextControllerCoreText.mm_sec1
- a/Source/WebCore/platform/graphics/mac/ComplexTextControllerCoreText.mm -53 / +63 lines
42		42
43	#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100) \|\| (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED < 90000)	43	#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100) \|\| (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED < 90000)
44	SOFT_LINK_FRAMEWORK(CoreText);	44	SOFT_LINK_FRAMEWORK(CoreText);
45	SOFT_LINK(CoreText, CTRunGetBaseAdvancesAndOrigins, void, (CTRunRef run, CFRange range, CGSize baseAdvances[], CGPoint origins[]), (run, range, baseAdvances, origins))	45	SOFT_LINK(CoreText, CTRunGetBaseAdvancesAndOrigins, void, (CTRunRef run, CFRange range, FloatSize baseAdvances[], FloatPoint origins[]), (run, range, baseAdvances, origins))
46	#endif	46	#endif
47		47
48
49	// Note: CTFontDescriptorRefs can live forever in caches inside CoreText, so this object can too.	48	// Note: CTFontDescriptorRefs can live forever in caches inside CoreText, so this object can too.
50	@interface WebCascadeList : NSArray {	49	@interface WebCascadeList : NSArray {
51	@private	50	@private
Lines 106-202 @end a/Source/WebCore/platform/graphics/mac/ComplexTextControllerCoreText.mm_sec2
106		105
107	namespace WebCore {	106	namespace WebCore {
108		107
109	ComplexTextController::ComplexTextRun::ComplexTextRun(CTRunRef ctRun, const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange)	108	ComplexTextController::ComplexTextRun::ComplexTextRun(CTRunRef ctRun, const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd)
110	: m_initialAdvance(CTRunGetInitialAdvance(ctRun))	109	: m_initialAdvance(CTRunGetInitialAdvance(ctRun))
111	, m_font(font)	110	, m_font(font)
112	, m_characters(characters)	111	, m_characters(characters)
113	, m_stringLength(stringLength)	112	, m_stringLength(stringLength)
114	, m_coreTextIndices(CTRunGetStringIndicesPtr(ctRun))	113	, m_indexBegin(indexBegin)
115	, m_glyphs(CTRunGetGlyphsPtr(ctRun))	114	, m_indexEnd(indexEnd)
116	, m_indexBegin(runRange.location)
117	, m_indexEnd(runRange.location + runRange.length)
118	, m_glyphCount(CTRunGetGlyphCount(ctRun))	115	, m_glyphCount(CTRunGetGlyphCount(ctRun))
119	, m_stringLocation(stringLocation)	116	, m_stringLocation(stringLocation)
120	, m_isLTR(!(CTRunGetStatus(ctRun) & kCTRunStatusRightToLeft))	117	, m_isLTR(!(CTRunGetStatus(ctRun) & kCTRunStatusRightToLeft))
121	{	118	{
122	if (!m_coreTextIndices) {	119	const CFIndex* coreTextIndicesPtr = CTRunGetStringIndicesPtr(ctRun);
123	m_coreTextIndicesVector.grow(m_glyphCount);	120	Vector<CFIndex> coreTextIndices;
124	CTRunGetStringIndices(ctRun, CFRangeMake(0, 0), m_coreTextIndicesVector.data());	121	if (!coreTextIndicesPtr) {
125	m_coreTextIndices = m_coreTextIndicesVector.data();	122	coreTextIndices.grow(m_glyphCount);
		123	CTRunGetStringIndices(ctRun, CFRangeMake(0, 0), coreTextIndices.data());
		124	coreTextIndicesPtr = coreTextIndices.data();
126	}	125	}
127		126	m_coreTextIndices.reserveInitialCapacity(m_glyphCount);
128	if (!m_glyphs) {	127	for (unsigned i = 0; i < m_glyphCount; ++i)
129	m_glyphsVector.grow(m_glyphCount);	128	m_coreTextIndices.uncheckedAppend(coreTextIndicesPtr[i]);
130	CTRunGetGlyphs(ctRun, CFRangeMake(0, 0), m_glyphsVector.data());	129
131	m_glyphs = m_glyphsVector.data();	130	const CGGlyph* glyphsPtr = CTRunGetGlyphsPtr(ctRun);
		131	Vector<CGGlyph> glyphs;
		132	if (!glyphsPtr) {
		133	glyphs.grow(m_glyphCount);
		134	CTRunGetGlyphs(ctRun, CFRangeMake(0, 0), glyphs.data());
		135	glyphsPtr = glyphs.data();
132	}	136	}
		137	m_glyphs.reserveInitialCapacity(m_glyphCount);
		138	for (unsigned i = 0; i < m_glyphCount; ++i)
		139	m_glyphs.uncheckedAppend(glyphsPtr[i]);
133		140
134	#if USE_LAYOUT_SPECIFIC_ADVANCES	141	#if USE_LAYOUT_SPECIFIC_ADVANCES
135	if (CTRunGetStatus(ctRun) & kCTRunStatusHasOrigins) {	142	if (CTRunGetStatus(ctRun) & kCTRunStatusHasOrigins) {
136	m_baseAdvancesVector.grow(m_glyphCount);	143	Vector<CGSize> baseAdvances(m_glyphCount);
137	m_glyphOrigins.grow(m_glyphCount);	144	Vector<CGPoint> glyphOrigins(m_glyphCount);
138	CTRunGetBaseAdvancesAndOrigins(ctRun, CFRangeMake(0, 0), m_baseAdvancesVector.data(), m_glyphOrigins.data());	145	CTRunGetBaseAdvancesAndOrigins(ctRun, CFRangeMake(0, 0), baseAdvances.data(), glyphOrigins.data());
139	m_baseAdvances = m_baseAdvancesVector.data();	146	m_baseAdvances.reserveInitialCapacity(m_glyphCount);
		147	m_glyphOrigins.reserveInitialCapacity(m_glyphCount);
		148	for (unsigned i = 0; i < m_glyphCount; ++i) {
		149	m_baseAdvances.uncheckedAppend(baseAdvances[i]);
		150	m_glyphOrigins.uncheckedAppend(glyphOrigins[i]);
		151	}
140	} else	152	} else
141	#endif	153	#endif
142	{	154	{
143	m_baseAdvances = CTRunGetAdvancesPtr(ctRun);	155	const CGSize* baseAdvances = CTRunGetAdvancesPtr(ctRun);
144	if (!m_baseAdvances) {	156	Vector<CGSize> baseAdvancesVector;
145	m_baseAdvancesVector.grow(m_glyphCount);	157	if (!baseAdvances) {
146	CTRunGetAdvances(ctRun, CFRangeMake(0, 0), m_baseAdvancesVector.data());	158	baseAdvancesVector.grow(m_glyphCount);
147	m_baseAdvances = m_baseAdvancesVector.data();	159	CTRunGetAdvances(ctRun, CFRangeMake(0, 0), baseAdvancesVector.data());
		160	baseAdvances = baseAdvancesVector.data();
148	}	161	}
		162	m_baseAdvances.reserveInitialCapacity(m_glyphCount);
		163	for (unsigned i = 0; i < m_glyphCount; ++i)
		164	m_baseAdvances.uncheckedAppend(baseAdvances[i]);
149	}	165	}
150	}	166	}
151		167
152	// Missing glyphs run constructor. Core Text will not generate a run of missing glyphs, instead falling back on	168	// Missing glyphs run constructor. Core Text will not generate a run of missing glyphs, instead falling back on
153	// glyphs from LastResort. We want to use the primary font's missing glyph in order to match the fast text code path.	169	// glyphs from LastResort. We want to use the primary font's missing glyph in order to match the fast text code path.
154	ComplexTextController::ComplexTextRun::ComplexTextRun(const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr)	170	ComplexTextController::ComplexTextRun::ComplexTextRun(const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr)
155	: m_initialAdvance(CGSizeZero)	171	: m_font(font)
156	, m_font(font)
157	, m_characters(characters)	172	, m_characters(characters)
158	, m_stringLength(stringLength)	173	, m_stringLength(stringLength)
159	, m_indexBegin(0)	174	, m_indexBegin(indexBegin)
160	, m_indexEnd(stringLength)	175	, m_indexEnd(indexEnd)
161	, m_stringLocation(stringLocation)	176	, m_stringLocation(stringLocation)
162	, m_isLTR(ltr)	177	, m_isLTR(ltr)
163	{	178	{
164	m_coreTextIndicesVector.reserveInitialCapacity(m_stringLength);	179	auto runLengthInCodeUnits = m_indexEnd - m_indexBegin;
165	unsigned r = 0;	180	m_coreTextIndices.reserveInitialCapacity(runLengthInCodeUnits);
166	while (r < m_stringLength) {	181	unsigned r = m_indexBegin;
167	m_coreTextIndicesVector.uncheckedAppend(r);	182	while (r < m_indexEnd) {
		183	m_coreTextIndices.uncheckedAppend(r);
168	UChar32 character;	184	UChar32 character;
169	U16_NEXT(m_characters, r, m_stringLength, character);	185	U16_NEXT(m_characters, r, m_stringLength, character);
170	}	186	}
171	m_glyphCount = m_coreTextIndicesVector.size();	187	m_glyphCount = m_coreTextIndices.size();
172	if (!ltr) {	188	if (!ltr) {
173	for (unsigned r = 0, end = m_glyphCount - 1; r < m_glyphCount / 2; ++r, --end)	189	for (unsigned r = 0, end = m_glyphCount - 1; r < m_glyphCount / 2; ++r, --end)
174	std::swap(m_coreTextIndicesVector[r], m_coreTextIndicesVector[end]);	190	std::swap(m_coreTextIndices[r], m_coreTextIndices[end]);
175	}	191	}
176	m_coreTextIndices = m_coreTextIndicesVector.data();
177		192
178	// Synthesize a run of missing glyphs.	193	// Synthesize a run of missing glyphs.
179	m_glyphsVector.fill(0, m_glyphCount);	194	m_glyphs.fill(0, m_glyphCount);
180	m_glyphs = m_glyphsVector.data();	195	m_baseAdvances.fill(FloatSize(m_font.widthForGlyph(0), 0), m_glyphCount);
181	m_baseAdvancesVector.fill(CGSizeMake(m_font.widthForGlyph(0), 0), m_glyphCount);
182	m_baseAdvances = m_baseAdvancesVector.data();
183	}	196	}
184		197
185		198
186	ComplexTextController::ComplexTextRun::ComplexTextRun(const Vector<CGSize>& advances, const Vector<CGPoint>& origins, const Vector<CGGlyph>& glyphs, const Vector<CFIndex>& stringIndices, CGSize initialAdvance, const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange, bool ltr)	199	ComplexTextController::ComplexTextRun::ComplexTextRun(const Vector<FloatSize>& advances, const Vector<FloatPoint>& origins, const Vector<Glyph>& glyphs, const Vector<unsigned>& stringIndices, FloatSize initialAdvance, const Font& font, const UChar* characters, unsigned stringLocation, unsigned stringLength, unsigned indexBegin, unsigned indexEnd, bool ltr)
187	: m_baseAdvancesVector(advances)	200	: m_baseAdvances(advances)
188	, m_glyphOrigins(origins)	201	, m_glyphOrigins(origins)
189	, m_glyphsVector(glyphs)	202	, m_glyphs(glyphs)
190	, m_coreTextIndicesVector(stringIndices)	203	, m_coreTextIndices(stringIndices)
191	, m_initialAdvance(initialAdvance)	204	, m_initialAdvance(initialAdvance)
192	, m_font(font)	205	, m_font(font)
193	, m_characters(characters)	206	, m_characters(characters)
194	, m_stringLength(stringLength)	207	, m_stringLength(stringLength)
195	, m_coreTextIndices(m_coreTextIndicesVector.data())	208	, m_indexBegin(indexBegin)
196	, m_glyphs(m_glyphsVector.data())	209	, m_indexEnd(indexEnd)
197	, m_baseAdvances(m_baseAdvancesVector.data())
198	, m_indexBegin(runRange.location)
199	, m_indexEnd(runRange.location + runRange.length)
200	, m_glyphCount(glyphs.size())	210	, m_glyphCount(glyphs.size())
201	, m_stringLocation(stringLocation)	211	, m_stringLocation(stringLocation)
202	, m_isLTR(ltr)	212	, m_isLTR(ltr)
Lines 229-235 void ComplexTextController::collectComplexTextRunsForCharacters(const UChar* cp, a/Source/WebCore/platform/graphics/mac/ComplexTextControllerCoreText.mm_sec3
229	{	239	{
230	if (!font) {	240	if (!font) {
231	// Create a run of missing glyphs from the primary font.	241	// Create a run of missing glyphs from the primary font.
232	m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFont(), cp, stringLocation, length, m_run.ltr()));	242	m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFont(), cp, stringLocation, length, 0, length, m_run.ltr()));
233	return;	243	return;
234	}	244	}
235		245
Lines 313-319 void ComplexTextController::collectComplexTextRunsForCharacters(const UChar* cp, a/Source/WebCore/platform/graphics/mac/ComplexTextControllerCoreText.mm_sec4
313	// NSFontRenderingMode.	323	// NSFontRenderingMode.
314	RetainPtr<CFStringRef> fontName = adoptCF(CTFontCopyPostScriptName(runCTFont));	324	RetainPtr<CFStringRef> fontName = adoptCF(CTFontCopyPostScriptName(runCTFont));
315	if (CFEqual(fontName.get(), CFSTR("LastResort"))) {	325	if (CFEqual(fontName.get(), CFSTR("LastResort"))) {
316	m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFont(), cp, stringLocation + runRange.location, runRange.length, m_run.ltr()));	326	m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFont(), cp, stringLocation, length, runRange.location, runRange.location + runRange.length, m_run.ltr()));
317	continue;	327	continue;
318	}	328	}
319	auto& fontCache = FontCache::singleton();	329	auto& fontCache = FontCache::singleton();
Lines 332-338 void ComplexTextController::collectComplexTextRunsForCharacters(const UChar* cp, a/Source/WebCore/platform/graphics/mac/ComplexTextControllerCoreText.mm_sec5
332	if (m_fallbackFonts && runFont != &m_font.primaryFont())	342	if (m_fallbackFonts && runFont != &m_font.primaryFont())
333	m_fallbackFonts->add(font);	343	m_fallbackFonts->add(font);
334		344
335	m_complexTextRuns.append(ComplexTextRun::create(ctRun, *runFont, cp, stringLocation, length, runRange));	345	m_complexTextRuns.append(ComplexTextRun::create(ctRun, *runFont, cp, stringLocation, length, runRange.location, runRange.location + runRange.length));
336	}	346	}
337	}	347	}
338		348

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +42 lines
		1	2017-02-06 Myles C. Maxfield <mmaxfield@apple.com>
		2
		3	Migrate ComplexTextController to use platform-independent types
		4	https://bugs.webkit.org/show_bug.cgi?id=167833
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	ComplexTextController will eventually be used on all ports to perform complex text layout.
		9	This is a mechanical patch which migrates the shared parts of ComplexTextController away from
		10	using CoreGraphics and CoreFoundation types in favor of WebCore/platform types. Eventually,
		11	ComplexTextController will get moved to PAL but there is a layering violation (TextLayout) to
		12	fix first.
		13
		14	No new tests because there is no behavior change.
		15
		16	* platform/graphics/GlyphBuffer.h:
		17	(WebCore::GlyphBufferAdvance::GlyphBufferAdvance):
		18	* platform/graphics/mac/ComplexTextController.cpp:
		19	(WebCore::ComplexTextController::offsetForPosition):
		20	(WebCore::advanceByCombiningCharacterSequence):
		21	(WebCore::ComplexTextController::ComplexTextRun::indexAt):
		22	(WebCore::ComplexTextController::ComplexTextRun::setIsNonMonotonic):
		23	(WebCore::ComplexTextController::advance):
		24	(WebCore::ComplexTextController::adjustGlyphsAndAdvances):
		25	* platform/graphics/mac/ComplexTextController.h:
		26	(WebCore::ComplexTextController::ComplexTextRun::create):
		27	(WebCore::ComplexTextController::ComplexTextRun::stringLength):
		28	(WebCore::ComplexTextController::ComplexTextRun::indexBegin):
		29	(WebCore::ComplexTextController::ComplexTextRun::indexEnd):
		30	(WebCore::ComplexTextController::ComplexTextRun::endOffsetAt):
		31	(WebCore::ComplexTextController::ComplexTextRun::glyphs):
		32	(WebCore::ComplexTextController::ComplexTextRun::growInitialAdvanceHorizontally):
		33	(WebCore::ComplexTextController::ComplexTextRun::initialAdvance):
		34	(WebCore::ComplexTextController::ComplexTextRun::baseAdvances):
		35	(WebCore::ComplexTextController::ComplexTextRun::glyphOrigins):
		36	(WebCore::ComplexTextController::glyphOrigin):
		37	(WebCore::ComplexTextController::ComplexTextRun::createForTesting): Deleted.
		38	* platform/graphics/mac/ComplexTextControllerCoreText.mm:
		39	(SOFT_LINK):
		40	(WebCore::ComplexTextController::ComplexTextRun::ComplexTextRun):
		41	(WebCore::ComplexTextController::collectComplexTextRunsForCharacters):
		42
1	2017-02-06 Said Abou-Hallawa <sabouhallawa@apple.com>	43	2017-02-06 Said Abou-Hallawa <sabouhallawa@apple.com>
2		44
3	Rename AnimationController to CSSAnimationController	45	Rename AnimationController to CSSAnimationController

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +11 lines
		1	2017-02-06 Myles C. Maxfield <mmaxfield@apple.com>
		2
		3	Migrate ComplexTextController to use platform-independent types
		4	https://bugs.webkit.org/show_bug.cgi?id=167833
		5
		6	Rebaseline tiny rounding result.
		7
		8	Reviewed by NOBODY (OOPS!).
		9
		10	* platform/mac/fast/text/complex-text-opacity-expected.txt:
		11
1	2017-02-06 Ryan Haddad <ryanhaddad@apple.com>	12	2017-02-06 Ryan Haddad <ryanhaddad@apple.com>
2		13
3	Unreviewed, rolling out r211722.	14	Unreviewed, rolling out r211722.

Lines 24-31 layer at (0,0) size 800x600 a/LayoutTests/platform/mac/fast/text/complex-text-opacity-expected.txt_sec1
- a/LayoutTests/platform/mac/fast/text/complex-text-opacity-expected.txt -2 / +2 lines
24	text run at (139,4) width 7: " "	24	text run at (139,4) width 7: " "
25	RenderText {#text} at (188,4) size 7x29	25	RenderText {#text} at (188,4) size 7x29
26	text run at (188,4) width 7: " "	26	text run at (188,4) width 7: " "
27	RenderText {#text} at (237,4) size 7x29	27	RenderText {#text} at (236,4) size 8x29
28	text run at (237,4) width 7: " "	28	text run at (236,4) width 8: " "
29	RenderText {#text} at (285,4) size 7x29	29	RenderText {#text} at (285,4) size 7x29
30	text run at (285,4) width 7: " "	30	text run at (285,4) width 7: " "
31	RenderText {#text} at (334,4) size 7x29	31	RenderText {#text} at (334,4) size 7x29