Attachment #286823 for bug #161119

View Details Raw Unified Return to Bug 161119

| Differences between



2016-08-23  Myles C. Maxfield  <mmaxfield@apple.com>

        [Cocoa] Improve performance of glyph advance metrics gathering
        https://bugs.webkit.org/show_bug.cgi?id=161119

        Reviewed by NOBODY (OOPS!).

        No new tests (OOPS!).

        * platform/graphics/Font.cpp:
        (WebCore::Font::platformGlyphInit):
        * platform/graphics/Font.h:
        (WebCore::Font::widthForGlyph):
        * platform/graphics/GlyphPage.h:
        (WebCore::GlyphData::GlyphData):
        (WebCore::GlyphPage::advanceForCharacter):
        (WebCore::GlyphPage::glyphDataForIndex):
        (WebCore::GlyphPage::advanceForIndex):
        (WebCore::GlyphPage::setGlyphForIndex):
        * platform/graphics/WidthIterator.cpp:
        (WebCore::WidthIterator::advanceInternal):
        * platform/graphics/cocoa/FontCocoa.mm:
        (WebCore::Font::platformWidthForGlyph):
        * platform/graphics/mac/GlyphPageMac.cpp:
        (WebCore::GlyphPage::fill):
        * platform/spi/cocoa/CoreTextSPI.h:

2016-08-23  Alex Christensen  <achristensen@webkit.org>

        Fix clean Windows build.

Lines 114-120 void Font::platformGlyphInit() a/Source/WebCore/platform/graphics/Font.cpp_sec1
- a/Source/WebCore/platform/graphics/Font.cpp -1 / +1 lines
114	// Nasty hack to determine if we should round or ceil space widths.	114	// Nasty hack to determine if we should round or ceil space widths.
115	// If the font is monospace or fake monospace we ceil to ensure that	115	// If the font is monospace or fake monospace we ceil to ensure that
116	// every character and the space are the same width. Otherwise we round.	116	// every character and the space are the same width. Otherwise we round.
117	m_spaceGlyph = glyphPageZero->glyphDataForCharacter(' ').glyph;	117	m_spaceGlyph = glyphPageZero->glyphDataForCharacter(space).glyph;
118	float width = widthForGlyph(m_spaceGlyph);	118	float width = widthForGlyph(m_spaceGlyph);
119	m_spaceWidth = width;	119	m_spaceWidth = width;
120	m_zeroGlyph = glyphPageZero->glyphDataForCharacter('0').glyph;	120	m_zeroGlyph = glyphPageZero->glyphDataForCharacter('0').glyph;



        return width;

#if ENABLE(OPENTYPE_VERTICAL)
    if (m_verticalData) {
#if USE(CG) || USE(CAIRO)
        width = m_verticalData->advanceHeight(this, glyph) + m_syntheticBoldOffset;
#else
        width = m_verticalData->advanceHeight(this, glyph);
#endif
    } else
#endif
        width = platformWidthForGlyph(glyph);




// Holds the glyph index and the corresponding Font information for a given
// character.
struct GlyphData {
    GlyphData(Glyph g = 0, const Font* f = nullptr, Optional<float> advance = Nullopt)
        : glyph(g)
        , font(f)
        , advance(advance)
    {
    }



    Glyph glyph;
    const Font* font;
    Optional<float> advance;
};

// A GlyphPage contains a fixed-size set of GlyphData mappings for a contiguous


    static unsigned count() { return s_count; }

    static constexpr size_t size = 256; // Covers Latin-1 in a single page.
    static unsigned indexForCharacter(UChar32 c) { return c % GlyphPage::size; }

    GlyphData glyphDataForCharacter(UChar32 c) const

        return glyphForIndex(indexForCharacter(c));
    }

    Optional<float> advanceForCharacter(UChar32 c) const
    {
        return advanceForIndex(indexForCharacter(c));
    }

    GlyphData glyphDataForIndex(unsigned index) const
    {
        Glyph glyph = glyphForIndex(index);
        return GlyphData(glyph, glyph ? &m_font : nullptr, advanceForIndex(index));
    }

    Glyph glyphForIndex(unsigned index) const

        return m_glyphs[index];
    }

    Optional<float> advanceForIndex(unsigned index) const
    void setGlyphForIndex(unsigned index, Glyph glyph)
    {
        ASSERT_WITH_SECURITY_IMPLICATION(index < size);
        if (m_advances.isEmpty())
            return Nullopt;
        return m_advances[index];
    }

    const Font& font() const

        ++s_count;
    }

    // FIXME: Pages are immutable after initialization. This should be private.
    void setGlyphForIndex(unsigned index, Glyph glyph, Optional<float> advance = Nullopt)
    {
        ASSERT_WITH_SECURITY_IMPLICATION(index < size);
        m_glyphs[index] = glyph;
        if (advance) {
            if (m_advances.isEmpty())
                m_advances.fill(0, size);
            m_advances[index] = advance.value();
        }
    }

    const Font& m_font;
    std::array<Glyph, size> m_glyphs { };
    Vector<float> m_advances;

    WEBCORE_EXPORT static unsigned s_count;
};

