[Mac] Add support for the USE_TYPO_METRICS flag
[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 #if USE(APPKIT)
61 #include "OpenTypeTypes.h"
62 #endif
63
64 namespace WebCore {
65
66 static bool fontHasVerticalGlyphs(CTFontRef ctFont)
67 {
68     // The check doesn't look neat but this is what AppKit does for vertical writing...
69     RetainPtr<CFArrayRef> tableTags = adoptCF(CTFontCopyAvailableTables(ctFont, kCTFontTableOptionNoOptions));
70     CFIndex numTables = CFArrayGetCount(tableTags.get());
71     for (CFIndex index = 0; index < numTables; ++index) {
72         CTFontTableTag tag = (CTFontTableTag)(uintptr_t)CFArrayGetValueAtIndex(tableTags.get(), index);
73         if (tag == kCTFontTableVhea || tag == kCTFontTableVORG)
74             return true;
75     }
76     return false;
77 }
78
79 #if USE(APPKIT)
80 static bool fontHasMathTable(CTFontRef ctFont)
81 {
82     RetainPtr<CFArrayRef> tableTags = adoptCF(CTFontCopyAvailableTables(ctFont, kCTFontTableOptionNoOptions));
83     CFIndex numTables = CFArrayGetCount(tableTags.get());
84     for (CFIndex index = 0; index < numTables; ++index) {
85         CTFontTableTag tag = (CTFontTableTag)(uintptr_t)CFArrayGetValueAtIndex(tableTags.get(), index);
86         if (tag == 'MATH')
87             return true;
88     }
89     return false;
90 }
91
92 static NSString *webFallbackFontFamily(void)
93 {
94     static NSString *webFallbackFontFamily = [[[NSFont systemFontOfSize:16.0f] familyName] retain];
95     return webFallbackFontFamily;
96 }
97 #else
98 bool fontFamilyShouldNotBeUsedForArabic(CFStringRef fontFamilyName)
99 {
100     if (!fontFamilyName)
101         return false;
102
103     // Times New Roman and Arial are not performant enough to use. <rdar://problem/21333326>
104     // FIXME <rdar://problem/12096835> remove this function once the above bug is fixed.
105     return (CFStringCompare(CFSTR("Times New Roman"), fontFamilyName, 0) == kCFCompareEqualTo)
106         || (CFStringCompare(CFSTR("Arial"), fontFamilyName, 0) == kCFCompareEqualTo);
107 }
108 #endif
109
110 void Font::platformInit()
111 {
112     // FIXME: Unify these two codepaths
113 #if USE(APPKIT)
114     m_syntheticBoldOffset = m_platformData.m_syntheticBold ? 1.0f : 0.f;
115
116     bool failedSetup = false;
117     if (!platformData().cgFont()) {
118         // Ack! Something very bad happened, like a corrupt font.
119         // Try looking for an alternate 'base' font for this renderer.
120
121         // Special case hack to use "Times New Roman" in place of "Times".
122         // "Times RO" is a common font whose family name is "Times".
123         // It overrides the normal "Times" family font.
124         // It also appears to have a corrupt regular variant.
125         NSString *fallbackFontFamily;
126         if ([[m_platformData.nsFont() familyName] isEqual:@"Times"])
127             fallbackFontFamily = @"Times New Roman";
128         else
129             fallbackFontFamily = webFallbackFontFamily();
130         
131         // Try setting up the alternate font.
132         // This is a last ditch effort to use a substitute font when something has gone wrong.
133 #if !ERROR_DISABLED
134         RetainPtr<NSFont> initialFont = m_platformData.nsFont();
135 #endif
136         if (m_platformData.font())
137             m_platformData.setNSFont([[NSFontManager sharedFontManager] convertFont:m_platformData.nsFont() toFamily:fallbackFontFamily]);
138         else
139             m_platformData.setNSFont([NSFont fontWithName:fallbackFontFamily size:m_platformData.size()]);
140         if (!platformData().cgFont()) {
141             if ([fallbackFontFamily isEqual:@"Times New Roman"]) {
142                 // OK, couldn't setup Times New Roman as an alternate to Times, fallback
143                 // on the system font.  If this fails we have no alternative left.
144                 m_platformData.setNSFont([[NSFontManager sharedFontManager] convertFont:m_platformData.nsFont() toFamily:webFallbackFontFamily()]);
145                 if (!platformData().cgFont()) {
146                     // We tried, Times, Times New Roman, and the system font. No joy. We have to give up.
147                     LOG_ERROR("unable to initialize with font %@", initialFont.get());
148                     failedSetup = true;
149                 }
150             } else {
151                 // We tried the requested font and the system font. No joy. We have to give up.
152                 LOG_ERROR("unable to initialize with font %@", initialFont.get());
153                 failedSetup = true;
154             }
155         }
156
157         // Report the problem.
158         LOG_ERROR("Corrupt font detected, using %@ in place of %@.",
159             [m_platformData.nsFont() familyName], [initialFont.get() familyName]);
160     }
161
162     // If all else fails, try to set up using the system font.
163     // This is probably because Times and Times New Roman are both unavailable.
164     if (failedSetup) {
165         m_platformData.setNSFont([NSFont systemFontOfSize:[m_platformData.nsFont() pointSize]]);
166         LOG_ERROR("failed to set up font, using system font %s", m_platformData.font());
167     }
168
169     m_isSystemFont = CTFontDescriptorIsSystemUIFont(adoptCF(CTFontCopyFontDescriptor(m_platformData.font())).get());
170
171 #if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100
172     // Work around <rdar://problem/19433490>
173     CGGlyph dummyGlyphs[] = {0, 0};
174     CGSize dummySize[] = { CGSizeMake(0, 0), CGSizeMake(0, 0) };
175     CTFontTransformGlyphs(m_platformData.ctFont(), dummyGlyphs, dummySize, 2, kCTFontTransformApplyPositioning | kCTFontTransformApplyShaping);
176 #endif
177
178     unsigned unitsPerEm = CGFontGetUnitsPerEm(m_platformData.cgFont());
179
180     // Some fonts erroneously specify a positive descender value. We follow Core Text in assuming that
181     // such fonts meant the same distance, but in the reverse direction.
182     float pointSize = m_platformData.m_size;
183     float ascent = scaleEmToUnits(CGFontGetAscent(m_platformData.cgFont()), unitsPerEm) * pointSize;
184     float descent = -scaleEmToUnits(-abs(CGFontGetDescent(m_platformData.cgFont())), unitsPerEm) * pointSize;
185     float capHeight = scaleEmToUnits(CGFontGetCapHeight(m_platformData.cgFont()), unitsPerEm) * pointSize;
186     
187     float lineGap = scaleEmToUnits(CGFontGetLeading(m_platformData.cgFont()), unitsPerEm) * pointSize;
188
189     // The Open Font Format describes the OS/2 USE_TYPO_METRICS flag as follows:
190     // "If set, it is strongly recommended to use OS/2.sTypoAscender - OS/2.sTypoDescender+ OS/2.sTypoLineGap as a value for default line spacing for this font."
191     // We only apply this rule in the important case of fonts with a MATH table.
192     if (fontHasMathTable(m_platformData.ctFont())) {
193         if (CFDataRef os2Table = CGFontCopyTableForTag(m_platformData.cgFont(), kCTFontTableOS2)) {
194             // For the structure of the OS/2 table, see
195             // https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6OS2.html
196             const CFIndex fsSelectionOffset = 16 * 2 + 10 + 4 * 4 + 4 * 1;
197             const CFIndex sTypoAscenderOffset = fsSelectionOffset + 3 * 2;
198             const CFIndex sTypoDescenderOffset = sTypoAscenderOffset + 2;
199             const CFIndex sTypoLineGapOffset = sTypoDescenderOffset + 2;
200             if (CFDataGetLength(os2Table) >= sTypoLineGapOffset + 2) {
201                 const UInt8* os2Data = CFDataGetBytePtr(os2Table);
202                 const unsigned short useTypoMetricsMask = 1 << 7;
203                 if (*(reinterpret_cast<const OpenType::UInt16*>(os2Data + fsSelectionOffset)) & useTypoMetricsMask) {
204                     ascent = scaleEmToUnits(*(reinterpret_cast<const OpenType::Int16*>(os2Data + sTypoAscenderOffset)), unitsPerEm) * pointSize;
205                     descent = -scaleEmToUnits(*(reinterpret_cast<const OpenType::Int16*>(os2Data + sTypoDescenderOffset)), unitsPerEm) * pointSize;
206                     lineGap = scaleEmToUnits(*(reinterpret_cast<const OpenType::Int16*>(os2Data + sTypoLineGapOffset)), unitsPerEm) * pointSize;
207                 }
208             }
209             CFRelease(os2Table);
210         }
211     }
212
213     // We need to adjust Times, Helvetica, and Courier to closely match the
214     // vertical metrics of their Microsoft counterparts that are the de facto
215     // web standard. The AppKit adjustment of 20% is too big and is
216     // incorrectly added to line spacing, so we use a 15% adjustment instead
217     // and add it to the ascent.
218     RetainPtr<CFStringRef> familyName = adoptCF(CTFontCopyFamilyName(m_platformData.font()));
219     if (familyName && (CFStringCompare(familyName.get(), CFSTR("Times"), kCFCompareCaseInsensitive) == kCFCompareEqualTo
220         || CFStringCompare(familyName.get(), CFSTR("Helvetica"), kCFCompareCaseInsensitive) == kCFCompareEqualTo
221         || CFStringCompare(familyName.get(), CFSTR("Courier"), kCFCompareCaseInsensitive) == kCFCompareEqualTo))
222         ascent += floorf(((ascent + descent) * 0.15f) + 0.5f);
223
224     // Compute and store line spacing, before the line metrics hacks are applied.
225     m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
226
227     // Hack Hiragino line metrics to allow room for marked text underlines.
228     // <rdar://problem/5386183>
229     if (descent < 3 && lineGap >= 3 && familyName && CFStringHasPrefix(familyName.get(), CFSTR("Hiragino"))) {
230         lineGap -= 3 - descent;
231         descent = 3;
232     }
233     
234     if (platformData().orientation() == Vertical && !isTextOrientationFallback())
235         m_hasVerticalGlyphs = fontHasVerticalGlyphs(m_platformData.ctFont());
236
237     float xHeight;
238
239     if (platformData().orientation() == Horizontal) {
240         // Measure the actual character "x", since it's possible for it to extend below the baseline, and we need the
241         // reported x-height to only include the portion of the glyph that is above the baseline.
242         NSGlyph xGlyph = glyphForCharacter('x');
243         if (xGlyph)
244             xHeight = -CGRectGetMinY(platformBoundsForGlyph(xGlyph));
245         else
246             xHeight = scaleEmToUnits(CGFontGetXHeight(m_platformData.cgFont()), unitsPerEm) * pointSize;
247     } else
248         xHeight = verticalRightOrientationFont()->fontMetrics().xHeight();
249
250     m_fontMetrics.setUnitsPerEm(unitsPerEm);
251     m_fontMetrics.setAscent(ascent);
252     m_fontMetrics.setDescent(descent);
253     m_fontMetrics.setCapHeight(capHeight);
254     m_fontMetrics.setLineGap(lineGap);
255     m_fontMetrics.setXHeight(xHeight);
256
257 #else
258
259     m_isSystemFont = CTFontDescriptorIsSystemUIFont(adoptCF(CTFontCopyFontDescriptor(m_platformData.font())).get());
260     m_syntheticBoldOffset = m_platformData.m_syntheticBold ? ceilf(m_platformData.size()  / 24.0f) : 0.f;
261
262     CTFontRef ctFont = m_platformData.font();
263     FontServicesIOS fontService(ctFont);
264     m_fontMetrics.setUnitsPerEm(fontService.unitsPerEm());
265     m_fontMetrics.setAscent(ceilf(fontService.ascent()));
266     m_fontMetrics.setDescent(ceilf(fontService.descent()));
267     m_fontMetrics.setLineGap(fontService.lineGap());
268     m_fontMetrics.setLineSpacing(fontService.lineSpacing());
269     m_fontMetrics.setXHeight(fontService.xHeight());
270     m_fontMetrics.setCapHeight(fontService.capHeight());
271     m_shouldNotBeUsedForArabic = fontFamilyShouldNotBeUsedForArabic(adoptCF(CTFontCopyFamilyName(ctFont)).get());
272
273     if (platformData().orientation() == Vertical && !isTextOrientationFallback())
274         m_hasVerticalGlyphs = fontHasVerticalGlyphs(m_platformData.ctFont());
275 #endif
276 }
277
278 void Font::platformCharWidthInit()
279 {
280     m_avgCharWidth = 0;
281     m_maxCharWidth = 0;
282     
283 #if PLATFORM(MAC)
284     RetainPtr<CFDataRef> os2Table = adoptCF(CGFontCopyTableForTag(m_platformData.cgFont(), 'OS/2'));
285     if (os2Table && CFDataGetLength(os2Table.get()) >= 4) {
286         const UInt8* os2 = CFDataGetBytePtr(os2Table.get());
287         SInt16 os2AvgCharWidth = os2[2] * 256 + os2[3];
288         m_avgCharWidth = scaleEmToUnits(os2AvgCharWidth, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
289     }
290
291     RetainPtr<CFDataRef> headTable = adoptCF(CGFontCopyTableForTag(m_platformData.cgFont(), 'head'));
292     if (headTable && CFDataGetLength(headTable.get()) >= 42) {
293         const UInt8* head = CFDataGetBytePtr(headTable.get());
294         ushort uxMin = head[36] * 256 + head[37];
295         ushort uxMax = head[40] * 256 + head[41];
296         SInt16 xMin = static_cast<SInt16>(uxMin);
297         SInt16 xMax = static_cast<SInt16>(uxMax);
298         float diff = static_cast<float>(xMax - xMin);
299         m_maxCharWidth = scaleEmToUnits(diff, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
300     }
301 #endif
302
303     // Fallback to a cross-platform estimate, which will populate these values if they are non-positive.
304     initCharWidths();
305 }
306
307 void Font::platformDestroy()
308 {
309 }
310
311 PassRefPtr<Font> Font::platformCreateScaledFont(const FontDescription&, float scaleFactor) const
312 {
313 #if !CORETEXT_WEB_FONTS
314     if (isCustomFont()) {
315         FontPlatformData scaledFontData(m_platformData);
316         scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
317         return Font::create(scaledFontData, true, false);
318     }
319 #endif
320
321     float size = m_platformData.size() * scaleFactor;
322
323 #if USE(APPKIT)
324     BEGIN_BLOCK_OBJC_EXCEPTIONS;
325
326     FontPlatformData scaledFontData(toCTFont([[NSFontManager sharedFontManager] convertFont:m_platformData.nsFont() toSize:size]), size, false, false, m_platformData.orientation());
327
328     if (scaledFontData.font()) {
329         NSFontManager *fontManager = [NSFontManager sharedFontManager];
330         NSFontTraitMask fontTraits = [fontManager traitsOfFont:m_platformData.nsFont()];
331
332         if (m_platformData.m_syntheticBold)
333             fontTraits |= NSBoldFontMask;
334         if (m_platformData.m_syntheticOblique)
335             fontTraits |= NSItalicFontMask;
336
337         NSFontTraitMask scaledFontTraits = [fontManager traitsOfFont:scaledFontData.nsFont()];
338         scaledFontData.m_syntheticBold = (fontTraits & NSBoldFontMask) && !(scaledFontTraits & NSBoldFontMask);
339         scaledFontData.m_syntheticOblique = (fontTraits & NSItalicFontMask) && !(scaledFontTraits & NSItalicFontMask);
340
341         return Font::create(scaledFontData);
342     }
343     END_BLOCK_OBJC_EXCEPTIONS;
344
345     return nullptr;
346 #else
347     CTFontSymbolicTraits fontTraits = CTFontGetSymbolicTraits(m_platformData.font());
348     RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontCopyFontDescriptor(m_platformData.font()));
349     RetainPtr<CTFontRef> scaledFont = adoptCF(CTFontCreateWithFontDescriptor(fontDescriptor.get(), size, nullptr));
350     FontPlatformData scaledFontData(scaledFont.get(), size, false, false, m_platformData.orientation());
351
352     if (scaledFontData.font()) {
353         if (m_platformData.m_syntheticBold)
354             fontTraits |= kCTFontBoldTrait;
355         if (m_platformData.m_syntheticOblique)
356             fontTraits |= kCTFontItalicTrait;
357
358         CTFontSymbolicTraits scaledFontTraits = CTFontGetSymbolicTraits(scaledFontData.font());
359         scaledFontData.m_syntheticBold = (fontTraits & kCTFontBoldTrait) && !(scaledFontTraits & kCTFontTraitBold);
360         scaledFontData.m_syntheticOblique = (fontTraits & kCTFontItalicTrait) && !(scaledFontTraits & kCTFontTraitItalic);
361
362         return Font::create(scaledFontData);
363     }
364
365     return nullptr;
366 #endif
367 }
368
369 void Font::determinePitch()
370 {
371 #if USE(APPKIT)
372     NSFont* f = m_platformData.nsFont();
373     // Special case Osaka-Mono.
374     // According to <rdar://problem/3999467>, we should treat Osaka-Mono as fixed pitch.
375     // Note that the AppKit does not report Osaka-Mono as fixed pitch.
376
377     // Special case MS-PGothic.
378     // According to <rdar://problem/4032938>, we should not treat MS-PGothic as fixed pitch.
379     // Note that AppKit does report MS-PGothic as fixed pitch.
380
381     // Special case MonotypeCorsiva
382     // According to <rdar://problem/5454704>, we should not treat MonotypeCorsiva as fixed pitch.
383     // Note that AppKit does report MonotypeCorsiva as fixed pitch.
384
385     NSString *name = [f fontName];
386     m_treatAsFixedPitch = ([f isFixedPitch]  || [f _isFakeFixedPitch] || [name caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame) && [name caseInsensitiveCompare:@"MS-PGothic"] != NSOrderedSame && [name caseInsensitiveCompare:@"MonotypeCorsiva"] != NSOrderedSame;
387 #else
388     CTFontRef ctFont = m_platformData.font();
389     m_treatAsFixedPitch = false;
390     if (!ctFont)
391         return; // CTFont is null in the case of SVG fonts for example.
392
393     RetainPtr<CFStringRef> fullName = adoptCF(CTFontCopyFullName(ctFont));
394     RetainPtr<CFStringRef> familyName = adoptCF(CTFontCopyFamilyName(ctFont));
395
396     m_treatAsFixedPitch = CGFontIsFixedPitch(m_platformData.cgFont()) || (fullName && (CFStringCompare(fullName.get(), CFSTR("Osaka-Mono"), kCFCompareCaseInsensitive) == kCFCompareEqualTo || CFStringCompare(fullName.get(), CFSTR("MS-PGothic"), kCFCompareCaseInsensitive) == kCFCompareEqualTo));
397     if (familyName && CFStringCompare(familyName.get(), CFSTR("Courier New"), kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
398         // 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).
399         m_treatAsFixedPitch = false;
400     }
401 #endif
402 }
403
404 FloatRect Font::platformBoundsForGlyph(Glyph glyph) const
405 {
406     FloatRect boundingBox;
407     boundingBox = CTFontGetBoundingRectsForGlyphs(m_platformData.ctFont(), platformData().orientation() == Vertical ? kCTFontOrientationVertical : kCTFontOrientationHorizontal, &glyph, 0, 1);
408     boundingBox.setY(-boundingBox.maxY());
409     if (m_syntheticBoldOffset)
410         boundingBox.setWidth(boundingBox.width() + m_syntheticBoldOffset);
411
412     return boundingBox;
413 }
414
415 static inline CGFontRenderingStyle renderingStyle(const FontPlatformData& platformData)
416 {
417 #if USE(APPKIT)
418     CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization;
419     NSFont *font = platformData.nsFont();
420     if (font) {
421         switch ([font renderingMode]) {
422         case NSFontIntegerAdvancementsRenderingMode:
423             style = 0;
424             break;
425         case NSFontAntialiasedIntegerAdvancementsRenderingMode:
426             style = kCGFontRenderingStyleAntialiasing;
427             break;
428         default:
429             break;
430         }
431     }
432     return style;
433
434 #else
435     UNUSED_PARAM(platformData);
436     return kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization | kCGFontAntialiasingStyleUnfiltered;
437 #endif
438 }
439
440 static inline bool advanceForColorBitmapFont(const FontPlatformData& platformData, Glyph glyph, CGSize& advance)
441 {
442 #if PLATFORM(MAC)
443     NSFont *font = platformData.nsFont();
444     if (!font || !platformData.isColorBitmapFont())
445         return false;
446     advance = NSSizeToCGSize([font advancementForGlyph:glyph]);
447     return true;
448 #else
449     UNUSED_PARAM(platformData);
450     UNUSED_PARAM(glyph);
451     UNUSED_PARAM(advance);
452     return false;
453 #endif
454 }
455
456 static inline bool canUseFastGlyphAdvanceGetter(const Font& font, Glyph glyph, CGSize& advance, bool& populatedAdvance)
457 {
458     const FontPlatformData& platformData = font.platformData();
459     // Fast getter doesn't doesn't work for emoji, bitmap fonts, or take custom tracking into account
460     if (font.hasCustomTracking() || platformData.textRenderingMode() == OptimizeLegibility)
461         return false;
462     if (advanceForColorBitmapFont(platformData, glyph, advance)) {
463         populatedAdvance = true;
464         return false;
465     }
466     return true;
467 }
468
469 float Font::platformWidthForGlyph(Glyph glyph) const
470 {
471     CGSize advance = CGSizeZero;
472     bool horizontal = platformData().orientation() == Horizontal;
473     bool populatedAdvance = false;
474     if ((horizontal || m_isBrokenIdeographFallback) && canUseFastGlyphAdvanceGetter(*this, glyph, advance, populatedAdvance)) {
475         float pointSize = platformData().m_size;
476         CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
477         if (!CGFontGetGlyphAdvancesForStyle(platformData().cgFont(), &m, renderingStyle(platformData()), &glyph, 1, &advance)) {
478             RetainPtr<CFStringRef> fullName = adoptCF(CGFontCopyFullName(platformData().cgFont()));
479             LOG_ERROR("Unable to cache glyph widths for %@ %f", fullName.get(), pointSize);
480             advance.width = 0;
481         }
482     } else if (!populatedAdvance)
483         CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), horizontal ? kCTFontOrientationHorizontal : kCTFontOrientationVertical, &glyph, &advance, 1);
484
485     return advance.width + m_syntheticBoldOffset;
486 }
487
488 struct ProviderInfo {
489     const UChar* characters;
490     size_t length;
491     CFDictionaryRef attributes;
492 };
493
494 static const UniChar* provideStringAndAttributes(CFIndex stringIndex, CFIndex* count, CFDictionaryRef* attributes, void* context)
495 {
496     ProviderInfo* info = static_cast<struct ProviderInfo*>(context);
497     if (stringIndex < 0 || static_cast<size_t>(stringIndex) >= info->length)
498         return 0;
499
500     *count = info->length - stringIndex;
501     *attributes = info->attributes;
502     return info->characters + stringIndex;
503 }
504
505 bool Font::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
506 {
507     ASSERT(isMainThread());
508
509     if (!m_combiningCharacterSequenceSupport)
510         m_combiningCharacterSequenceSupport = std::make_unique<HashMap<String, bool>>();
511
512     WTF::HashMap<String, bool>::AddResult addResult = m_combiningCharacterSequenceSupport->add(String(characters, length), false);
513     if (!addResult.isNewEntry)
514         return addResult.iterator->value;
515
516     RetainPtr<CFTypeRef> fontEqualityObject = platformData().objectForEqualityCheck();
517
518     ProviderInfo info = { characters, length, getCFStringAttributes(false, platformData().orientation()) };
519     RetainPtr<CTLineRef> line = adoptCF(CTLineCreateWithUniCharProvider(&provideStringAndAttributes, 0, &info));
520
521     CFArrayRef runArray = CTLineGetGlyphRuns(line.get());
522     CFIndex runCount = CFArrayGetCount(runArray);
523
524     for (CFIndex r = 0; r < runCount; r++) {
525         CTRunRef ctRun = static_cast<CTRunRef>(CFArrayGetValueAtIndex(runArray, r));
526         ASSERT(CFGetTypeID(ctRun) == CTRunGetTypeID());
527         CFDictionaryRef runAttributes = CTRunGetAttributes(ctRun);
528         CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttributes, kCTFontAttributeName));
529         if (!CFEqual(fontEqualityObject.get(), FontPlatformData::objectForEqualityCheck(runFont).get()))
530             return false;
531     }
532
533     addResult.iterator->value = true;
534     return true;
535 }
536
537 } // namespace WebCore