2c266d08059eb2ae6015f32129c20c0c2175d569
[WebKit-https.git] / Source / WebCore / platform / graphics / cocoa / FontCocoa.mm
1 /*
2  * Copyright (C) 2005, 2006, 2010, 2011 Apple Inc. All rights reserved.
3  * Copyright (C) 2006 Alexey Proskuryakov
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #import "config.h"
28 #import "Font.h"
29
30 #import "BlockExceptions.h"
31 #import "Color.h"
32 #import "CoreGraphicsSPI.h"
33 #import "CoreTextSPI.h"
34 #import "FloatRect.h"
35 #import "FontCache.h"
36 #import "FontCascade.h"
37 #import "FontDescription.h"
38 #import "SharedBuffer.h"
39 #import "WebCoreSystemInterface.h"
40 #import <float.h>
41 #import <unicode/uchar.h>
42 #import <wtf/Assertions.h>
43 #import <wtf/RetainPtr.h>
44 #import <wtf/StdLibExtras.h>
45
46 #if USE(APPKIT)
47 #import <AppKit/AppKit.h>
48 #import <ApplicationServices/ApplicationServices.h>
49 #else
50 #import "FontServicesIOS.h"
51 #import <CoreText/CoreText.h>
52 #endif
53
54 #if USE(APPKIT)
55 @interface NSFont (WebAppKitSecretAPI)
56 - (BOOL)_isFakeFixedPitch;
57 @end
58 #endif
59
60 namespace WebCore {
61
62 static bool fontHasVerticalGlyphs(CTFontRef ctFont)
63 {
64     // The check doesn't look neat but this is what AppKit does for vertical writing...
65     RetainPtr<CFArrayRef> tableTags = adoptCF(CTFontCopyAvailableTables(ctFont, kCTFontTableOptionNoOptions));
66     CFIndex numTables = CFArrayGetCount(tableTags.get());
67     for (CFIndex index = 0; index < numTables; ++index) {
68         CTFontTableTag tag = (CTFontTableTag)(uintptr_t)CFArrayGetValueAtIndex(tableTags.get(), index);
69         if (tag == kCTFontTableVhea || tag == kCTFontTableVORG)
70             return true;
71     }
72     return false;
73 }
74
75 #if USE(APPKIT)
76 static NSString *webFallbackFontFamily(void)
77 {
78     static NSString *webFallbackFontFamily = [[[NSFont systemFontOfSize:16.0f] familyName] retain];
79     return webFallbackFontFamily;
80 }
81 #else
82 static bool fontFamilyShouldNotBeUsedForArabic(CFStringRef fontFamilyName)
83 {
84     if (!fontFamilyName)
85         return false;
86
87     // Times New Roman contains Arabic glyphs, but Core Text doesn't know how to shape them. <rdar://problem/9823975>
88     // FIXME <rdar://problem/12096835> remove this function once the above bug is fixed.
89     // Arial and Tahoma are have performance issues so don't use them as well.
90     return (CFStringCompare(CFSTR("Times New Roman"), fontFamilyName, 0) == kCFCompareEqualTo)
91         || (CFStringCompare(CFSTR("Arial"), fontFamilyName, 0) == kCFCompareEqualTo)
92         || (CFStringCompare(CFSTR("Tahoma"), fontFamilyName, 0) == kCFCompareEqualTo);
93 }
94 #endif
95
96 void Font::platformInit()
97 {
98 #if USE(APPKIT)
99     m_syntheticBoldOffset = m_platformData.m_syntheticBold ? 1.0f : 0.f;
100
101     bool failedSetup = false;
102     if (!platformData().cgFont()) {
103         // Ack! Something very bad happened, like a corrupt font.
104         // Try looking for an alternate 'base' font for this renderer.
105
106         // Special case hack to use "Times New Roman" in place of "Times".
107         // "Times RO" is a common font whose family name is "Times".
108         // It overrides the normal "Times" family font.
109         // It also appears to have a corrupt regular variant.
110         NSString *fallbackFontFamily;
111         if ([[m_platformData.nsFont() familyName] isEqual:@"Times"])
112             fallbackFontFamily = @"Times New Roman";
113         else
114             fallbackFontFamily = webFallbackFontFamily();
115         
116         // Try setting up the alternate font.
117         // This is a last ditch effort to use a substitute font when something has gone wrong.
118 #if !ERROR_DISABLED
119         RetainPtr<NSFont> initialFont = m_platformData.nsFont();
120 #endif
121         if (m_platformData.font())
122             m_platformData.setNSFont([[NSFontManager sharedFontManager] convertFont:m_platformData.nsFont() toFamily:fallbackFontFamily]);
123         else
124             m_platformData.setNSFont([NSFont fontWithName:fallbackFontFamily size:m_platformData.size()]);
125         if (!platformData().cgFont()) {
126             if ([fallbackFontFamily isEqual:@"Times New Roman"]) {
127                 // OK, couldn't setup Times New Roman as an alternate to Times, fallback
128                 // on the system font.  If this fails we have no alternative left.
129                 m_platformData.setNSFont([[NSFontManager sharedFontManager] convertFont:m_platformData.nsFont() toFamily:webFallbackFontFamily()]);
130                 if (!platformData().cgFont()) {
131                     // We tried, Times, Times New Roman, and the system font. No joy. We have to give up.
132                     LOG_ERROR("unable to initialize with font %@", initialFont.get());
133                     failedSetup = true;
134                 }
135             } else {
136                 // We tried the requested font and the system font. No joy. We have to give up.
137                 LOG_ERROR("unable to initialize with font %@", initialFont.get());
138                 failedSetup = true;
139             }
140         }
141
142         // Report the problem.
143         LOG_ERROR("Corrupt font detected, using %@ in place of %@.",
144             [m_platformData.nsFont() familyName], [initialFont.get() familyName]);
145     }
146
147     // If all else fails, try to set up using the system font.
148     // This is probably because Times and Times New Roman are both unavailable.
149     if (failedSetup) {
150         m_platformData.setNSFont([NSFont systemFontOfSize:[m_platformData.nsFont() pointSize]]);
151         LOG_ERROR("failed to set up font, using system font %s", m_platformData.font());
152     }
153
154     // Work around <rdar://problem/19433490>
155     CGGlyph dummyGlyphs[] = {0, 0};
156     CGSize dummySize[] = { CGSizeMake(0, 0), CGSizeMake(0, 0) };
157     CTFontTransformGlyphs(m_platformData.ctFont(), dummyGlyphs, dummySize, 2, kCTFontTransformApplyPositioning | kCTFontTransformApplyShaping);
158     
159     int iAscent;
160     int iDescent;
161     int iCapHeight;
162     int iLineGap;
163     unsigned unitsPerEm;
164     iAscent = CGFontGetAscent(m_platformData.cgFont());
165     // Some fonts erroneously specify a positive descender value. We follow Core Text in assuming that
166     // such fonts meant the same distance, but in the reverse direction.
167     iDescent = -abs(CGFontGetDescent(m_platformData.cgFont()));
168     iCapHeight = CGFontGetCapHeight(m_platformData.cgFont());
169     iLineGap = CGFontGetLeading(m_platformData.cgFont());
170     unitsPerEm = CGFontGetUnitsPerEm(m_platformData.cgFont());
171
172     float pointSize = m_platformData.m_size;
173     float ascent = scaleEmToUnits(iAscent, unitsPerEm) * pointSize;
174     float descent = -scaleEmToUnits(iDescent, unitsPerEm) * pointSize;
175     float capHeight = scaleEmToUnits(iCapHeight, unitsPerEm) * pointSize;
176     
177     float lineGap = scaleEmToUnits(iLineGap, unitsPerEm) * pointSize;
178
179     // We need to adjust Times, Helvetica, and Courier to closely match the
180     // vertical metrics of their Microsoft counterparts that are the de facto
181     // web standard. The AppKit adjustment of 20% is too big and is
182     // incorrectly added to line spacing, so we use a 15% adjustment instead
183     // and add it to the ascent.
184     NSString *familyName = [m_platformData.nsFont() familyName];
185     if ([familyName isEqualToString:@"Times"] || [familyName isEqualToString:@"Helvetica"] || [familyName isEqualToString:@"Courier"])
186         ascent += floorf(((ascent + descent) * 0.15f) + 0.5f);
187
188     // Compute and store line spacing, before the line metrics hacks are applied.
189     m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
190
191     // Hack Hiragino line metrics to allow room for marked text underlines.
192     // <rdar://problem/5386183>
193     if (descent < 3 && lineGap >= 3 && [familyName hasPrefix:@"Hiragino"]) {
194         lineGap -= 3 - descent;
195         descent = 3;
196     }
197     
198     if (platformData().orientation() == Vertical && !isTextOrientationFallback())
199         m_hasVerticalGlyphs = fontHasVerticalGlyphs(m_platformData.ctFont());
200
201     float xHeight;
202
203     if (platformData().orientation() == Horizontal) {
204         // Measure the actual character "x", since it's possible for it to extend below the baseline, and we need the
205         // reported x-height to only include the portion of the glyph that is above the baseline.
206         NSGlyph xGlyph = glyphForCharacter('x');
207         if (xGlyph)
208             xHeight = -CGRectGetMinY(platformBoundsForGlyph(xGlyph));
209         else
210             xHeight = scaleEmToUnits(CGFontGetXHeight(m_platformData.cgFont()), unitsPerEm) * pointSize;
211     } else
212         xHeight = verticalRightOrientationFont()->fontMetrics().xHeight();
213
214     m_fontMetrics.setUnitsPerEm(unitsPerEm);
215     m_fontMetrics.setAscent(ascent);
216     m_fontMetrics.setDescent(descent);
217     m_fontMetrics.setCapHeight(capHeight);
218     m_fontMetrics.setLineGap(lineGap);
219     m_fontMetrics.setXHeight(xHeight);
220 #else
221     m_syntheticBoldOffset = m_platformData.m_syntheticBold ? ceilf(m_platformData.size()  / 24.0f) : 0.f;
222     m_spaceGlyph = 0;
223     m_spaceWidth = 0;
224     unsigned unitsPerEm;
225     float ascent;
226     float descent;
227     float capHeight;
228     float lineGap;
229     float lineSpacing;
230     float xHeight;
231     RetainPtr<CFStringRef> familyName;
232     if (CTFontRef ctFont = m_platformData.font()) {
233         FontServicesIOS fontService(ctFont);
234         ascent = ceilf(fontService.ascent());
235         descent = ceilf(fontService.descent());
236         lineSpacing = fontService.lineSpacing();
237         lineGap = fontService.lineGap();
238         xHeight = fontService.xHeight();
239         capHeight = fontService.capHeight();
240         unitsPerEm = fontService.unitsPerEm();
241         familyName = adoptCF(CTFontCopyFamilyName(ctFont));
242     } else {
243         CGFontRef cgFont = m_platformData.cgFont();
244
245         unitsPerEm = CGFontGetUnitsPerEm(cgFont);
246
247         float pointSize = m_platformData.size();
248         ascent = lroundf(scaleEmToUnits(CGFontGetAscent(cgFont), unitsPerEm) * pointSize);
249         descent = lroundf(-scaleEmToUnits(-abs(CGFontGetDescent(cgFont)), unitsPerEm) * pointSize);
250         lineGap = lroundf(scaleEmToUnits(CGFontGetLeading(cgFont), unitsPerEm) * pointSize);
251         xHeight = scaleEmToUnits(CGFontGetXHeight(cgFont), unitsPerEm) * pointSize;
252         capHeight = scaleEmToUnits(CGFontGetCapHeight(cgFont), unitsPerEm) * pointSize;
253
254         lineSpacing = ascent + descent + lineGap;
255         familyName = adoptCF(CGFontCopyFamilyName(cgFont));
256     }
257
258     m_fontMetrics.setUnitsPerEm(unitsPerEm);
259     m_fontMetrics.setAscent(ascent);
260     m_fontMetrics.setDescent(descent);
261     m_fontMetrics.setLineGap(lineGap);
262     m_fontMetrics.setLineSpacing(lineSpacing);
263     m_fontMetrics.setXHeight(xHeight);
264     m_fontMetrics.setCapHeight(capHeight);
265     m_shouldNotBeUsedForArabic = fontFamilyShouldNotBeUsedForArabic(familyName.get());
266
267     if (platformData().orientation() == Vertical && !isTextOrientationFallback())
268         m_hasVerticalGlyphs = fontHasVerticalGlyphs(m_platformData.ctFont());
269
270     if (m_platformData.m_isEmoji) {
271         int thirdOfSize = m_platformData.size() / 3;
272         m_fontMetrics.setAscent(thirdOfSize);
273         m_fontMetrics.setDescent(thirdOfSize);
274         m_fontMetrics.setLineGap(thirdOfSize);
275         m_fontMetrics.setLineSpacing(0);
276     }
277 #endif
278
279     m_isSystemFont = CTFontDescriptorIsSystemUIFont(adoptCF(CTFontCopyFontDescriptor(m_platformData.font())).get());
280 }
281
282 void Font::platformCharWidthInit()
283 {
284     m_avgCharWidth = 0;
285     m_maxCharWidth = 0;
286     
287 #if PLATFORM(MAC)
288     RetainPtr<CFDataRef> os2Table = adoptCF(CGFontCopyTableForTag(m_platformData.cgFont(), 'OS/2'));
289     if (os2Table && CFDataGetLength(os2Table.get()) >= 4) {
290         const UInt8* os2 = CFDataGetBytePtr(os2Table.get());
291         SInt16 os2AvgCharWidth = os2[2] * 256 + os2[3];
292         m_avgCharWidth = scaleEmToUnits(os2AvgCharWidth, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
293     }
294
295     RetainPtr<CFDataRef> headTable = adoptCF(CGFontCopyTableForTag(m_platformData.cgFont(), 'head'));
296     if (headTable && CFDataGetLength(headTable.get()) >= 42) {
297         const UInt8* head = CFDataGetBytePtr(headTable.get());
298         ushort uxMin = head[36] * 256 + head[37];
299         ushort uxMax = head[40] * 256 + head[41];
300         SInt16 xMin = static_cast<SInt16>(uxMin);
301         SInt16 xMax = static_cast<SInt16>(uxMax);
302         float diff = static_cast<float>(xMax - xMin);
303         m_maxCharWidth = scaleEmToUnits(diff, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
304     }
305 #endif
306
307     // Fallback to a cross-platform estimate, which will populate these values if they are non-positive.
308     initCharWidths();
309 }
310
311 void Font::platformDestroy()
312 {
313 }
314
315 PassRefPtr<Font> Font::platformCreateScaledFont(const FontDescription&, float scaleFactor) const
316 {
317     if (isCustomFont()) {
318         FontPlatformData scaledFontData(m_platformData);
319         scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
320         return Font::create(scaledFontData, true, false);
321     }
322
323     float size = m_platformData.size() * scaleFactor;
324
325 #if USE(APPKIT)
326     BEGIN_BLOCK_OBJC_EXCEPTIONS;
327
328     FontPlatformData scaledFontData([[NSFontManager sharedFontManager] convertFont:m_platformData.nsFont() toSize:size], size, false, false, m_platformData.orientation());
329
330     if (scaledFontData.font()) {
331         NSFontManager *fontManager = [NSFontManager sharedFontManager];
332         NSFontTraitMask fontTraits = [fontManager traitsOfFont:m_platformData.nsFont()];
333
334         if (m_platformData.m_syntheticBold)
335             fontTraits |= NSBoldFontMask;
336         if (m_platformData.m_syntheticOblique)
337             fontTraits |= NSItalicFontMask;
338
339         NSFontTraitMask scaledFontTraits = [fontManager traitsOfFont:scaledFontData.nsFont()];
340         scaledFontData.m_syntheticBold = (fontTraits & NSBoldFontMask) && !(scaledFontTraits & NSBoldFontMask);
341         scaledFontData.m_syntheticOblique = (fontTraits & NSItalicFontMask) && !(scaledFontTraits & NSItalicFontMask);
342
343         return Font::create(scaledFontData);
344     }
345     END_BLOCK_OBJC_EXCEPTIONS;
346
347     return nullptr;
348 #else
349     CTFontSymbolicTraits fontTraits = CTFontGetSymbolicTraits(m_platformData.font());
350     RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontCopyFontDescriptor(m_platformData.font()));
351     RetainPtr<CTFontRef> scaledFont = adoptCF(CTFontCreateWithFontDescriptor(fontDescriptor.get(), size, nullptr));
352     FontPlatformData scaledFontData(scaledFont.get(), size, false, false, m_platformData.orientation());
353
354     if (scaledFontData.font()) {
355         if (m_platformData.m_syntheticBold)
356             fontTraits |= kCTFontBoldTrait;
357         if (m_platformData.m_syntheticOblique)
358             fontTraits |= kCTFontItalicTrait;
359
360         CTFontSymbolicTraits scaledFontTraits = CTFontGetSymbolicTraits(scaledFontData.font());
361         scaledFontData.m_syntheticBold = (fontTraits & kCTFontBoldTrait) && !(scaledFontTraits & kCTFontTraitBold);
362         scaledFontData.m_syntheticOblique = (fontTraits & kCTFontItalicTrait) && !(scaledFontTraits & kCTFontTraitItalic);
363
364         return Font::create(scaledFontData);
365     }
366
367     return nullptr;
368 #endif
369 }
370
371 void Font::determinePitch()
372 {
373 #if USE(APPKIT)
374     NSFont* f = m_platformData.nsFont();
375     // Special case Osaka-Mono.
376     // According to <rdar://problem/3999467>, we should treat Osaka-Mono as fixed pitch.
377     // Note that the AppKit does not report Osaka-Mono as fixed pitch.
378
379     // Special case MS-PGothic.
380     // According to <rdar://problem/4032938>, we should not treat MS-PGothic as fixed pitch.
381     // Note that AppKit does report MS-PGothic as fixed pitch.
382
383     // Special case MonotypeCorsiva
384     // According to <rdar://problem/5454704>, we should not treat MonotypeCorsiva as fixed pitch.
385     // Note that AppKit does report MonotypeCorsiva as fixed pitch.
386
387     NSString *name = [f fontName];
388     m_treatAsFixedPitch = ([f isFixedPitch]  || [f _isFakeFixedPitch] || [name caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame) && [name caseInsensitiveCompare:@"MS-PGothic"] != NSOrderedSame && [name caseInsensitiveCompare:@"MonotypeCorsiva"] != NSOrderedSame;
389 #else
390     CTFontRef ctFont = m_platformData.font();
391     m_treatAsFixedPitch = false;
392     if (!ctFont)
393         return; // CTFont is null in the case of SVG fonts for example.
394
395     RetainPtr<CFStringRef> fullName = adoptCF(CTFontCopyFullName(ctFont));
396     RetainPtr<CFStringRef> familyName = adoptCF(CTFontCopyFamilyName(ctFont));
397
398     m_treatAsFixedPitch = CGFontIsFixedPitch(m_platformData.cgFont()) || (fullName && (CFStringCompare(fullName.get(), CFSTR("Osaka-Mono"), kCFCompareCaseInsensitive) == kCFCompareEqualTo || CFStringCompare(fullName.get(), CFSTR("MS-PGothic"), kCFCompareCaseInsensitive) == kCFCompareEqualTo));
399     if (familyName && CFStringCompare(familyName.get(), CFSTR("Courier New"), kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
400         // Special case Courier New to not be treated as fixed pitch, as this will make use of a hacked space width which is undesireable for iPhone (see rdar://6269783).
401         m_treatAsFixedPitch = false;
402     }
403 #endif
404 }
405
406 FloatRect Font::platformBoundsForGlyph(Glyph glyph) const
407 {
408     FloatRect boundingBox;
409     boundingBox = CTFontGetBoundingRectsForGlyphs(m_platformData.ctFont(), platformData().orientation() == Vertical ? kCTFontOrientationVertical : kCTFontOrientationHorizontal, &glyph, 0, 1);
410     boundingBox.setY(-boundingBox.maxY());
411     if (m_syntheticBoldOffset)
412         boundingBox.setWidth(boundingBox.width() + m_syntheticBoldOffset);
413
414     return boundingBox;
415 }
416
417 static inline CGFontRenderingStyle renderingStyle(const FontPlatformData& platformData)
418 {
419 #if USE(APPKIT)
420     CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization;
421     NSFont *font = platformData.nsFont();
422     if (font) {
423         switch ([font renderingMode]) {
424         case NSFontIntegerAdvancementsRenderingMode:
425             style = 0;
426             break;
427         case NSFontAntialiasedIntegerAdvancementsRenderingMode:
428             style = kCGFontRenderingStyleAntialiasing;
429             break;
430         default:
431             break;
432         }
433     }
434     return style;
435
436 #else
437     UNUSED_PARAM(platformData);
438     return kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization | kCGFontAntialiasingStyleUnfiltered;
439 #endif
440 }
441
442 static inline bool advanceForColorBitmapFont(const FontPlatformData& platformData, Glyph glyph, CGSize& advance)
443 {
444 #if PLATFORM(MAC)
445     NSFont *font = platformData.nsFont();
446     if (!font || !platformData.isColorBitmapFont())
447         return false;
448     advance = NSSizeToCGSize([font advancementForGlyph:glyph]);
449     return true;
450 #else
451     UNUSED_PARAM(platformData);
452     UNUSED_PARAM(glyph);
453     UNUSED_PARAM(advance);
454     return false;
455 #endif
456 }
457
458 static inline bool hasCustomTracking(const Font& font)
459 {
460     return font.isSystemFont();
461 }
462
463 static inline bool isEmoji(const FontPlatformData& platformData)
464 {
465 #if PLATFORM(IOS)
466     return platformData.m_isEmoji;
467 #else
468     UNUSED_PARAM(platformData);
469     return false;
470 #endif
471 }
472
473 static inline bool canUseFastGlyphAdvanceGetter(const Font& font, Glyph glyph, CGSize& advance, bool& populatedAdvance)
474 {
475     const FontPlatformData& platformData = font.platformData();
476     // Fast getter doesn't take custom tracking into account
477     if (hasCustomTracking(font))
478         return false;
479     // Fast getter doesn't work for emoji
480     if (isEmoji(platformData))
481         return false;
482     // ... or for any bitmap fonts in general
483     if (advanceForColorBitmapFont(platformData, glyph, advance)) {
484         populatedAdvance = true;
485         return false;
486     }
487     return true;
488 }
489
490 float Font::platformWidthForGlyph(Glyph glyph) const
491 {
492     CGSize advance = CGSizeZero;
493     bool horizontal = platformData().orientation() == Horizontal;
494     bool populatedAdvance = false;
495     if ((horizontal || m_isBrokenIdeographFallback) && canUseFastGlyphAdvanceGetter(*this, glyph, advance, populatedAdvance)) {
496         float pointSize = platformData().m_size;
497         CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
498         if (!CGFontGetGlyphAdvancesForStyle(platformData().cgFont(), &m, renderingStyle(platformData()), &glyph, 1, &advance)) {
499             RetainPtr<CFStringRef> fullName = adoptCF(CGFontCopyFullName(platformData().cgFont()));
500             LOG_ERROR("Unable to cache glyph widths for %@ %f", fullName.get(), pointSize);
501             advance.width = 0;
502         }
503     } else if (!populatedAdvance) {
504         // m_platformData.font() returns the original font that was passed into the FontPlatformData constructor.\10 In the case of fonts that have custom tracking,
505         // the custom tracking does not survive the transformation to either m_platformData.cgFont() nor m_platformData.ctFont(), so we must use the original
506         // font() that was passed in. However, for web fonts, m_platformData.font() is null, so we must use m_platformData.ctFont() for those cases.
507         if (hasCustomTracking(*this))
508             CTFontGetAdvancesForGlyphs(m_platformData.font(), horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical, &glyph, &advance, 1);
509         else
510             CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical, &glyph, &advance, 1);
511     }
512
513     return advance.width + m_syntheticBoldOffset;
514 }
515
516 struct ProviderInfo {
517     const UChar* characters;
518     size_t length;
519     CFDictionaryRef attributes;
520 };
521
522 static const UniChar* provideStringAndAttributes(CFIndex stringIndex, CFIndex* count, CFDictionaryRef* attributes, void* context)
523 {
524     ProviderInfo* info = static_cast<struct ProviderInfo*>(context);
525     if (stringIndex < 0 || static_cast<size_t>(stringIndex) >= info->length)
526         return 0;
527
528     *count = info->length - stringIndex;
529     *attributes = info->attributes;
530     return info->characters + stringIndex;
531 }
532
533 bool Font::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
534 {
535     ASSERT(isMainThread());
536
537     if (!m_combiningCharacterSequenceSupport)
538         m_combiningCharacterSequenceSupport = std::make_unique<HashMap<String, bool>>();
539
540     WTF::HashMap<String, bool>::AddResult addResult = m_combiningCharacterSequenceSupport->add(String(characters, length), false);
541     if (!addResult.isNewEntry)
542         return addResult.iterator->value;
543
544     RetainPtr<CFTypeRef> fontEqualityObject = platformData().objectForEqualityCheck();
545
546     ProviderInfo info = { characters, length, getCFStringAttributes(0, platformData().orientation()) };
547     RetainPtr<CTLineRef> line = adoptCF(CTLineCreateWithUniCharProvider(&provideStringAndAttributes, 0, &info));
548
549     CFArrayRef runArray = CTLineGetGlyphRuns(line.get());
550     CFIndex runCount = CFArrayGetCount(runArray);
551
552     for (CFIndex r = 0; r < runCount; r++) {
553         CTRunRef ctRun = static_cast<CTRunRef>(CFArrayGetValueAtIndex(runArray, r));
554         ASSERT(CFGetTypeID(ctRun) == CTRunGetTypeID());
555         CFDictionaryRef runAttributes = CTRunGetAttributes(ctRun);
556         CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttributes, kCTFontAttributeName));
557         if (!CFEqual(fontEqualityObject.get(), FontPlatformData::objectForEqualityCheck(runFont).get()))
558             return false;
559     }
560
561     addResult.iterator->value = true;
562     return true;
563 }
564
565 #if USE(APPKIT)
566 const Font* Font::compositeFontReferenceFont(NSFont *key) const
567 {
568     if (!key || CFEqual(adoptCF(CTFontCopyPostScriptName(CTFontRef(key))).get(), CFSTR("LastResort")))
569         return nullptr;
570
571     if (!m_derivedFontData)
572         m_derivedFontData = std::make_unique<DerivedFontData>(isCustomFont());
573
574     auto addResult = m_derivedFontData->compositeFontReferences.add(key, nullptr);
575     if (addResult.isNewEntry) {
576         NSFont *substituteFont = [key printerFont];
577
578         CTFontSymbolicTraits traits = CTFontGetSymbolicTraits((CTFontRef)substituteFont);
579         bool syntheticBold = platformData().syntheticBold() && !(traits & kCTFontBoldTrait);
580         bool syntheticOblique = platformData().syntheticOblique() && !(traits & kCTFontItalicTrait);
581
582         FontPlatformData substitutePlatform(substituteFont, platformData().size(), syntheticBold, syntheticOblique, platformData().orientation(), platformData().widthVariant());
583         addResult.iterator->value = Font::create(substitutePlatform, isCustomFont());
584     }
585     return addResult.iterator->value.get();
586 }
587 #endif
588
589 } // namespace WebCore