Lines 207-213 inline unsigned WidthIterator::advanceInternal(TextIterator& textIterator, Glyph a/Source/WebCore/platform/graphics/WidthIterator.cpp_sec1
- a/Source/WebCore/platform/graphics/WidthIterator.cpp -1 / +3 lines
207	if (character == '\t' && m_run.allowTabs())	207	if (character == '\t' && m_run.allowTabs())
208	width = m_font->tabWidth(*font, m_run.tabSize(), m_run.xPos() + m_runWidthSoFar + widthSinceLastRounding);	208	width = m_font->tabWidth(*font, m_run.tabSize(), m_run.xPos() + m_runWidthSoFar + widthSinceLastRounding);
209	else {	209	else {
210	width = font->widthForGlyph(glyph);	210	width = glyphData.advance.valueOrCompute([&] {
		211	return font->widthForGlyph(glyph);
		212	});
211		213
212	// SVG uses horizontalGlyphStretch(), when textLength is used to stretch/squeeze text.	214	// SVG uses horizontalGlyphStretch(), when textLength is used to stretch/squeeze text.
213	width *= m_run.horizontalGlyphStretch();	215	width *= m_run.horizontalGlyphStretch();



{
    CGSize advance = CGSizeZero;
    bool horizontal = platformData().orientation() == Horizontal;
    CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical, &glyph, &advance, 1);
    if ((horizontal || m_isBrokenIdeographFallback) && canUseFastGlyphAdvanceGetter(this->platformData(), glyph, advance, populatedAdvance)) {
        float pointSize = platformData().size();
        CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
        CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization | kCGFontAntialiasingStyleUnfiltered;
        if (!CGFontGetGlyphAdvancesForStyle(platformData().cgFont(), &m, style, &glyph, 1, &advance)) {
            RetainPtr<CFStringRef> fullName = adoptCF(CGFontCopyFullName(platformData().cgFont()));
            LOG_ERROR("Unable to cache glyph widths for %@ %f", fullName.get(), pointSize);
            advance.width = 0;
        }
    } else if (!populatedAdvance && platformData().size())
        CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical, &glyph, &advance, 1);

    return advance.width + m_syntheticBoldOffset;
}



    ASSERT(bufferLength == GlyphPage::size || bufferLength == 2 * GlyphPage::size);

    const Font& font = this->font();
    Vector<CGGlyph> glyphs(bufferLength);
    memset(glyphs.data(), 0, sizeof(CGGlyph) * bufferLength);
    if (!shouldUseCoreText(buffer, bufferLength, font)) {
        // We pass in either 256 or 512 UTF-16 characters: 256 for U+FFFF and less, 512 (double character surrogates)
        // for U+10000 and above. It is indeed possible to get back 512 glyphs back from the API, so the glyph buffer
        // we pass in must be 512. If we get back more than 256 glyphs though we'll ignore all the ones after 256,
        // this should not happen as the only time we pass in 512 characters is when they are surrogates.
        CGFontGetGlyphsForUnichars(font.platformData().cgFont(), buffer, glyphs.data(), bufferLength);
        glyphStep = 1;
    } else {
        // Because we know the implementation of shouldUseCoreText(), if the font isn't for text combine and it isn't a system font,
        // we know it must have vertical glyphs.


        // When buffer consists of surrogate pairs, CTFontGetVerticalGlyphsForCharacters and CTFontGetGlyphsForCharacters
        // place the glyphs at indices corresponding to the first character of each pair.
        unsigned glyphStep = bufferLength / GlyphPage::size;
        if (glyphStep != 1) {
            for (unsigned i = 0; i < GlyphPage::size; ++i)
                glyphs[i] = glyphs[i * glyphStep];
        }
    }

    Vector<CGSize> advances(GlyphPage::size);
    CTFontOrientation orientation = font.platformData().orientation() == Horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical;
    CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization | kCGFontAntialiasingStyleUnfiltered;
    CTFontGetUnsummedAdvancesForGlyphsAndStyle(font.platformData().ctFont(), orientation, style, glyphs.data(), advances.data(), GlyphPage::size);

    bool haveGlyphs = false;
    for (unsigned i = 0; i < GlyphPage::size; ++i) {
        if (glyphs[i]) {
            setGlyphForIndex(i, glyphs[i], advances[i].width);
            haveGlyphs = true;
        }
    }



    kCTFontUIFontSystemUltraLight = 104,
};

typedef CF_OPTIONS(uint32_t, CTFontTransformOptions)
{
    kCTFontTransformApplyShaping = (1 << 0),
    kCTFontTransformApplyPositioning = (1 << 1)
};

typedef CF_OPTIONS(uint32_t, CTFontDescriptorOptions)
{
    kCTFontDescriptorOptionSystemUIFont = 1 << 1,
    kCTFontDescriptorOptionPreferAppleSystemFont = kCTFontOptionsPreferSystemFont
};

#endif

