Access FontCache global instance via singleton() static member function
[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         return;
272
273     int thirdOfSize = m_platformData.size() / 3;
274     m_fontMetrics.setAscent(thirdOfSize);
275     m_fontMetrics.setDescent(thirdOfSize);
276     m_fontMetrics.setLineGap(thirdOfSize);
277     m_fontMetrics.setLineSpacing(0);
278 #endif
279 }
280
281 void Font::platformCharWidthInit()
282 {
283     m_avgCharWidth = 0;
284     m_maxCharWidth = 0;
285     
286 #if PLATFORM(MAC)
287     RetainPtr<CFDataRef> os2Table = adoptCF(CGFontCopyTableForTag(m_platformData.cgFont(), 'OS/2'));
288     if (os2Table && CFDataGetLength(os2Table.get()) >= 4) {
289         const UInt8* os2 = CFDataGetBytePtr(os2Table.get());
290         SInt16 os2AvgCharWidth = os2[2] * 256 + os2[3];
291         m_avgCharWidth = scaleEmToUnits(os2AvgCharWidth, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
292     }
293
294     RetainPtr<CFDataRef> headTable = adoptCF(CGFontCopyTableForTag(m_platformData.cgFont(), 'head'));
295     if (headTable && CFDataGetLength(headTable.get()) >= 42) {
296         const UInt8* head = CFDataGetBytePtr(headTable.get());
297         ushort uxMin = head[36] * 256 + head[37];
298         ushort uxMax = head[40] * 256 + head[41];
299         SInt16 xMin = static_cast<SInt16>(uxMin);
300         SInt16 xMax = static_cast<SInt16>(uxMax);
301         float diff = static_cast<float>(xMax - xMin);
302         m_maxCharWidth = scaleEmToUnits(diff, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
303     }
304 #endif
305
306     // Fallback to a cross-platform estimate, which will populate these values if they are non-positive.
307     initCharWidths();
308 }
309
310 void Font::platformDestroy()
311 {
312 }
313
314 PassRefPtr<Font> Font::platformCreateScaledFont(const FontDescription&, float scaleFactor) const
315 {
316     if (isCustomFont()) {
317         FontPlatformData scaledFontData(m_platformData);
318         scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
319         return Font::create(scaledFontData, true, false);
320     }
321
322     float size = m_platformData.size() * scaleFactor;
323
324 #if USE(APPKIT)
325     BEGIN_BLOCK_OBJC_EXCEPTIONS;
326
327     FontPlatformData scaledFontData([[NSFontManager sharedFontManager] convertFont:m_platformData.nsFont() toSize:size], size, false, false, m_platformData.orientation());
328
329     if (scaledFontData.font()) {
330         NSFontManager *fontManager = [NSFontManager sharedFontManager];
331         NSFontTraitMask fontTraits = [fontManager traitsOfFont:m_platformData.nsFont()];
332
333         if (m_platformData.m_syntheticBold)
334             fontTraits |= NSBoldFontMask;
335         if (m_platformData.m_syntheticOblique)
336             fontTraits |= NSItalicFontMask;
337
338         NSFontTraitMask scaledFontTraits = [fontManager traitsOfFont:scaledFontData.nsFont()];
339         scaledFontData.m_syntheticBold = (fontTraits & NSBoldFontMask) && !(scaledFontTraits & NSBoldFontMask);
340         scaledFontData.m_syntheticOblique = (fontTraits & NSItalicFontMask) && !(scaledFontTraits & NSItalicFontMask);
341
342         return FontCache::singleton().fontForPlatformData(scaledFontData);
343     }
344     END_BLOCK_OBJC_EXCEPTIONS;
345
346     return nullptr;
347 #else
348     CTFontSymbolicTraits fontTraits = CTFontGetSymbolicTraits(m_platformData.font());
349     RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontCopyFontDescriptor(m_platformData.font()));
350     RetainPtr<CTFontRef> scaledFont = adoptCF(CTFontCreateWithFontDescriptor(fontDescriptor.get(), size, nullptr));
351     FontPlatformData scaledFontData(scaledFont.get(), size, false, false, m_platformData.orientation());
352
353     if (scaledFontData.font()) {
354         if (m_platformData.m_syntheticBold)
355             fontTraits |= kCTFontBoldTrait;
356         if (m_platformData.m_syntheticOblique)
357             fontTraits |= kCTFontItalicTrait;
358
359         CTFontSymbolicTraits scaledFontTraits = CTFontGetSymbolicTraits(scaledFontData.font());
360         scaledFontData.m_syntheticBold = (fontTraits & kCTFontBoldTrait) && !(scaledFontTraits & kCTFontTraitBold);
361         scaledFontData.m_syntheticOblique = (fontTraits & kCTFontItalicTrait) && !(scaledFontTraits & kCTFontTraitItalic);
362
363         return FontCache::singleton().fontForPlatformData(scaledFontData);
364     }
365
366     return nullptr;
367 #endif
368 }
369
370 void Font::determinePitch()
371 {
372 #if USE(APPKIT)
373     NSFont* f = m_platformData.nsFont();
374     // Special case Osaka-Mono.
375     // According to <rdar://problem/3999467>, we should treat Osaka-Mono as fixed pitch.
376     // Note that the AppKit does not report Osaka-Mono as fixed pitch.
377
378     // Special case MS-PGothic.
379     // According to <rdar://problem/4032938>, we should not treat MS-PGothic as fixed pitch.
380     // Note that AppKit does report MS-PGothic as fixed pitch.
381
382     // Special case MonotypeCorsiva
383     // According to <rdar://problem/5454704>, we should not treat MonotypeCorsiva as fixed pitch.
384     // Note that AppKit does report MonotypeCorsiva as fixed pitch.
385
386     NSString *name = [f fontName];
387     m_treatAsFixedPitch = ([f isFixedPitch]  || [f _isFakeFixedPitch] || [name caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame) && [name caseInsensitiveCompare:@"MS-PGothic"] != NSOrderedSame && [name caseInsensitiveCompare:@"MonotypeCorsiva"] != NSOrderedSame;
388 #else
389     CTFontRef ctFont = m_platformData.font();
390     m_treatAsFixedPitch = false;
391     if (!ctFont)
392         return; // CTFont is null in the case of SVG fonts for example.
393
394     RetainPtr<CFStringRef> fullName = adoptCF(CTFontCopyFullName(ctFont));
395     RetainPtr<CFStringRef> familyName = adoptCF(CTFontCopyFamilyName(ctFont));
396
397     m_treatAsFixedPitch = CGFontIsFixedPitch(m_platformData.cgFont()) || (fullName && (CFStringCompare(fullName.get(), CFSTR("Osaka-Mono"), kCFCompareCaseInsensitive) == kCFCompareEqualTo || CFStringCompare(fullName.get(), CFSTR("MS-PGothic"), kCFCompareCaseInsensitive) == kCFCompareEqualTo));
398     if (familyName && CFStringCompare(familyName.get(), CFSTR("Courier New"), kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
399         // 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).
400         m_treatAsFixedPitch = false;
401     }
402 #endif
403 }
404
405 FloatRect Font::platformBoundsForGlyph(Glyph glyph) const
406 {
407     FloatRect boundingBox;
408     boundingBox = CTFontGetBoundingRectsForGlyphs(m_platformData.ctFont(), platformData().orientation() == Vertical ? kCTFontVerticalOrientation : kCTFontHorizontalOrientation, &glyph, 0, 1);
409     boundingBox.setY(-boundingBox.maxY());
410     if (m_syntheticBoldOffset)
411         boundingBox.setWidth(boundingBox.width() + m_syntheticBoldOffset);
412
413     return boundingBox;
414 }
415
416 static inline CGFontRenderingStyle renderingStyle(const FontPlatformData& platformData)
417 {
418 #if USE(APPKIT)
419     CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization;
420     NSFont *font = platformData.nsFont();
421     if (font) {
422         switch ([font renderingMode]) {
423         case NSFontIntegerAdvancementsRenderingMode:
424             style = 0;
425             break;
426         case NSFontAntialiasedIntegerAdvancementsRenderingMode:
427             style = kCGFontRenderingStyleAntialiasing;
428             break;
429         default:
430             break;
431         }
432     }
433     return style;
434
435 #else
436     UNUSED_PARAM(platformData);
437     return kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization | kCGFontAntialiasingStyleUnfiltered;
438 #endif
439 }
440
441 static inline bool advanceForColorBitmapFont(const FontPlatformData& platformData, Glyph glyph, CGSize& advance)
442 {
443 #if PLATFORM(MAC)
444     NSFont *font = platformData.nsFont();
445     if (!font || !platformData.isColorBitmapFont())
446         return false;
447     advance = NSSizeToCGSize([font advancementForGlyph:glyph]);
448     return true;
449 #else
450     UNUSED_PARAM(platformData);
451     UNUSED_PARAM(glyph);
452     UNUSED_PARAM(advance);
453     return false;
454 #endif
455 }
456
457 static bool hasCustomTracking(CTFontRef font)
458 {
459     return CTFontDescriptorIsSystemUIFont(adoptCF(CTFontCopyFontDescriptor(font)).get());
460 }
461
462 static inline bool isEmoji(const FontPlatformData& platformData)
463 {
464 #if PLATFORM(IOS)
465     return platformData.m_isEmoji;
466 #else
467     UNUSED_PARAM(platformData);
468     return false;
469 #endif
470 }
471
472 static inline bool canUseFastGlyphAdvanceGetter(const FontPlatformData& platformData, Glyph glyph, CGSize& advance, bool& populatedAdvance)
473 {
474     // Fast getter doesn't take custom tracking into account
475     if (hasCustomTracking(platformData.ctFont()))
476         return false;
477     // Fast getter doesn't work for emoji
478     if (isEmoji(platformData))
479         return false;
480     // ... or for any bitmap fonts in general
481     if (advanceForColorBitmapFont(platformData, glyph, advance)) {
482         populatedAdvance = true;
483         return false;
484     }
485     return true;
486 }
487
488 float Font::platformWidthForGlyph(Glyph glyph) const
489 {
490     CGSize advance = CGSizeZero;
491     bool horizontal = platformData().orientation() == Horizontal;
492     bool populatedAdvance = false;
493     if ((horizontal || m_isBrokenIdeographFallback) && canUseFastGlyphAdvanceGetter(platformData(), glyph, advance, populatedAdvance)) {
494         float pointSize = platformData().m_size;
495         CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
496         if (!CGFontGetGlyphAdvancesForStyle(platformData().cgFont(), &m, renderingStyle(platformData()), &glyph, 1, &advance)) {
497             RetainPtr<CFStringRef> fullName = adoptCF(CGFontCopyFullName(platformData().cgFont()));
498             LOG_ERROR("Unable to cache glyph widths for %@ %f", fullName.get(), pointSize);
499             advance.width = 0;
500         }
501     } else if (!populatedAdvance)
502         CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), horizontal ? kCTFontHorizontalOrientation : kCTFontVerticalOrientation, &glyph, &advance, 1);
503
504     return advance.width + m_syntheticBoldOffset;
505 }
506
507 struct ProviderInfo {
508     const UChar* characters;
509     size_t length;
510     CFDictionaryRef attributes;
511 };
512
513 static const UniChar* provideStringAndAttributes(CFIndex stringIndex, CFIndex* count, CFDictionaryRef* attributes, void* context)
514 {
515     ProviderInfo* info = static_cast<struct ProviderInfo*>(context);
516     if (stringIndex < 0 || static_cast<size_t>(stringIndex) >= info->length)
517         return 0;
518
519     *count = info->length - stringIndex;
520     *attributes = info->attributes;
521     return info->characters + stringIndex;
522 }
523
524 bool Font::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
525 {
526     ASSERT(isMainThread());
527
528     if (!m_combiningCharacterSequenceSupport)
529         m_combiningCharacterSequenceSupport = std::make_unique<HashMap<String, bool>>();
530
531     WTF::HashMap<String, bool>::AddResult addResult = m_combiningCharacterSequenceSupport->add(String(characters, length), false);
532     if (!addResult.isNewEntry)
533         return addResult.iterator->value;
534
535     RetainPtr<CFTypeRef> fontEqualityObject = platformData().objectForEqualityCheck();
536
537     ProviderInfo info = { characters, length, getCFStringAttributes(0, platformData().orientation()) };
538     RetainPtr<CTLineRef> line = adoptCF(CTLineCreateWithUniCharProvider(&provideStringAndAttributes, 0, &info));
539
540     CFArrayRef runArray = CTLineGetGlyphRuns(line.get());
541     CFIndex runCount = CFArrayGetCount(runArray);
542
543     for (CFIndex r = 0; r < runCount; r++) {
544         CTRunRef ctRun = static_cast<CTRunRef>(CFArrayGetValueAtIndex(runArray, r));
545         ASSERT(CFGetTypeID(ctRun) == CTRunGetTypeID());
546         CFDictionaryRef runAttributes = CTRunGetAttributes(ctRun);
547         CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttributes, kCTFontAttributeName));
548         if (!CFEqual(fontEqualityObject.get(), FontPlatformData::objectForEqualityCheck(runFont).get()))
549             return false;
550     }
551
552     addResult.iterator->value = true;
553     return true;
554 }
555
556 #if USE(APPKIT)
557 const Font* Font::compositeFontReferenceFont(NSFont *key) const
558 {
559     if (!key || CFEqual(adoptCF(CTFontCopyPostScriptName(CTFontRef(key))).get(), CFSTR("LastResort")))
560         return nullptr;
561
562     if (!m_derivedFontData)
563         m_derivedFontData = std::make_unique<DerivedFontData>(isCustomFont());
564
565     auto addResult = m_derivedFontData->compositeFontReferences.add(key, nullptr);
566     if (addResult.isNewEntry) {
567         NSFont *substituteFont = [key printerFont];
568
569         CTFontSymbolicTraits traits = CTFontGetSymbolicTraits((CTFontRef)substituteFont);
570         bool syntheticBold = platformData().syntheticBold() && !(traits & kCTFontBoldTrait);
571         bool syntheticOblique = platformData().syntheticOblique() && !(traits & kCTFontItalicTrait);
572
573         FontPlatformData substitutePlatform(substituteFont, platformData().size(), syntheticBold, syntheticOblique, platformData().orientation(), platformData().widthVariant());
574         addResult.iterator->value = Font::create(substitutePlatform, isCustomFont());
575     }
576     return addResult.iterator->value.get();
577 }
578 #endif
579
580 } // namespace WebCore