FontCache should only deal with SimpleFontData
[WebKit-https.git] / Source / WebCore / platform / graphics / mac / FontMac.mm
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #import "config.h"
24 #import "Font.h"
25
26 #import "CoreGraphicsSPI.h"
27 #import "CoreTextSPI.h"
28 #import "DashArray.h"
29 #import "GlyphBuffer.h"
30 #import "GraphicsContext.h"
31 #import "Logging.h"
32 #import "SimpleFontData.h"
33 #import "WebCoreSystemInterface.h"
34 #if USE(APPKIT)
35 #import <AppKit/AppKit.h>
36 #endif
37 #import <wtf/MathExtras.h>
38
39 #if ENABLE(LETTERPRESS)
40 #import "CoreUISPI.h"
41 #import "SoftLinking.h"
42
43 SOFT_LINK_PRIVATE_FRAMEWORK(CoreUI)
44 SOFT_LINK_CLASS(CoreUI, CUICatalog)
45 SOFT_LINK_CLASS(CoreUI, CUIStyleEffectConfiguration)
46
47 SOFT_LINK_FRAMEWORK(UIKit)
48 SOFT_LINK(UIKit, _UIKitGetTextEffectsCatalog, CUICatalog *, (void), ())
49 #endif
50
51 #define SYNTHETIC_OBLIQUE_ANGLE 14
52
53 #ifdef __LP64__
54 #define URefCon void*
55 #else
56 #define URefCon UInt32
57 #endif
58
59 namespace WebCore {
60
61 bool Font::canReturnFallbackFontsForComplexText()
62 {
63     return true;
64 }
65
66 bool Font::canExpandAroundIdeographsInComplexText()
67 {
68     return true;
69 }
70
71 static inline void fillVectorWithHorizontalGlyphPositions(Vector<CGPoint, 256>& positions, CGContextRef context, const CGSize* advances, size_t count)
72 {
73     CGAffineTransform matrix = CGAffineTransformInvert(CGContextGetTextMatrix(context));
74     positions[0] = CGPointZero;
75     for (size_t i = 1; i < count; ++i) {
76         CGSize advance = CGSizeApplyAffineTransform(advances[i - 1], matrix);
77         positions[i].x = positions[i - 1].x + advance.width;
78         positions[i].y = positions[i - 1].y + advance.height;
79     }
80 }
81
82 static inline bool shouldUseLetterpressEffect(const GraphicsContext& context)
83 {
84 #if ENABLE(LETTERPRESS)
85     return context.textDrawingMode() & TextModeLetterpress;
86 #else
87     UNUSED_PARAM(context);
88     return false;
89 #endif
90 }
91
92 static void showLetterpressedGlyphsWithAdvances(const FloatPoint& point, const SimpleFontData* font, CGContextRef context, const CGGlyph* glyphs, const CGSize* advances, size_t count)
93 {
94 #if ENABLE(LETTERPRESS)
95     if (!count)
96         return;
97
98     const FontPlatformData& platformData = font->platformData();
99     if (platformData.orientation() == Vertical) {
100         // FIXME: Implement support for vertical text. See <rdar://problem/13737298>.
101         return;
102     }
103
104     CGContextSetTextPosition(context, point.x(), point.y());
105     Vector<CGPoint, 256> positions(count);
106     fillVectorWithHorizontalGlyphPositions(positions, context, advances, count);
107
108     CTFontRef ctFont = platformData.ctFont();
109     CGContextSetFontSize(context, CTFontGetSize(ctFont));
110
111     static CUICatalog *catalog = _UIKitGetTextEffectsCatalog();
112     if (!catalog)
113         return;
114
115     static CUIStyleEffectConfiguration *styleConfiguration;
116     if (!styleConfiguration) {
117         styleConfiguration = [allocCUIStyleEffectConfigurationInstance() init];
118         styleConfiguration.useSimplifiedEffect = YES;
119     }
120
121     [catalog drawGlyphs:glyphs atPositions:positions.data() inContext:context withFont:ctFont count:count stylePresetName:@"_UIKitNewLetterpressStyle" styleConfiguration:styleConfiguration foregroundColor:CGContextGetFillColorAsColor(context)];
122 #else
123     UNUSED_PARAM(point);
124     UNUSED_PARAM(font);
125     UNUSED_PARAM(context);
126     UNUSED_PARAM(glyphs);
127     UNUSED_PARAM(advances);
128     UNUSED_PARAM(count);
129 #endif
130 }
131
132 static void showGlyphsWithAdvances(const FloatPoint& point, const SimpleFontData* font, CGContextRef context, const CGGlyph* glyphs, const CGSize* advances, size_t count)
133 {
134     if (!count)
135         return;
136
137     CGContextSetTextPosition(context, point.x(), point.y());
138
139     const FontPlatformData& platformData = font->platformData();
140     Vector<CGPoint, 256> positions(count);
141     if (platformData.isColorBitmapFont())
142         fillVectorWithHorizontalGlyphPositions(positions, context, advances, count);
143     if (platformData.orientation() == Vertical) {
144         CGAffineTransform savedMatrix;
145         CGAffineTransform rotateLeftTransform = CGAffineTransformMake(0, -1, 1, 0, 0, 0);
146         savedMatrix = CGContextGetTextMatrix(context);
147         CGAffineTransform runMatrix = CGAffineTransformConcat(savedMatrix, rotateLeftTransform);
148         CGContextSetTextMatrix(context, runMatrix);
149
150         Vector<CGSize, 256> translations(count);
151         CTFontGetVerticalTranslationsForGlyphs(platformData.ctFont(), glyphs, translations.data(), count);
152
153         CGAffineTransform transform = CGAffineTransformInvert(CGContextGetTextMatrix(context));
154
155         CGPoint position = FloatPoint(point.x(), point.y() + font->fontMetrics().floatAscent(IdeographicBaseline) - font->fontMetrics().floatAscent());
156         for (size_t i = 0; i < count; ++i) {
157             CGSize translation = CGSizeApplyAffineTransform(translations[i], rotateLeftTransform);
158             positions[i] = CGPointApplyAffineTransform(CGPointMake(position.x - translation.width, position.y + translation.height), transform);
159             position.x += advances[i].width;
160             position.y += advances[i].height;
161         }
162         if (!platformData.isColorBitmapFont())
163             CGContextShowGlyphsAtPositions(context, glyphs, positions.data(), count);
164         else
165             CTFontDrawGlyphs(platformData.ctFont(), glyphs, positions.data(), count, context);
166         CGContextSetTextMatrix(context, savedMatrix);
167     } else {
168         if (!platformData.isColorBitmapFont())
169 #pragma clang diagnostic push
170 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
171             CGContextShowGlyphsWithAdvances(context, glyphs, advances, count);
172 #pragma clang diagnostic pop
173         else
174             CTFontDrawGlyphs(platformData.ctFont(), glyphs, positions.data(), count, context);
175     }
176 }
177
178 #if PLATFORM(MAC)
179 static void setCGFontRenderingMode(CGContextRef cgContext, NSFontRenderingMode renderingMode, BOOL shouldSubpixelQuantize)
180 {
181     if (renderingMode == NSFontIntegerAdvancementsRenderingMode) {
182         CGContextSetShouldAntialiasFonts(cgContext, false);
183         return;
184     }
185
186     CGContextSetShouldAntialiasFonts(cgContext, true);
187
188     CGAffineTransform contextTransform = CGContextGetCTM(cgContext);
189     BOOL isTranslationOrIntegralScale = WTF::isIntegral(contextTransform.a) && WTF::isIntegral(contextTransform.d) && contextTransform.b == 0.f && contextTransform.c == 0.f;
190     BOOL isRotated = ((contextTransform.b || contextTransform.c) && (contextTransform.a || contextTransform.d));
191     BOOL doSubpixelQuantization = isTranslationOrIntegralScale || (!isRotated && shouldSubpixelQuantize);
192
193     CGContextSetShouldSubpixelPositionFonts(cgContext, renderingMode != NSFontAntialiasedIntegerAdvancementsRenderingMode || !isTranslationOrIntegralScale);
194     CGContextSetShouldSubpixelQuantizeFonts(cgContext, doSubpixelQuantization);
195 }
196 #endif
197
198 void Font::drawGlyphs(GraphicsContext* context, const SimpleFontData* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& anchorPoint) const
199 {
200     const FontPlatformData& platformData = font->platformData();
201     if (!platformData.size())
202         return;
203
204     CGContextRef cgContext = context->platformContext();
205
206     bool shouldSmoothFonts;
207     bool changeFontSmoothing;
208     
209     switch(fontDescription().fontSmoothing()) {
210     case Antialiased: {
211         context->setShouldAntialias(true);
212         shouldSmoothFonts = false;
213         changeFontSmoothing = true;
214         break;
215     }
216     case SubpixelAntialiased: {
217         context->setShouldAntialias(true);
218         shouldSmoothFonts = true;
219         changeFontSmoothing = true;
220         break;
221     }
222     case NoSmoothing: {
223         context->setShouldAntialias(false);
224         shouldSmoothFonts = false;
225         changeFontSmoothing = true;
226         break;
227     }
228     case AutoSmoothing: {
229         shouldSmoothFonts = true;
230         changeFontSmoothing = false;
231         break;
232     }
233     }
234     
235     if (!shouldUseSmoothing()) {
236         shouldSmoothFonts = false;
237         changeFontSmoothing = true;
238     }
239
240 #if !PLATFORM(IOS)
241     bool originalShouldUseFontSmoothing = false;
242     if (changeFontSmoothing) {
243         originalShouldUseFontSmoothing = CGContextGetShouldSmoothFonts(cgContext);
244         CGContextSetShouldSmoothFonts(cgContext, shouldSmoothFonts);
245     }
246 #endif
247
248 #if !PLATFORM(IOS)
249     NSFont* drawFont;
250     if (!isPrinterFont()) {
251         drawFont = [platformData.nsFont() screenFont];
252         if (drawFont != platformData.nsFont()) {
253             // We are getting this in too many places (3406411); use ERROR so it only prints on debug versions for now. (We should debug this also, eventually).
254             LOG_ERROR("Attempting to set non-screen font (%@) when drawing to screen.  Using screen font anyway, may result in incorrect metrics.",
255                 [[[platformData.nsFont() fontDescriptor] fontAttributes] objectForKey:NSFontNameAttribute]);
256         }
257     } else {
258         drawFont = [platformData.nsFont() printerFont];
259         if (drawFont != platformData.nsFont()) {
260             NSLog(@"Attempting to set non-printer font (%@) when printing.  Using printer font anyway, may result in incorrect metrics.",
261                 [[[platformData.nsFont() fontDescriptor] fontAttributes] objectForKey:NSFontNameAttribute]);
262         }
263     }
264 #endif
265     
266     CGContextSetFont(cgContext, platformData.cgFont());
267
268     bool useLetterpressEffect = shouldUseLetterpressEffect(*context);
269     FloatPoint point = anchorPoint;
270 #if PLATFORM(IOS)
271     float fontSize = platformData.size();
272     CGAffineTransform matrix = useLetterpressEffect || platformData.isColorBitmapFont() ? CGAffineTransformIdentity : CGAffineTransformMakeScale(fontSize, fontSize);
273     if (platformData.m_isEmoji) {
274         if (!context->emojiDrawingEnabled())
275             return;
276
277         // Mimic the positioining of non-bitmap glyphs, which are not subpixel-positioned.
278         point.setY(ceilf(point.y()));
279
280         // Emoji glyphs snap to the CSS pixel grid.
281         point.setX(floorf(point.x()));
282
283         // Emoji glyphs are offset one CSS pixel to the right.
284         point.move(1, 0);
285
286         // Emoji glyphs are offset vertically based on font size.
287         float y = point.y();
288         if (fontSize <= 15) {
289             // Undo Core Text's y adjustment.
290             static float yAdjustmentFactor = iosExecutableWasLinkedOnOrAfterVersion(wkIOSSystemVersion_6_0) ? .19 : .1;
291             point.setY(floorf(y - yAdjustmentFactor * (fontSize + 2) + 2));
292         } else {
293             if (fontSize < 26)
294                 y -= .35f * fontSize - 10;
295
296             // Undo Core Text's y adjustment.
297             static float yAdjustment = iosExecutableWasLinkedOnOrAfterVersion(wkIOSSystemVersion_6_0) ? 3.8 : 2;
298             point.setY(floorf(y - yAdjustment));
299         }
300     }
301 #else
302     CGAffineTransform matrix = CGAffineTransformIdentity;
303     if (drawFont && !platformData.isColorBitmapFont())
304         memcpy(&matrix, [drawFont matrix], sizeof(matrix));
305 #endif
306     matrix.b = -matrix.b;
307     matrix.d = -matrix.d;
308     if (platformData.m_syntheticOblique) {
309         static float obliqueSkew = tanf(SYNTHETIC_OBLIQUE_ANGLE * piFloat / 180);
310         if (platformData.orientation() == Vertical)
311             matrix = CGAffineTransformConcat(matrix, CGAffineTransformMake(1, obliqueSkew, 0, 1, 0, 0));
312         else
313             matrix = CGAffineTransformConcat(matrix, CGAffineTransformMake(1, 0, -obliqueSkew, 1, 0, 0));
314     }
315     CGContextSetTextMatrix(cgContext, matrix);
316
317 #if PLATFORM(IOS)
318     CGContextSetFontSize(cgContext, 1);
319     CGContextSetShouldSubpixelQuantizeFonts(cgContext, context->shouldSubpixelQuantizeFonts());
320 #else
321     setCGFontRenderingMode(cgContext, [drawFont renderingMode], context->shouldSubpixelQuantizeFonts());
322     if (drawFont)
323         CGContextSetFontSize(cgContext, 1);
324     else
325         CGContextSetFontSize(cgContext, platformData.m_size);
326 #endif
327
328
329     FloatSize shadowOffset;
330     float shadowBlur;
331     Color shadowColor;
332     ColorSpace shadowColorSpace;
333     ColorSpace fillColorSpace = context->fillColorSpace();
334     context->getShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace);
335
336     AffineTransform contextCTM = context->getCTM();
337     float syntheticBoldOffset = font->syntheticBoldOffset();
338     if (syntheticBoldOffset && !contextCTM.isIdentityOrTranslationOrFlipped()) {
339         FloatSize horizontalUnitSizeInDevicePixels = contextCTM.mapSize(FloatSize(1, 0));
340         float horizontalUnitLengthInDevicePixels = sqrtf(horizontalUnitSizeInDevicePixels.width() * horizontalUnitSizeInDevicePixels.width() + horizontalUnitSizeInDevicePixels.height() * horizontalUnitSizeInDevicePixels.height());
341         if (horizontalUnitLengthInDevicePixels)
342             syntheticBoldOffset /= horizontalUnitLengthInDevicePixels;
343     };
344
345     bool hasSimpleShadow = context->textDrawingMode() == TextModeFill && shadowColor.isValid() && !shadowBlur && !platformData.isColorBitmapFont() && (!context->shadowsIgnoreTransforms() || contextCTM.isIdentityOrTranslationOrFlipped()) && !context->isInTransparencyLayer();
346     if (hasSimpleShadow) {
347         // Paint simple shadows ourselves instead of relying on CG shadows, to avoid losing subpixel antialiasing.
348         context->clearShadow();
349         Color fillColor = context->fillColor();
350         Color shadowFillColor(shadowColor.red(), shadowColor.green(), shadowColor.blue(), shadowColor.alpha() * fillColor.alpha() / 255);
351         context->setFillColor(shadowFillColor, shadowColorSpace);
352         float shadowTextX = point.x() + shadowOffset.width();
353         // If shadows are ignoring transforms, then we haven't applied the Y coordinate flip yet, so down is negative.
354         float shadowTextY = point.y() + shadowOffset.height() * (context->shadowsIgnoreTransforms() ? -1 : 1);
355         showGlyphsWithAdvances(FloatPoint(shadowTextX, shadowTextY), font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
356 #if !PLATFORM(IOS)
357         if (syntheticBoldOffset)
358 #else
359         if (syntheticBoldOffset && !platformData.m_isEmoji)
360 #endif
361             showGlyphsWithAdvances(FloatPoint(shadowTextX + syntheticBoldOffset, shadowTextY), font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
362         context->setFillColor(fillColor, fillColorSpace);
363     }
364
365     if (useLetterpressEffect)
366         showLetterpressedGlyphsWithAdvances(point, font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
367     else
368         showGlyphsWithAdvances(point, font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
369 #if !PLATFORM(IOS)
370     if (syntheticBoldOffset)
371 #else
372     if (syntheticBoldOffset && !platformData.m_isEmoji)
373 #endif
374         showGlyphsWithAdvances(FloatPoint(point.x() + syntheticBoldOffset, point.y()), font, cgContext, glyphBuffer.glyphs(from), static_cast<const CGSize*>(glyphBuffer.advances(from)), numGlyphs);
375
376     if (hasSimpleShadow)
377         context->setShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace);
378
379 #if !PLATFORM(IOS)
380     if (changeFontSmoothing)
381         CGContextSetShouldSmoothFonts(cgContext, originalShouldUseFontSmoothing);
382 #endif
383 }
384
385 #if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
386 struct GlyphIterationState {
387     GlyphIterationState(CGPoint startingPoint, CGPoint currentPoint, CGFloat y1, CGFloat y2, CGFloat minX, CGFloat maxX)
388         : startingPoint(startingPoint)
389         , currentPoint(currentPoint)
390         , y1(y1)
391         , y2(y2)
392         , minX(minX)
393         , maxX(maxX)
394     {
395     }
396     CGPoint startingPoint;
397     CGPoint currentPoint;
398     CGFloat y1;
399     CGFloat y2;
400     CGFloat minX;
401     CGFloat maxX;
402 };
403
404 static bool findIntersectionPoint(float y, CGPoint p1, CGPoint p2, CGFloat& x)
405 {
406     x = p1.x + (y - p1.y) * (p2.x - p1.x) / (p2.y - p1.y);
407     return (p1.y < y && p2.y > y) || (p1.y > y && p2.y < y);
408 }
409
410 static void updateX(GlyphIterationState& state, CGFloat x)
411 {
412     state.minX = std::min(state.minX, x);
413     state.maxX = std::max(state.maxX, x);
414 }
415
416 // This function is called by CGPathApply and is therefore invoked for each
417 // contour in a glyph. This function models each contours as a straight line
418 // and calculates the intersections between each pseudo-contour and
419 // two horizontal lines (the upper and lower bounds of an underline) found in
420 // GlyphIterationState::y1 and GlyphIterationState::y2. It keeps track of the
421 // leftmost and rightmost intersection in GlyphIterationState::minX and
422 // GlyphIterationState::maxX.
423 static void findPathIntersections(void* stateAsVoidPointer, const CGPathElement* e)
424 {
425     auto& state = *static_cast<GlyphIterationState*>(stateAsVoidPointer);
426     bool doIntersection = false;
427     CGPoint point = CGPointZero;
428     switch (e->type) {
429     case kCGPathElementMoveToPoint:
430         state.startingPoint = e->points[0];
431         state.currentPoint = e->points[0];
432         break;
433     case kCGPathElementAddLineToPoint:
434         doIntersection = true;
435         point = e->points[0];
436         break;
437     case kCGPathElementAddQuadCurveToPoint:
438         doIntersection = true;
439         point = e->points[1];
440         break;
441     case kCGPathElementAddCurveToPoint:
442         doIntersection = true;
443         point = e->points[2];
444         break;
445     case kCGPathElementCloseSubpath:
446         doIntersection = true;
447         point = state.startingPoint;
448         break;
449     }
450     if (!doIntersection)
451         return;
452     CGFloat x;
453     if (findIntersectionPoint(state.y1, state.currentPoint, point, x))
454         updateX(state, x);
455     if (findIntersectionPoint(state.y2, state.currentPoint, point, x))
456         updateX(state, x);
457     if ((state.currentPoint.y >= state.y1 && state.currentPoint.y <= state.y2)
458         || (state.currentPoint.y <= state.y1 && state.currentPoint.y >= state.y2))
459         updateX(state, state.currentPoint.x);
460     state.currentPoint = point;
461 }
462
463 class MacGlyphToPathTranslator final : public GlyphToPathTranslator {
464 public:
465     MacGlyphToPathTranslator(const TextRun& textRun, const GlyphBuffer& glyphBuffer, const FloatPoint& textOrigin)
466         : m_index(0)
467         , m_textRun(textRun)
468         , m_glyphBuffer(glyphBuffer)
469         , m_fontData(glyphBuffer.fontDataAt(m_index))
470         , m_translation(CGAffineTransformScale(CGAffineTransformMakeTranslation(textOrigin.x(), textOrigin.y()), 1, -1))
471     {
472         moveToNextValidGlyph();
473     }
474 private:
475     virtual bool containsMorePaths() override
476     {
477         return m_index != m_glyphBuffer.size();
478     }
479     virtual Path path() override;
480     virtual std::pair<float, float> extents() override;
481     virtual GlyphUnderlineType underlineType() override;
482     virtual void advance() override;
483     void moveToNextValidGlyph();
484
485     int m_index;
486     const TextRun& m_textRun;
487     const GlyphBuffer& m_glyphBuffer;
488     const SimpleFontData* m_fontData;
489     CGAffineTransform m_translation;
490 };
491
492 Path MacGlyphToPathTranslator::path()
493 {
494     RetainPtr<CGPathRef> result = adoptCF(CTFontCreatePathForGlyph(m_fontData->platformData().ctFont(), m_glyphBuffer.glyphAt(m_index), &m_translation));
495     return adoptCF(CGPathCreateMutableCopy(result.get()));
496 }
497
498 std::pair<float, float> MacGlyphToPathTranslator::extents()
499 {
500     CGPoint beginning = CGPointApplyAffineTransform(CGPointMake(0, 0), m_translation);
501     CGSize end = CGSizeApplyAffineTransform(m_glyphBuffer.advanceAt(m_index), m_translation);
502     return std::make_pair(static_cast<float>(beginning.x), static_cast<float>(beginning.x + end.width));
503 }
504
505 auto MacGlyphToPathTranslator::underlineType() -> GlyphUnderlineType
506 {
507     return computeUnderlineType(m_textRun, m_glyphBuffer, m_index);
508 }
509
510 void MacGlyphToPathTranslator::moveToNextValidGlyph()
511 {
512     if (!m_fontData->isSVGFont())
513         return;
514     advance();
515 }
516
517 void MacGlyphToPathTranslator::advance()
518 {
519     do {
520         GlyphBufferAdvance advance = m_glyphBuffer.advanceAt(m_index);
521         m_translation = CGAffineTransformTranslate(m_translation, advance.width(), advance.height());
522         ++m_index;
523         if (m_index >= m_glyphBuffer.size())
524             break;
525         m_fontData = m_glyphBuffer.fontDataAt(m_index);
526     } while (m_fontData->isSVGFont() && m_index < m_glyphBuffer.size());
527 }
528
529 DashArray Font::dashesForIntersectionsWithRect(const TextRun& run, const FloatPoint& textOrigin, const FloatRect& lineExtents) const
530 {
531     if (isLoadingCustomFonts())
532         return DashArray();
533
534     GlyphBuffer glyphBuffer;
535     glyphBuffer.saveOffsetsInString();
536     float deltaX;
537     if (codePath(run) != Font::Complex)
538         deltaX = getGlyphsAndAdvancesForSimpleText(run, 0, run.length(), glyphBuffer);
539     else
540         deltaX = getGlyphsAndAdvancesForComplexText(run, 0, run.length(), glyphBuffer);
541
542     if (!glyphBuffer.size())
543         return DashArray();
544     
545     // FIXME: Handle SVG + non-SVG interleaved runs. https://bugs.webkit.org/show_bug.cgi?id=133778
546     const SimpleFontData* fontData = glyphBuffer.fontDataAt(0);
547     std::unique_ptr<GlyphToPathTranslator> translator;
548     bool isSVG = false;
549     FloatPoint origin = FloatPoint(textOrigin.x() + deltaX, textOrigin.y());
550     if (!fontData->isSVGFont())
551         translator = std::make_unique<MacGlyphToPathTranslator>(run, glyphBuffer, origin);
552     else {
553         TextRun::RenderingContext* renderingContext = run.renderingContext();
554         if (!renderingContext)
555             return DashArray();
556         translator = renderingContext->createGlyphToPathTranslator(*fontData, &run, glyphBuffer, 0, glyphBuffer.size(), origin);
557         isSVG = true;
558     }
559     DashArray result;
560     for (int index = 0; translator->containsMorePaths(); ++index, translator->advance()) {
561         GlyphIterationState info = GlyphIterationState(CGPointMake(0, 0), CGPointMake(0, 0), lineExtents.y(), lineExtents.y() + lineExtents.height(), lineExtents.x() + lineExtents.width(), lineExtents.x());
562         const SimpleFontData* localFontData = glyphBuffer.fontDataAt(index);
563         if (!localFontData || (!isSVG && localFontData->isSVGFont()) || (isSVG && localFontData != fontData)) {
564             // The advances will get all messed up if we do anything other than bail here.
565             result.clear();
566             break;
567         }
568         switch (translator->underlineType()) {
569         case GlyphToPathTranslator::GlyphUnderlineType::SkipDescenders: {
570             Path path = translator->path();
571             CGPathApply(path.platformPath(), &info, &findPathIntersections);
572             if (info.minX < info.maxX) {
573                 result.append(info.minX - lineExtents.x());
574                 result.append(info.maxX - lineExtents.x());
575             }
576             break;
577         }
578         case GlyphToPathTranslator::GlyphUnderlineType::SkipGlyph: {
579             std::pair<float, float> extents = translator->extents();
580             result.append(extents.first - lineExtents.x());
581             result.append(extents.second - lineExtents.x());
582             break;
583         }
584         case GlyphToPathTranslator::GlyphUnderlineType::DrawOverGlyph:
585             // Nothing to do
586             break;
587         }
588     }
589     return result;
590 }
591 #endif
592
593 bool Font::primaryFontDataIsSystemFont() const
594 {
595 #if PLATFORM(IOS) || __MAC_OS_X_VERSION_MIN_REQUIRED > 1090
596     const auto& fontData = primaryFontData();
597     return !fontData.isSVGFont() && CTFontDescriptorIsSystemUIFont(adoptCF(CTFontCopyFontDescriptor(fontData.platformData().ctFont())).get());
598 #else
599     // System fonts are hidden by having a name that begins with a period, so simply search
600     // for that here rather than try to keep the list up to date.
601     return firstFamily().startsWith('.');
602 #endif
603 }
604
605 }