extern "C" {

extern const CFStringRef kCTFontReferenceURLAttribute;
extern const CFStringRef kCTFontOpticalSizeAttribute;

#if PLATFORM(COCOA)
#if !USE(APPLE_INTERNAL_SDK)
typedef CF_OPTIONS(uint32_t, CTFontTransformOptions)
{
    kCTFontTransformApplyShaping = (1 << 0),
    kCTFontTransformApplyPositioning = (1 << 1)
};
#endif
bool CTFontTransformGlyphs(CTFontRef, CGGlyph glyphs[], CGSize advances[], CFIndex count, CTFontTransformOptions);
#endif

CGSize CTRunGetInitialAdvance(CTRunRef run);
CTLineRef CTLineCreateWithUniCharProvider(CTUniCharProviderCallback provide, CTUniCharDisposeCallback dispose, void* refCon);
CTTypesetterRef CTTypesetterCreateWithUniCharProviderAndOptions(CTUniCharProviderCallback provide, CTUniCharDisposeCallback dispose, void* refCon, CFDictionaryRef options);
bool CTFontGetVerticalGlyphsForCharacters(CTFontRef, const UniChar characters[], CGGlyph glyphs[], CFIndex count);
void CTFontGetUnsummedAdvancesForGlyphsAndStyle(CTFontRef, CTFontOrientation, CGFontRenderingStyle, const CGGlyph[], CGSize advances[], CFIndex count);

CTFontDescriptorRef CTFontDescriptorCreateForUIType(CTFontUIFontType, CGFloat size, CFStringRef language);
CTFontDescriptorRef CTFontDescriptorCreateWithTextStyle(CFStringRef style, CFStringRef size, CFStringRef language);
CTFontDescriptorRef CTFontDescriptorCreateCopyWithSymbolicTraits(CTFontDescriptorRef original, CTFontSymbolicTraits symTraitValue, CTFontSymbolicTraits symTraitMask);
CFBitVectorRef CTFontCopyGlyphCoverageForFeature(CTFontRef, CFDictionaryRef feature);

#if PLATFORM(COCOA)
#if !USE(APPLE_INTERNAL_SDK)
typedef CF_OPTIONS(uint32_t, CTFontDescriptorOptions)
{
    kCTFontDescriptorOptionSystemUIFont = 1 << 1,
    kCTFontDescriptorOptionPreferAppleSystemFont = kCTFontOptionsPreferSystemFont
};

CTFontDescriptorRef CTFontDescriptorCreateWithAttributesAndOptions(CFDictionaryRef attributes, CTFontDescriptorOptions);

extern const CFStringRef kCTFontDescriptorTextStyleAttribute;
extern const CFStringRef kCTFontUIFontDesignTrait;
#endif
#endif

bool CTFontDescriptorIsSystemUIFont(CTFontDescriptorRef);
CTFontRef CTFontCreateForCSS(CFStringRef name, uint16_t weight, CTFontSymbolicTraits, CGFloat size);
CTFontRef CTFontCreateForCharactersWithLanguage(CTFontRef currentFont, const UTF16Char *characters, CFIndex length, CFStringRef language, CFIndex *coveredLength);

#if PLATFORM(COCOA)
extern const CFStringRef kCTUIFontTextStyleShortHeadline;
extern const CFStringRef kCTUIFontTextStyleShortBody;
extern const CFStringRef kCTUIFontTextStyleShortSubhead;

extern const CGFloat kCTFontWeightBold;
extern const CGFloat kCTFontWeightHeavy;
extern const CGFloat kCTFontWeightBlack;
#endif

#if PLATFORM(IOS)
extern const CFStringRef kCTUIFontTextStyleTitle1;
extern const CFStringRef kCTUIFontTextStyleTitle2;
extern const CFStringRef kCTUIFontTextStyleTitle3;
CTFontDescriptorRef CTFontCreatePhysicalFontDescriptorForCharactersWithLanguage(CTFontRef currentFont, const UTF16Char* characters, CFIndex length, CFStringRef language, CFIndex* coveredLength);
#endif

CTFontRef CTFontCreatePhysicalFontForCharactersWithLanguage(CTFontRef, const UTF16Char* characters, CFIndex length, CFStringRef language, CFIndex* coveredLength);
bool CTFontIsAppleColorEmoji(CTFontRef);




void MathOperator::reset(const RenderStyle& style)
{
    m_variantOrAssembly = Nullopt;
    m_maxPreferredWidth = 0;
    m_width = 0;
    m_ascent = 0;

{
    ASSERT(sizeVariant.font);
    ASSERT(sizeVariant.font->mathData());
    m_variantOrAssembly = sizeVariant;
    m_variant = sizeVariant;
    m_width = advanceWidthForGlyph(sizeVariant);
    getAscentAndDescentForGlyph(sizeVariant, m_ascent, m_descent);
}

void MathOperator::setGlyphAssembly(const GlyphAssemblyData& assemblyData)
{
    ASSERT(m_operatorType == Type::VerticalOperator || m_operatorType == Type::HorizontalOperator);
    m_variantOrAssembly = assemblyData;
    m_assembly = assemblyData;
    if (m_operatorType == Type::VerticalOperator) {
        m_width = 0;
        m_width = std::max<LayoutUnit>(m_width, advanceWidthForGlyph(assemblyData.topOrRight));
        m_width = std::max<LayoutUnit>(m_width, advanceWidthForGlyph(assemblyData.extension));
        m_width = std::max<LayoutUnit>(m_width, advanceWidthForGlyph(assemblyData.bottomOrLeft));
        m_width = std::max<LayoutUnit>(m_width, advanceWidthForGlyph(assemblyData.middle));
    } else {
        m_ascent = 0;
        m_descent = 0;
        LayoutUnit ascent, descent;
        getAscentAndDescentForGlyph(assemblyData.bottomOrLeft, ascent, descent);
        m_ascent = std::max(m_ascent, ascent);
        m_descent = std::max(m_descent, descent);
        getAscentAndDescentForGlyph(assemblyData.extension, ascent, descent);
        m_ascent = std::max(m_ascent, ascent);
        m_descent = std::max(m_descent, descent);
        getAscentAndDescentForGlyph(assemblyData.topOrRight, ascent, descent);
        m_ascent = std::max(m_ascent, ascent);
        m_descent = std::max(m_descent, descent);
        getAscentAndDescentForGlyph(assemblyData.middle, ascent, descent);
        m_ascent = std::max(m_ascent, ascent);
        m_descent = std::max(m_descent, descent);
    }

{
    ASSERT(m_operatorType == Type::VerticalOperator || m_operatorType == Type::HorizontalOperator);
    calculateStretchyData(style, false, targetSize);
    if (isAssembly()) {
        if (m_operatorType == Type::VerticalOperator) {
            m_ascent = targetSize;
            m_descent = 0;

void MathOperator::fillWithVerticalExtensionGlyph(const RenderStyle& style, PaintInfo& info, const LayoutPoint& from, const LayoutPoint& to)
{
    ASSERT(m_operatorType == Type::VerticalOperator);
    ASSERT(isAssembly());
    auto& assembly = this->assembly();
    ASSERT(assembly.extension.font);
    ASSERT(from.y() <= to.y());

    // If there is no space for the extension glyph, we don't need to do anything.


    GraphicsContextStateSaver stateSaver(info.context());

    FloatRect glyphBounds = boundsForGlyph(assembly.extension);

    // Clipping the extender region here allows us to draw the bottom extender glyph into the
    // regions of the bottom glyph without worrying about overdraw (hairy pixels) and simplifies later clipping.


    // In practice, only small stretch sizes are requested but we limit the number of glyphs to avoid hangs.
    for (unsigned extensionCount = 0; lastPaintedGlyphRect.maxY() < to.y() && extensionCount < kMaximumExtensionCount; extensionCount++) {
        lastPaintedGlyphRect = paintGlyph(style, info, assembly.extension, glyphOrigin, TrimTopAndBottom);
        glyphOrigin.setY(glyphOrigin.y() + lastPaintedGlyphRect.height());

        // There's a chance that if the font size is small enough the glue glyph has been reduced to an empty rectangle

void MathOperator::fillWithHorizontalExtensionGlyph(const RenderStyle& style, PaintInfo& info, const LayoutPoint& from, const LayoutPoint& to)
{
    ASSERT(m_operatorType == Type::HorizontalOperator);
    ASSERT(isAssembly());
    auto& assembly = this->assembly();
    ASSERT(assembly.extension.font);
    ASSERT(from.x() <= to.x());
    ASSERT(from.y() == to.y());



    // In practice, only small stretch sizes are requested but we limit the number of glyphs to avoid hangs.
    for (unsigned extensionCount = 0; lastPaintedGlyphRect.maxX() < to.x() && extensionCount < kMaximumExtensionCount; extensionCount++) {
        lastPaintedGlyphRect = paintGlyph(style, info, assembly.extension, glyphOrigin, TrimLeftAndRight);
        glyphOrigin.setX(glyphOrigin.x() + lastPaintedGlyphRect.width());

        // There's a chance that if the font size is small enough the glue glyph has been reduced to an empty rectangle

void MathOperator::paintVerticalGlyphAssembly(const RenderStyle& style, PaintInfo& info, const LayoutPoint& paintOffset)
{
    ASSERT(m_operatorType == Type::VerticalOperator);
    ASSERT(isAssembly());
    auto& assembly = this->assembly();
    ASSERT(assembly.topOrRight.font);
    ASSERT(assembly.bottomOrLeft.font);

    // We are positioning the glyphs so that the edge of the tight glyph bounds line up exactly with the edges of our paint box.
    LayoutPoint operatorTopLeft = paintOffset;
    FloatRect topGlyphBounds = boundsForGlyph(assembly.topOrRight);
    LayoutPoint topGlyphOrigin(operatorTopLeft.x(), operatorTopLeft.y() - topGlyphBounds.y());
    LayoutRect topGlyphPaintRect = paintGlyph(style, info, assembly.topOrRight, topGlyphOrigin, TrimBottom);

    FloatRect bottomGlyphBounds = boundsForGlyph(assembly.bottomOrLeft);
    LayoutPoint bottomGlyphOrigin(operatorTopLeft.x(), operatorTopLeft.y() + stretchSize() - (bottomGlyphBounds.height() + bottomGlyphBounds.y()));
    LayoutRect bottomGlyphPaintRect = paintGlyph(style, info, assembly.bottomOrLeft, bottomGlyphOrigin, TrimTop);

    if (assembly.middle.font) {
        // Center the glyph origin between the start and end glyph paint extents. Then shift it half the paint height toward the bottom glyph.
        FloatRect middleGlyphBounds = boundsForGlyph(assembly.middle);
        LayoutPoint middleGlyphOrigin(operatorTopLeft.x(), topGlyphOrigin.y());
        middleGlyphOrigin.moveBy(LayoutPoint(0, (bottomGlyphPaintRect.y() - topGlyphPaintRect.maxY()) / 2.0));
        middleGlyphOrigin.moveBy(LayoutPoint(0, middleGlyphBounds.height() / 2.0));

        LayoutRect middleGlyphPaintRect = paintGlyph(style, info, assembly.middle, middleGlyphOrigin, TrimTopAndBottom);
        fillWithVerticalExtensionGlyph(style, info, topGlyphPaintRect.minXMaxYCorner(), middleGlyphPaintRect.minXMinYCorner());
        fillWithVerticalExtensionGlyph(style, info, middleGlyphPaintRect.minXMaxYCorner(), bottomGlyphPaintRect.minXMinYCorner());
    } else

void MathOperator::paintHorizontalGlyphAssembly(const RenderStyle& style, PaintInfo& info, const LayoutPoint& paintOffset)
{
    ASSERT(m_operatorType == Type::HorizontalOperator);
    ASSERT(isAssembly());
    auto& assembly = this->assembly();
    ASSERT(assembly.bottomOrLeft.font);
    ASSERT(assembly.topOrRight.font);

    // We are positioning the glyphs so that the edge of the tight glyph bounds line up exactly with the edges of our paint box.
    LayoutPoint operatorTopLeft = paintOffset;
    LayoutUnit baselineY = operatorTopLeft.y() + m_ascent;
    LayoutPoint leftGlyphOrigin(operatorTopLeft.x(), baselineY);
    LayoutRect leftGlyphPaintRect = paintGlyph(style, info, assembly.bottomOrLeft, leftGlyphOrigin, TrimRight);

    FloatRect rightGlyphBounds = boundsForGlyph(assembly.topOrRight);
    LayoutPoint rightGlyphOrigin(operatorTopLeft.x() + stretchSize() - rightGlyphBounds.width(), baselineY);
    LayoutRect rightGlyphPaintRect = paintGlyph(style, info, assembly.topOrRight, rightGlyphOrigin, TrimLeft);

    if (assembly.middle.font) {
        // Center the glyph origin between the start and end glyph paint extents.
        LayoutPoint middleGlyphOrigin(operatorTopLeft.x(), baselineY);
        middleGlyphOrigin.moveBy(LayoutPoint((rightGlyphPaintRect.x() - leftGlyphPaintRect.maxX()) / 2.0, 0));
        LayoutRect middleGlyphPaintRect = paintGlyph(style, info, assembly.middle, middleGlyphOrigin, TrimLeftAndRight);
        fillWithHorizontalExtensionGlyph(style, info, LayoutPoint(leftGlyphPaintRect.maxX(), baselineY), LayoutPoint(middleGlyphPaintRect.x(), baselineY));
        fillWithHorizontalExtensionGlyph(style, info, LayoutPoint(middleGlyphPaintRect.maxX(), baselineY), LayoutPoint(rightGlyphPaintRect.x(), baselineY));
    } else

        }
    }

    if (isAssembly()) {
        if (m_operatorType == Type::VerticalOperator)
            paintVerticalGlyphAssembly(style, info, paintOffset);
        else

    }

    GlyphData glyphData;
    ASSERT(!m_variantOrAssembly || isVariant());
    if (!m_variantOrAssembly) {
        if (!getBaseGlyph(style, glyphData))
            return;
    } else if (isVariant()) {
        auto& variant = this->variant();
        ASSERT(variant.font);
        glyphData = variant;
    }
    GlyphBuffer buffer;
    buffer.add(glyphData.glyph, glyphData.font, advanceWidthForGlyph(glyphData));

    paintInfo.context().drawGlyphs(style.fontCascade(), *glyphData.font, buffer, 0, 1, operatorOrigin);
}

bool MathOperator::isVariant() const
{
    if (!m_variantOrAssembly)
        return false;

    bool result = false;
    auto visitor = WTF::makeVisitor(
        [&](GlyphData&) { result = true; },
        [&](GlyphAssemblyData&) { result = false; }
    );
    std::experimental::visit(visitor, m_variantOrAssembly);
    return result;
}

bool MathOperator::isAssembly() const
{
    if (!m_variantOrAssembly)
        return false;

    bool result = false;
    auto visitor = WTF::makeVisitor(
        [&](GlyphData&) { result = false; },
        [&](GlyphAssemblyData&) { result = true; }
    );
    std::experimental::visit(visitor, m_variantOrAssembly);
    return result;
}

GlyphData& MathOperator::variant()
{
    ASSERT(m_variantOrAssembly);
    GlyphData* result = nullptr;
    auto visitor = WTF::makeVisitor(
        [&](GlyphData& m_variant) { result = &m_variant; },
        [&](GlyphAssemblyData&) { CRASH_WITH_SECURITY_IMPLICATION(); }
    );
    std::experimental::visit(visitor, m_variantOrAssembly.value());
    return *result;
}

GlyphAssemblyData& MathOperator::assembly()
{
    ASSERT(m_variantOrAssembly);
    GlyphAssemblyData* result = nullptr;
    auto visitor = WTF::makeVisitor(
        [&](GlyphData&) { CRASH_WITH_SECURITY_IMPLICATION() },
        [&](GlyphAssemblyData&, m_assembly) { result = &m_assembly; }
    );
    std::experimental::visit(visitor, m_variantOrAssembly.value());
    return *result;
}

}

#endif

Lines 31-36 a/Source/WebCore/rendering/mathml/MathOperator.h_sec1
- a/Source/WebCore/rendering/mathml/MathOperator.h -6 / +8 lines
31	#include "OpenTypeMathData.h"	31	#include "OpenTypeMathData.h"
32	#include "PaintInfo.h"	32	#include "PaintInfo.h"
33	#include <unicode/utypes.h>	33	#include <unicode/utypes.h>
		34	#include <wtf/Optional.h>
		35	#include <wtf/Variant.h>
34		36
35	namespace WebCore {	37	namespace WebCore {
36		38
Lines 61-67 private: a/Source/WebCore/rendering/mathml/MathOperator.h_sec2
61	GlyphData bottomOrLeft;	63	GlyphData bottomOrLeft;
62	GlyphData middle;	64	GlyphData middle;
63	};	65	};
64	enum class StretchType { Unstretched, SizeVariant, GlyphAssembly };
65	enum GlyphPaintTrimming {	66	enum GlyphPaintTrimming {
66	TrimTop,	67	TrimTop,
67	TrimBottom,	68	TrimBottom,
Lines 87-99 private: a/Source/WebCore/rendering/mathml/MathOperator.h_sec3
87	void paintVerticalGlyphAssembly(const RenderStyle&, PaintInfo&, const LayoutPoint&);	88	void paintVerticalGlyphAssembly(const RenderStyle&, PaintInfo&, const LayoutPoint&);
88	void paintHorizontalGlyphAssembly(const RenderStyle&, PaintInfo&, const LayoutPoint&);	89	void paintHorizontalGlyphAssembly(const RenderStyle&, PaintInfo&, const LayoutPoint&);
89		90
		91	bool isVariant() const;
		92	bool isAssembly() const;
		93	GlyphData& variant();
		94	GlyphAssemblyData& assembly();
		95
90	UChar m_baseCharacter { 0 };	96	UChar m_baseCharacter { 0 };
91	Type m_operatorType { Type::NormalOperator };	97	Type m_operatorType { Type::NormalOperator };
92	StretchType m_stretchType { StretchType::Unstretched };	98	Optional<std::experimental::variant<GlyphData, GlyphAssemblyData>> m_variantOrAssembly;
93	union {
94	GlyphData m_variant;
95	GlyphAssemblyData m_assembly;
96	};
97	LayoutUnit m_maxPreferredWidth { 0 };	99	LayoutUnit m_maxPreferredWidth { 0 };
98	LayoutUnit m_width { 0 };	100	LayoutUnit m_width { 0 };
99	LayoutUnit m_ascent { 0 };	101	LayoutUnit m_ascent { 0 };

Return to Bug 161119

Lines 337-349 ALWAYS_INLINE float Font::widthForGlyph(Glyph glyph) const a/Source/WebCore/platform/graphics/Font.h_sec1
- a/Source/WebCore/platform/graphics/Font.h -2 / +2 lines
337	return width;	337	return width;
338		338
339	#if ENABLE(OPENTYPE_VERTICAL)	339	#if ENABLE(OPENTYPE_VERTICAL)
340	if (m_verticalData)	340	if (m_verticalData) {
341	#if USE(CG) \|\| USE(CAIRO)	341	#if USE(CG) \|\| USE(CAIRO)
342	width = m_verticalData->advanceHeight(this, glyph) + m_syntheticBoldOffset;	342	width = m_verticalData->advanceHeight(this, glyph) + m_syntheticBoldOffset;
343	#else	343	#else
344	width = m_verticalData->advanceHeight(this, glyph);	344	width = m_verticalData->advanceHeight(this, glyph);
345	#endif	345	#endif
346	else	346	} else
347	#endif	347	#endif
348	width = platformWidthForGlyph(glyph);	348	width = platformWidthForGlyph(glyph);
349		349

Lines 622-639 float Font::platformWidthForGlyph(Glyph glyph) const a/Source/WebCore/platform/graphics/cocoa/FontCocoa.mm_sec1
- a/Source/WebCore/platform/graphics/cocoa/FontCocoa.mm -12 / +1 lines
622	{	622	{
623	CGSize advance = CGSizeZero;	623	CGSize advance = CGSizeZero;
624	bool horizontal = platformData().orientation() == Horizontal;	624	bool horizontal = platformData().orientation() == Horizontal;
625	bool populatedAdvance = false;	625	CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical, &glyph, &advance, 1);
626	if ((horizontal \|\| m_isBrokenIdeographFallback) && canUseFastGlyphAdvanceGetter(this->platformData(), glyph, advance, populatedAdvance)) {
627	float pointSize = platformData().size();
628	CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
629	CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing \| kCGFontRenderingStyleSubpixelPositioning \| kCGFontRenderingStyleSubpixelQuantization \| kCGFontAntialiasingStyleUnfiltered;
630	if (!CGFontGetGlyphAdvancesForStyle(platformData().cgFont(), &m, style, &glyph, 1, &advance)) {
631	RetainPtr<CFStringRef> fullName = adoptCF(CGFontCopyFullName(platformData().cgFont()));
632	LOG_ERROR("Unable to cache glyph widths for %@ %f", fullName.get(), pointSize);
633	advance.width = 0;
634	}
635	} else if (!populatedAdvance && platformData().size())
636	CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical, &glyph, &advance, 1);
637		626
638	return advance.width + m_syntheticBoldOffset;	627	return advance.width + m_syntheticBoldOffset;
639	}	628	}

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +27 lines
		1	2016-08-23 Myles C. Maxfield <mmaxfield@apple.com>
		2
		3	[Cocoa] Improve performance of glyph advance metrics gathering
		4	https://bugs.webkit.org/show_bug.cgi?id=161119
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	No new tests (OOPS!).
		9
		10	* platform/graphics/Font.cpp:
		11	(WebCore::Font::platformGlyphInit):
		12	* platform/graphics/Font.h:
		13	(WebCore::Font::widthForGlyph):
		14	* platform/graphics/GlyphPage.h:
		15	(WebCore::GlyphData::GlyphData):
		16	(WebCore::GlyphPage::advanceForCharacter):
		17	(WebCore::GlyphPage::glyphDataForIndex):
		18	(WebCore::GlyphPage::advanceForIndex):
		19	(WebCore::GlyphPage::setGlyphForIndex):
		20	* platform/graphics/WidthIterator.cpp:
		21	(WebCore::WidthIterator::advanceInternal):
		22	* platform/graphics/cocoa/FontCocoa.mm:
		23	(WebCore::Font::platformWidthForGlyph):
		24	* platform/graphics/mac/GlyphPageMac.cpp:
		25	(WebCore::GlyphPage::fill):
		26	* platform/spi/cocoa/CoreTextSPI.h:
		27
1	2016-08-23 Alex Christensen <achristensen@webkit.org>	28	2016-08-23 Alex Christensen <achristensen@webkit.org>
2		29
3	Fix clean Windows build.	30	Fix clean Windows build.

Lines 43-51 class Font; a/Source/WebCore/platform/graphics/GlyphPage.h_sec1
- a/Source/WebCore/platform/graphics/GlyphPage.h -7 / +28 lines
43	// Holds the glyph index and the corresponding Font information for a given	43	// Holds the glyph index and the corresponding Font information for a given
44	// character.	44	// character.
45	struct GlyphData {	45	struct GlyphData {
46	GlyphData(Glyph g = 0, const Font* f = 0)	46	GlyphData(Glyph g = 0, const Font* f = nullptr, Optional<float> advance = Nullopt)
47	: glyph(g)	47	: glyph(g)
48	, font(f)	48	, font(f)
		49	, advance(advance)
49	{	50	{
50	}	51	}
51		52
Lines 53-58 struct GlyphData { a/Source/WebCore/platform/graphics/GlyphPage.h_sec2
53		54
54	Glyph glyph;	55	Glyph glyph;
55	const Font* font;	56	const Font* font;
		57	Optional<float> advance;
56	};	58	};
57		59
58	// A GlyphPage contains a fixed-size set of GlyphData mappings for a contiguous	60	// A GlyphPage contains a fixed-size set of GlyphData mappings for a contiguous
Lines 72-78 public: a/Source/WebCore/platform/graphics/GlyphPage.h_sec3
72		74
73	static unsigned count() { return s_count; }	75	static unsigned count() { return s_count; }
74		76
75	static const size_t size = 256; // Covers Latin-1 in a single page.	77	static constexpr size_t size = 256; // Covers Latin-1 in a single page.
76	static unsigned indexForCharacter(UChar32 c) { return c % GlyphPage::size; }	78	static unsigned indexForCharacter(UChar32 c) { return c % GlyphPage::size; }
77		79
78	GlyphData glyphDataForCharacter(UChar32 c) const	80	GlyphData glyphDataForCharacter(UChar32 c) const
Lines 85-94 public: a/Source/WebCore/platform/graphics/GlyphPage.h_sec4
85	return glyphForIndex(indexForCharacter(c));	87	return glyphForIndex(indexForCharacter(c));
86	}	88	}
87		89
		90	Optional<float> advanceForCharacter(UChar32 c) const
		91	{
		92	return advanceForIndex(indexForCharacter(c));
		93	}
		94
88	GlyphData glyphDataForIndex(unsigned index) const	95	GlyphData glyphDataForIndex(unsigned index) const
89	{	96	{
90	Glyph glyph = glyphForIndex(index);	97	Glyph glyph = glyphForIndex(index);
91	return GlyphData(glyph, glyph ? &m_font : nullptr);	98	return GlyphData(glyph, glyph ? &m_font : nullptr, advanceForIndex(index));
92	}	99	}
93		100
94	Glyph glyphForIndex(unsigned index) const	101	Glyph glyphForIndex(unsigned index) const
Lines 97-107 public: a/Source/WebCore/platform/graphics/GlyphPage.h_sec5
97	return m_glyphs[index];	104	return m_glyphs[index];
98	}	105	}
99		106
100	// FIXME: Pages are immutable after initialization. This should be private.	107	Optional<float> advanceForIndex(unsigned index) const
101	void setGlyphForIndex(unsigned index, Glyph glyph)
102	{	108	{
103	ASSERT_WITH_SECURITY_IMPLICATION(index < size);	109	ASSERT_WITH_SECURITY_IMPLICATION(index < size);
104	m_glyphs[index] = glyph;	110	if (m_advances.isEmpty())
		111	return Nullopt;
		112	return m_advances[index];
105	}	113	}
106		114
107	const Font& font() const	115	const Font& font() const
Lines 119-126 private: a/Source/WebCore/platform/graphics/GlyphPage.h_sec6
119	++s_count;	127	++s_count;
120	}	128	}
121		129
		130	// FIXME: Pages are immutable after initialization. This should be private.
		131	void setGlyphForIndex(unsigned index, Glyph glyph, Optional<float> advance = Nullopt)
		132	{
		133	ASSERT_WITH_SECURITY_IMPLICATION(index < size);
		134	m_glyphs[index] = glyph;
		135	if (advance) {
		136	if (m_advances.isEmpty())
		137	m_advances.fill(0, size);
		138	m_advances[index] = advance.value();
		139	}
		140	}
		141
122	const Font& m_font;	142	const Font& m_font;
123	Glyph m_glyphs[size] { };	143	std::array<Glyph, size> m_glyphs { };
		144	Vector<float> m_advances;
124		145
125	WEBCORE_EXPORT static unsigned s_count;	146	WEBCORE_EXPORT static unsigned s_count;
126	};	147	};

Lines 63-77 bool GlyphPage::fill(UChar* buffer, unsigned bufferLength) a/Source/WebCore/platform/graphics/mac/GlyphPageMac.cpp_sec1
- a/Source/WebCore/platform/graphics/mac/GlyphPageMac.cpp -6 / +14 lines
63	ASSERT(bufferLength == GlyphPage::size \|\| bufferLength == 2 * GlyphPage::size);	63	ASSERT(bufferLength == GlyphPage::size \|\| bufferLength == 2 * GlyphPage::size);
64		64
65	const Font& font = this->font();	65	const Font& font = this->font();
66	Vector<CGGlyph, 512> glyphs(bufferLength);	66	Vector<CGGlyph> glyphs(bufferLength);
67	unsigned glyphStep;	67	memset(glyphs.data(), 0, sizeof(CGGlyph) * bufferLength);
68	if (!shouldUseCoreText(buffer, bufferLength, font)) {	68	if (!shouldUseCoreText(buffer, bufferLength, font)) {
69	// We pass in either 256 or 512 UTF-16 characters: 256 for U+FFFF and less, 512 (double character surrogates)	69	// We pass in either 256 or 512 UTF-16 characters: 256 for U+FFFF and less, 512 (double character surrogates)
70	// for U+10000 and above. It is indeed possible to get back 512 glyphs back from the API, so the glyph buffer	70	// for U+10000 and above. It is indeed possible to get back 512 glyphs back from the API, so the glyph buffer
71	// we pass in must be 512. If we get back more than 256 glyphs though we'll ignore all the ones after 256,	71	// we pass in must be 512. If we get back more than 256 glyphs though we'll ignore all the ones after 256,
72	// this should not happen as the only time we pass in 512 characters is when they are surrogates.	72	// this should not happen as the only time we pass in 512 characters is when they are surrogates.
73	CGFontGetGlyphsForUnichars(font.platformData().cgFont(), buffer, glyphs.data(), bufferLength);	73	CGFontGetGlyphsForUnichars(font.platformData().cgFont(), buffer, glyphs.data(), bufferLength);
74	glyphStep = 1;
75	} else {	74	} else {
76	// Because we know the implementation of shouldUseCoreText(), if the font isn't for text combine and it isn't a system font,	75	// Because we know the implementation of shouldUseCoreText(), if the font isn't for text combine and it isn't a system font,
77	// we know it must have vertical glyphs.	76	// we know it must have vertical glyphs.
Lines 82-94 bool GlyphPage::fill(UChar* buffer, unsigned bufferLength) a/Source/WebCore/platform/graphics/mac/GlyphPageMac.cpp_sec2
82		81
83	// When buffer consists of surrogate pairs, CTFontGetVerticalGlyphsForCharacters and CTFontGetGlyphsForCharacters	82	// When buffer consists of surrogate pairs, CTFontGetVerticalGlyphsForCharacters and CTFontGetGlyphsForCharacters
84	// place the glyphs at indices corresponding to the first character of each pair.	83	// place the glyphs at indices corresponding to the first character of each pair.
85	glyphStep = bufferLength / GlyphPage::size;	84	unsigned glyphStep = bufferLength / GlyphPage::size;
		85	if (glyphStep != 1) {
		86	for (unsigned i = 0; i < GlyphPage::size; ++i)
		87	glyphs[i] = glyphs[i * glyphStep];
		88	}
86	}	89	}
87		90
		91	Vector<CGSize> advances(GlyphPage::size);
		92	CTFontOrientation orientation = font.platformData().orientation() == Horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical;
		93	CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing \| kCGFontRenderingStyleSubpixelPositioning \| kCGFontRenderingStyleSubpixelQuantization \| kCGFontAntialiasingStyleUnfiltered;
		94	CTFontGetUnsummedAdvancesForGlyphsAndStyle(font.platformData().ctFont(), orientation, style, glyphs.data(), advances.data(), GlyphPage::size);
		95
88	bool haveGlyphs = false;	96	bool haveGlyphs = false;
89	for (unsigned i = 0; i < GlyphPage::size; ++i) {	97	for (unsigned i = 0; i < GlyphPage::size; ++i) {
90	if (glyphs[i * glyphStep]) {	98	if (glyphs[i]) {
91	setGlyphForIndex(i, glyphs[i * glyphStep]);	99	setGlyphForIndex(i, glyphs[i], advances[i].width);
92	haveGlyphs = true;	100	haveGlyphs = true;
93	}	101	}
94	}	102	}

Lines 42-47 enum { a/Source/WebCore/platform/spi/cocoa/CoreTextSPI.h_sec1
- a/Source/WebCore/platform/spi/cocoa/CoreTextSPI.h -23 / +13 lines
42	kCTFontUIFontSystemUltraLight = 104,	42	kCTFontUIFontSystemUltraLight = 104,
43	};	43	};
44		44
		45	typedef CF_OPTIONS(uint32_t, CTFontTransformOptions)
		46	{
		47	kCTFontTransformApplyShaping = (1 << 0),
		48	kCTFontTransformApplyPositioning = (1 << 1)
		49	};
		50
		51	typedef CF_OPTIONS(uint32_t, CTFontDescriptorOptions)
		52	{
		53	kCTFontDescriptorOptionSystemUIFont = 1 << 1,
		54	kCTFontDescriptorOptionPreferAppleSystemFont = kCTFontOptionsPreferSystemFont
		55	};
		56
45	#endif	57	#endif
46		58
47	extern "C" {	59	extern "C" {
Lines 52-98 typedef void (CTUniCharDisposeCallback)(const UniChar chars, void* refCon); a/Source/WebCore/platform/spi/cocoa/CoreTextSPI.h_sec2
52	extern const CFStringRef kCTFontReferenceURLAttribute;	64	extern const CFStringRef kCTFontReferenceURLAttribute;
53	extern const CFStringRef kCTFontOpticalSizeAttribute;	65	extern const CFStringRef kCTFontOpticalSizeAttribute;
54		66
55	#if PLATFORM(COCOA)
56	#if !USE(APPLE_INTERNAL_SDK)
57	typedef CF_OPTIONS(uint32_t, CTFontTransformOptions)
58	{
59	kCTFontTransformApplyShaping = (1 << 0),
60	kCTFontTransformApplyPositioning = (1 << 1)
61	};
62	#endif
63	bool CTFontTransformGlyphs(CTFontRef, CGGlyph glyphs[], CGSize advances[], CFIndex count, CTFontTransformOptions);	67	bool CTFontTransformGlyphs(CTFontRef, CGGlyph glyphs[], CGSize advances[], CFIndex count, CTFontTransformOptions);
64	#endif
65		68
66	CGSize CTRunGetInitialAdvance(CTRunRef run);	69	CGSize CTRunGetInitialAdvance(CTRunRef run);
67	CTLineRef CTLineCreateWithUniCharProvider(CTUniCharProviderCallback provide, CTUniCharDisposeCallback dispose, void* refCon);	70	CTLineRef CTLineCreateWithUniCharProvider(CTUniCharProviderCallback provide, CTUniCharDisposeCallback dispose, void* refCon);
68	CTTypesetterRef CTTypesetterCreateWithUniCharProviderAndOptions(CTUniCharProviderCallback provide, CTUniCharDisposeCallback dispose, void* refCon, CFDictionaryRef options);	71	CTTypesetterRef CTTypesetterCreateWithUniCharProviderAndOptions(CTUniCharProviderCallback provide, CTUniCharDisposeCallback dispose, void* refCon, CFDictionaryRef options);
69	bool CTFontGetVerticalGlyphsForCharacters(CTFontRef, const UniChar characters[], CGGlyph glyphs[], CFIndex count);	72	bool CTFontGetVerticalGlyphsForCharacters(CTFontRef, const UniChar characters[], CGGlyph glyphs[], CFIndex count);
		73	void CTFontGetUnsummedAdvancesForGlyphsAndStyle(CTFontRef, CTFontOrientation, CGFontRenderingStyle, const CGGlyph[], CGSize advances[], CFIndex count);
70		74
71	CTFontDescriptorRef CTFontDescriptorCreateForUIType(CTFontUIFontType, CGFloat size, CFStringRef language);	75	CTFontDescriptorRef CTFontDescriptorCreateForUIType(CTFontUIFontType, CGFloat size, CFStringRef language);
72	CTFontDescriptorRef CTFontDescriptorCreateWithTextStyle(CFStringRef style, CFStringRef size, CFStringRef language);	76	CTFontDescriptorRef CTFontDescriptorCreateWithTextStyle(CFStringRef style, CFStringRef size, CFStringRef language);
73	CTFontDescriptorRef CTFontDescriptorCreateCopyWithSymbolicTraits(CTFontDescriptorRef original, CTFontSymbolicTraits symTraitValue, CTFontSymbolicTraits symTraitMask);	77	CTFontDescriptorRef CTFontDescriptorCreateCopyWithSymbolicTraits(CTFontDescriptorRef original, CTFontSymbolicTraits symTraitValue, CTFontSymbolicTraits symTraitMask);
74	CFBitVectorRef CTFontCopyGlyphCoverageForFeature(CTFontRef, CFDictionaryRef feature);	78	CFBitVectorRef CTFontCopyGlyphCoverageForFeature(CTFontRef, CFDictionaryRef feature);
75		79
76	#if PLATFORM(COCOA)
77	#if !USE(APPLE_INTERNAL_SDK)
78	typedef CF_OPTIONS(uint32_t, CTFontDescriptorOptions)
79	{
80	kCTFontDescriptorOptionSystemUIFont = 1 << 1,
81	kCTFontDescriptorOptionPreferAppleSystemFont = kCTFontOptionsPreferSystemFont
82	};
83
84	CTFontDescriptorRef CTFontDescriptorCreateWithAttributesAndOptions(CFDictionaryRef attributes, CTFontDescriptorOptions);	80	CTFontDescriptorRef CTFontDescriptorCreateWithAttributesAndOptions(CFDictionaryRef attributes, CTFontDescriptorOptions);
85		81
86	extern const CFStringRef kCTFontDescriptorTextStyleAttribute;	82	extern const CFStringRef kCTFontDescriptorTextStyleAttribute;
87	extern const CFStringRef kCTFontUIFontDesignTrait;	83	extern const CFStringRef kCTFontUIFontDesignTrait;
88	#endif
89	#endif
90		84
91	bool CTFontDescriptorIsSystemUIFont(CTFontDescriptorRef);	85	bool CTFontDescriptorIsSystemUIFont(CTFontDescriptorRef);
92	CTFontRef CTFontCreateForCSS(CFStringRef name, uint16_t weight, CTFontSymbolicTraits, CGFloat size);	86	CTFontRef CTFontCreateForCSS(CFStringRef name, uint16_t weight, CTFontSymbolicTraits, CGFloat size);
93	CTFontRef CTFontCreateForCharactersWithLanguage(CTFontRef currentFont, const UTF16Char characters, CFIndex length, CFStringRef language, CFIndex coveredLength);	87	CTFontRef CTFontCreateForCharactersWithLanguage(CTFontRef currentFont, const UTF16Char characters, CFIndex length, CFStringRef language, CFIndex coveredLength);
94		88
95	#if PLATFORM(COCOA)
96	extern const CFStringRef kCTUIFontTextStyleShortHeadline;	89	extern const CFStringRef kCTUIFontTextStyleShortHeadline;
97	extern const CFStringRef kCTUIFontTextStyleShortBody;	90	extern const CFStringRef kCTUIFontTextStyleShortBody;
98	extern const CFStringRef kCTUIFontTextStyleShortSubhead;	91	extern const CFStringRef kCTUIFontTextStyleShortSubhead;
Lines 118-131 extern const CGFloat kCTFontWeightSemibold; a/Source/WebCore/platform/spi/cocoa/CoreTextSPI.h_sec3
118	extern const CGFloat kCTFontWeightBold;	111	extern const CGFloat kCTFontWeightBold;
119	extern const CGFloat kCTFontWeightHeavy;	112	extern const CGFloat kCTFontWeightHeavy;
120	extern const CGFloat kCTFontWeightBlack;	113	extern const CGFloat kCTFontWeightBlack;
121	#endif
122		114
123	#if PLATFORM(IOS)
124	extern const CFStringRef kCTUIFontTextStyleTitle1;	115	extern const CFStringRef kCTUIFontTextStyleTitle1;
125	extern const CFStringRef kCTUIFontTextStyleTitle2;	116	extern const CFStringRef kCTUIFontTextStyleTitle2;
126	extern const CFStringRef kCTUIFontTextStyleTitle3;	117	extern const CFStringRef kCTUIFontTextStyleTitle3;
127	CTFontDescriptorRef CTFontCreatePhysicalFontDescriptorForCharactersWithLanguage(CTFontRef currentFont, const UTF16Char* characters, CFIndex length, CFStringRef language, CFIndex* coveredLength);	118	CTFontDescriptorRef CTFontCreatePhysicalFontDescriptorForCharactersWithLanguage(CTFontRef currentFont, const UTF16Char* characters, CFIndex length, CFStringRef language, CFIndex* coveredLength);
128	#endif
129		119
130	CTFontRef CTFontCreatePhysicalFontForCharactersWithLanguage(CTFontRef, const UTF16Char* characters, CFIndex length, CFStringRef language, CFIndex* coveredLength);	120	CTFontRef CTFontCreatePhysicalFontForCharactersWithLanguage(CTFontRef, const UTF16Char* characters, CFIndex length, CFStringRef language, CFIndex* coveredLength);
131	bool CTFontIsAppleColorEmoji(CTFontRef);	121	bool CTFontIsAppleColorEmoji(CTFontRef);