[iOS] Support bold and thin italicized system fonts
[WebKit-https.git] / Source / WebCore / platform / graphics / mac / FontCacheMac.mm
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
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  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #import "config.h"
31 #import "FontCache.h"
32
33 #if !PLATFORM(IOS)
34
35 #import "CoreGraphicsSPI.h"
36 #import "CoreTextSPI.h"
37 #import "Font.h"
38 #import "FontCascade.h"
39 #import "FontPlatformData.h"
40 #import "NSFontSPI.h"
41 #import "WebCoreNSStringExtras.h"
42 #import "WebCoreSystemInterface.h"
43 #import <AppKit/AppKit.h>
44 #import <wtf/MainThread.h>
45 #import <wtf/NeverDestroyed.h>
46 #import <wtf/Optional.h>
47 #import <wtf/StdLibExtras.h>
48 #import <wtf/Threading.h>
49 #import <wtf/text/AtomicStringHash.h>
50
51 namespace WebCore {
52
53 #if !ENABLE(PLATFORM_FONT_LOOKUP)
54
55 #define SYNTHESIZED_FONT_TRAITS (NSBoldFontMask | NSItalicFontMask)
56
57 #define IMPORTANT_FONT_TRAITS (0 \
58     | NSCompressedFontMask \
59     | NSCondensedFontMask \
60     | NSExpandedFontMask \
61     | NSItalicFontMask \
62     | NSNarrowFontMask \
63     | NSPosterFontMask \
64     | NSSmallCapsFontMask \
65 )
66
67 static bool acceptableChoice(NSFontTraitMask desiredTraits, NSFontTraitMask candidateTraits)
68 {
69     desiredTraits &= ~SYNTHESIZED_FONT_TRAITS;
70     return (candidateTraits & desiredTraits) == desiredTraits;
71 }
72
73 static bool betterChoice(NSFontTraitMask desiredTraits, int desiredWeight, NSFontTraitMask chosenTraits, int chosenWeight, NSFontTraitMask candidateTraits, int candidateWeight)
74 {
75     if (!acceptableChoice(desiredTraits, candidateTraits))
76         return false;
77
78     // A list of the traits we care about.
79     // The top item in the list is the worst trait to mismatch; if a font has this
80     // and we didn't ask for it, we'd prefer any other font in the family.
81     const NSFontTraitMask masks[] = {
82         NSPosterFontMask,
83         NSSmallCapsFontMask,
84         NSItalicFontMask,
85         NSCompressedFontMask,
86         NSCondensedFontMask,
87         NSExpandedFontMask,
88         NSNarrowFontMask,
89         0
90     };
91
92     int i = 0;
93     NSFontTraitMask mask;
94     while ((mask = masks[i++])) {
95         bool desired = desiredTraits & mask;
96         bool chosenHasUnwantedTrait = desired != (chosenTraits & mask);
97         bool candidateHasUnwantedTrait = desired != (candidateTraits & mask);
98         if (!candidateHasUnwantedTrait && chosenHasUnwantedTrait)
99             return true;
100         if (!chosenHasUnwantedTrait && candidateHasUnwantedTrait)
101             return false;
102     }
103
104     int chosenWeightDeltaMagnitude = abs(chosenWeight - desiredWeight);
105     int candidateWeightDeltaMagnitude = abs(candidateWeight - desiredWeight);
106
107     // If both are the same distance from the desired weight, prefer the candidate if it is further from medium.
108     if (chosenWeightDeltaMagnitude == candidateWeightDeltaMagnitude)
109         return abs(candidateWeight - 6) > abs(chosenWeight - 6);
110
111     // Otherwise, prefer the one closer to the desired weight.
112     return candidateWeightDeltaMagnitude < chosenWeightDeltaMagnitude;
113 }
114
115 #endif
116
117 static inline FontTraitsMask toTraitsMask(NSFontTraitMask appKitTraits, NSInteger appKitWeight)
118 {
119     return static_cast<FontTraitsMask>(((appKitTraits & NSFontItalicTrait) ? FontStyleItalicMask : FontStyleNormalMask)
120         | FontVariantNormalMask
121         | (appKitWeight == 1 ? FontWeight100Mask :
122             appKitWeight == 2 ? FontWeight200Mask :
123             appKitWeight <= 4 ? FontWeight300Mask :
124             appKitWeight == 5 ? FontWeight400Mask :
125             appKitWeight == 6 ? FontWeight500Mask :
126             appKitWeight <= 8 ? FontWeight600Mask :
127             appKitWeight == 9 ? FontWeight700Mask :
128             appKitWeight <= 11 ? FontWeight800Mask :
129                 FontWeight900Mask));
130 }
131
132 #if !ENABLE(PLATFORM_FONT_LOOKUP)
133 // Keep a cache for mapping desired font families to font families actually available on the system for performance.
134 using AvailableFamilyMap = HashMap<std::pair<AtomicString, NSFontTraitMask>, AtomicString>;
135 static AvailableFamilyMap& desiredFamilyToAvailableFamilyMap()
136 {
137     ASSERT(isMainThread());
138     static NeverDestroyed<AvailableFamilyMap> map;
139     return map;
140 }
141
142 static bool hasDesiredFamilyToAvailableFamilyMapping(const AtomicString& desiredFamily, NSFontTraitMask desiredTraits, NSString*& availableFamily)
143 {
144     AtomicString value = desiredFamilyToAvailableFamilyMap().get(std::make_pair(desiredFamily, desiredTraits));
145     availableFamily = value.isEmpty() ? nil : static_cast<NSString*>(value);
146     return !value.isNull();
147 }
148
149 static inline void rememberDesiredFamilyToAvailableFamilyMapping(const AtomicString& desiredFamily, NSFontTraitMask desiredTraits, NSString* availableFamily)
150 {
151     static const unsigned maxCacheSize = 128;
152     auto& familyMapping = desiredFamilyToAvailableFamilyMap();
153     ASSERT(familyMapping.size() <= maxCacheSize);
154     if (familyMapping.size() >= maxCacheSize)
155         familyMapping.remove(familyMapping.begin());
156
157     // Store nil as an emptyAtom to distinguish from missing values (nullAtom).
158     AtomicString value = availableFamily ? AtomicString(availableFamily) : emptyAtom;
159     familyMapping.add(std::make_pair(desiredFamily, desiredTraits), value);
160 }
161
162 #else
163
164 static uint16_t toCoreTextFontWeight(FontWeight fontWeight)
165 {
166     static const int coreTextFontWeights[] = {
167         100, // FontWeight100
168         200, // FontWeight200
169         300, // FontWeight300
170         400, // FontWeight400
171         500, // FontWeight500
172         600, // FontWeight600
173         700, // FontWeight700
174         800, // FontWeight800
175         900, // FontWeight900
176     };
177     return coreTextFontWeights[fontWeight];
178 }
179 #endif
180
181 typedef HashSet<String, CaseFoldingHash> Whitelist;
182 static Whitelist& fontWhitelist()
183 {
184     static NeverDestroyed<Whitelist> whitelist;
185     return whitelist;
186 }
187
188 void FontCache::setFontWhitelist(const Vector<String>& inputWhitelist)
189 {
190     Whitelist& whitelist = fontWhitelist();
191     whitelist.clear();
192     for (auto& item : inputWhitelist)
193         whitelist.add(item);
194 }
195
196 static int toAppKitFontWeight(FontWeight fontWeight)
197 {
198     static const int appKitFontWeights[] = {
199         2, // FontWeight100
200         3, // FontWeight200
201         4, // FontWeight300
202         5, // FontWeight400
203         6, // FontWeight500
204         8, // FontWeight600
205         9, // FontWeight700
206         10, // FontWeight800
207         12, // FontWeight900
208     };
209     return appKitFontWeights[fontWeight];
210 }
211
212 #if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101000
213 static CGFloat toNSFontWeight(FontWeight fontWeight)
214 {
215     static const CGFloat nsFontWeights[] = {
216         NSFontWeightUltraLight,
217         NSFontWeightThin,
218         NSFontWeightLight,
219         NSFontWeightRegular,
220         NSFontWeightMedium,
221         NSFontWeightSemibold,
222         NSFontWeightBold,
223         NSFontWeightHeavy,
224         NSFontWeightBlack
225     };
226     ASSERT(fontWeight >= 0 && fontWeight <= 8);
227     return nsFontWeights[fontWeight];
228 }
229 #endif
230
231 static Optional<NSFont*> fontWithFamilySpecialCase(const AtomicString& family, FontWeight weight, NSFontTraitMask desiredTraits, float size)
232 {
233     if (equalIgnoringASCIICase(family, "-webkit-system-font")
234         || equalIgnoringASCIICase(family, "-apple-system")
235         || equalIgnoringASCIICase(family, "-apple-system-font")) {
236 #if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101000
237         NSFont *result = [NSFont systemFontOfSize:size weight:toNSFontWeight(weight)];
238 #else
239         NSFont *result = (weight >= FontWeight600) ? [NSFont boldSystemFontOfSize:size] : [NSFont systemFontOfSize:size];
240 #endif
241         if (desiredTraits & NSFontItalicTrait)
242             result = [[NSFontManager sharedFontManager] convertFont:result toHaveTrait:desiredTraits];
243         return result;
244     }
245
246     if (equalIgnoringASCIICase(family, "-apple-system-monospaced-numbers")) {
247         NSArray *featureArray = @[ @{ NSFontFeatureTypeIdentifierKey : @(kNumberSpacingType),
248             NSFontFeatureSelectorIdentifierKey : @(kMonospacedNumbersSelector) } ];
249
250         NSFont* systemFont = [NSFont systemFontOfSize:size];
251         NSFontDescriptor* desc = [systemFont.fontDescriptor fontDescriptorByAddingAttributes:@{ NSFontFeatureSettingsAttribute : featureArray }];
252         return [NSFont fontWithDescriptor:desc size:size];
253     }
254
255     if (equalIgnoringASCIICase(family, "-apple-menu"))
256         return [NSFont menuFontOfSize:size];
257
258     if (equalIgnoringASCIICase(family, "-apple-status-bar"))
259         return [NSFont labelFontOfSize:size];
260
261     return Optional<NSFont*>(Nullopt);
262 }
263
264 // Family name is somewhat of a misnomer here. We first attempt to find an exact match
265 // comparing the desiredFamily to the PostScript name of the installed fonts. If that fails
266 // we then do a search based on the family names of the installed fonts.
267 static NSFont *fontWithFamily(const AtomicString& family, NSFontTraitMask desiredTraits, FontWeight weight, float size)
268 {
269     if (const auto& specialCase = fontWithFamilySpecialCase(family, weight, desiredTraits, size))
270         return specialCase.value();
271
272     NSFontManager *fontManager = [NSFontManager sharedFontManager];
273     NSString *availableFamily;
274     int chosenWeight;
275     NSFont *font;
276
277 #if ENABLE(PLATFORM_FONT_LOOKUP)
278
279     const auto& whitelist = fontWhitelist();
280     if (whitelist.size() && !whitelist.contains(family.lower()))
281         return nil;
282     CTFontSymbolicTraits requestedTraits = 0;
283     if (desiredTraits & NSFontItalicTrait)
284         requestedTraits |= kCTFontItalicTrait;
285     if (weight >= FontWeight600)
286         requestedTraits |= kCTFontBoldTrait;
287
288     NSString *desiredFamily = family;
289     font = CFBridgingRelease(CTFontCreateForCSS((CFStringRef)desiredFamily, toCoreTextFontWeight(weight), requestedTraits, size));
290     availableFamily = [font familyName];
291     chosenWeight = [fontManager weightOfFont:font];
292
293 #else
294
295     NSFontTraitMask desiredTraitsForNameMatch = desiredTraits | (weight >= FontWeight600 ? NSBoldFontMask : 0);
296     if (hasDesiredFamilyToAvailableFamilyMapping(family, desiredTraitsForNameMatch, availableFamily)) {
297         if (!availableFamily) {
298             // We already know the desired font family does not map to any available font family.
299             return nil;
300         }
301     }
302
303     if (!availableFamily) {
304         NSString *desiredFamily = family;
305
306         // Do a simple case insensitive search for a matching font family.
307         // NSFontManager requires exact name matches.
308         // This addresses the problem of matching arial to Arial, etc., but perhaps not all the issues.
309         for (availableFamily in [fontManager availableFontFamilies]) {
310             if ([desiredFamily caseInsensitiveCompare:availableFamily] == NSOrderedSame)
311                 break;
312         }
313
314         if (!availableFamily) {
315             // Match by PostScript name.
316             NSFont *nameMatchedFont = nil;
317             for (NSString *availableFont in [fontManager availableFonts]) {
318                 if ([desiredFamily caseInsensitiveCompare:availableFont] == NSOrderedSame) {
319                     nameMatchedFont = [NSFont fontWithName:availableFont size:size];
320
321                     // Special case Osaka-Mono. According to <rdar://problem/3999467>, we need to
322                     // treat Osaka-Mono as fixed pitch.
323                     if ([desiredFamily caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame && !desiredTraitsForNameMatch)
324                         return nameMatchedFont;
325
326                     NSFontTraitMask traits = [fontManager traitsOfFont:nameMatchedFont];
327                     if ((traits & desiredTraitsForNameMatch) == desiredTraitsForNameMatch)
328                         return [fontManager convertFont:nameMatchedFont toHaveTrait:desiredTraitsForNameMatch];
329
330                     availableFamily = [nameMatchedFont familyName];
331                     break;
332                 }
333             }
334         }
335
336         rememberDesiredFamilyToAvailableFamilyMapping(family, desiredTraitsForNameMatch, availableFamily);
337         if (!availableFamily)
338             return nil;
339     }
340
341     // Found a family, now figure out what weight and traits to use.
342     bool choseFont = false;
343     chosenWeight = 0;
344     NSFontTraitMask chosenTraits = 0;
345     NSString *chosenFullName = 0;
346
347     int appKitDesiredWeight = toAppKitFontWeight(weight);
348     NSArray *fonts = [fontManager availableMembersOfFontFamily:availableFamily];
349     for (NSArray *fontInfo in fonts) {
350         // Array indices must be hard coded because of lame AppKit API.
351         NSString *fontFullName = [fontInfo objectAtIndex:0];
352         NSInteger fontWeight = [[fontInfo objectAtIndex:2] intValue];
353         NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
354
355         BOOL newWinner;
356         if (!choseFont)
357             newWinner = acceptableChoice(desiredTraits, fontTraits);
358         else
359             newWinner = betterChoice(desiredTraits, appKitDesiredWeight, chosenTraits, chosenWeight, fontTraits, fontWeight);
360
361         if (newWinner) {
362             choseFont = YES;
363             chosenWeight = fontWeight;
364             chosenTraits = fontTraits;
365             chosenFullName = fontFullName;
366
367             if (chosenWeight == appKitDesiredWeight && (chosenTraits & IMPORTANT_FONT_TRAITS) == (desiredTraits & IMPORTANT_FONT_TRAITS))
368                 break;
369         }
370     }
371
372     if (!choseFont)
373         return nil;
374
375     font = [NSFont fontWithName:chosenFullName size:size];
376
377 #endif
378
379     if (!font)
380         return nil;
381
382     NSFontTraitMask actualTraits = 0;
383     if (desiredTraits & NSFontItalicTrait)
384         actualTraits = [fontManager traitsOfFont:font];
385     int actualWeight = [fontManager weightOfFont:font];
386
387     bool syntheticBold = toAppKitFontWeight(weight) >= 7 && actualWeight < 7;
388     bool syntheticOblique = (desiredTraits & NSFontItalicTrait) && !(actualTraits & NSFontItalicTrait);
389
390     // There are some malformed fonts that will be correctly returned by -fontWithFamily:traits:weight:size: as a match for a particular trait,
391     // though -[NSFontManager traitsOfFont:] incorrectly claims the font does not have the specified trait. This could result in applying 
392     // synthetic bold on top of an already-bold font, as reported in <http://bugs.webkit.org/show_bug.cgi?id=6146>. To work around this
393     // problem, if we got an apparent exact match, but the requested traits aren't present in the matched font, we'll try to get a font from 
394     // the same family without those traits (to apply the synthetic traits to later).
395     NSFontTraitMask nonSyntheticTraits = desiredTraits;
396
397     if (syntheticBold)
398         nonSyntheticTraits &= ~NSBoldFontMask;
399
400     if (syntheticOblique)
401         nonSyntheticTraits &= ~NSItalicFontMask;
402
403     if (nonSyntheticTraits != desiredTraits) {
404         NSFont *fontWithoutSyntheticTraits = [fontManager fontWithFamily:availableFamily traits:nonSyntheticTraits weight:chosenWeight size:size];
405         if (fontWithoutSyntheticTraits)
406             font = fontWithoutSyntheticTraits;
407     }
408
409     return font;
410 }
411
412 // The "void*" parameter makes the function match the prototype for callbacks from callOnMainThread.
413 static void invalidateFontCache(void*)
414 {
415     if (!isMainThread()) {
416         callOnMainThread(&invalidateFontCache, nullptr);
417         return;
418     }
419     FontCache::singleton().invalidate();
420
421 #if !ENABLE(PLATFORM_FONT_LOOKUP)
422     desiredFamilyToAvailableFamilyMap().clear();
423 #endif
424 }
425
426 static void fontCacheRegisteredFontsChangedNotificationCallback(CFNotificationCenterRef, void* observer, CFStringRef name, const void *, CFDictionaryRef)
427 {
428     ASSERT_UNUSED(observer, observer == &FontCache::singleton());
429     ASSERT_UNUSED(name, CFEqual(name, kCTFontManagerRegisteredFontsChangedNotification));
430     invalidateFontCache(0);
431 }
432
433 void FontCache::platformInit()
434 {
435     CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(), this, fontCacheRegisteredFontsChangedNotificationCallback, kCTFontManagerRegisteredFontsChangedNotification, 0, CFNotificationSuspensionBehaviorDeliverImmediately);
436 }
437
438 static inline bool isAppKitFontWeightBold(NSInteger appKitFontWeight)
439 {
440     return appKitFontWeight >= 7;
441 }
442
443 static bool shouldAutoActivateFontIfNeeded(const AtomicString& family)
444 {
445 #ifndef NDEBUG
446     // This cache is not thread safe so the following assertion is there to
447     // make sure this function is always called from the same thread.
448     static ThreadIdentifier initThreadId = currentThread();
449     ASSERT(currentThread() == initThreadId);
450 #endif
451
452     static NeverDestroyed<HashSet<AtomicString>> knownFamilies;
453     static const unsigned maxCacheSize = 128;
454     ASSERT(knownFamilies.get().size() <= maxCacheSize);
455     if (knownFamilies.get().size() == maxCacheSize)
456         knownFamilies.get().remove(knownFamilies.get().begin());
457
458     // Only attempt to auto-activate fonts once for performance reasons.
459     return knownFamilies.get().add(family).isNewEntry;
460 }
461
462 RefPtr<Font> FontCache::systemFallbackForCharacters(const FontDescription& description, const Font* originalFontData, bool isPlatformFont, const UChar* characters, unsigned length)
463 {
464     UChar32 character;
465     U16_GET(characters, 0, 0, length, character);
466     const FontPlatformData& platformData = originalFontData->platformData();
467     NSFont *nsFont = platformData.nsFont();
468
469     NSString *string = [[NSString alloc] initWithCharactersNoCopy:const_cast<UChar*>(characters) length:length freeWhenDone:NO];
470     NSFont *substituteFont = [NSFont findFontLike:nsFont forString:string withRange:NSMakeRange(0, [string length]) inLanguage:nil];
471     [string release];
472
473     if (!substituteFont && length == 1)
474         substituteFont = [NSFont findFontLike:nsFont forCharacter:characters[0] inLanguage:nil];
475     if (!substituteFont)
476         return 0;
477
478     // Use the family name from the AppKit-supplied substitute font, requesting the
479     // traits, weight, and size we want. One way this does better than the original
480     // AppKit request is that it takes synthetic bold and oblique into account.
481     // But it does create the possibility that we could end up with a font that
482     // doesn't actually cover the characters we need.
483
484     NSFontManager *fontManager = [NSFontManager sharedFontManager];
485
486     NSFontTraitMask traits = 0;
487     NSInteger weight;
488     CGFloat size;
489
490     if (nsFont) {
491         if (description.italic())
492             traits = [fontManager traitsOfFont:nsFont];
493         if (platformData.m_syntheticBold)
494             traits |= NSBoldFontMask;
495         if (platformData.m_syntheticOblique)
496             traits |= NSFontItalicTrait;
497         weight = [fontManager weightOfFont:nsFont];
498         size = [nsFont pointSize];
499     } else {
500         // For custom fonts nsFont is nil.
501         traits = description.italic() ? NSFontItalicTrait : 0;
502         weight = toAppKitFontWeight(description.weight());
503         size = description.computedPixelSize();
504     }
505
506     NSFontTraitMask substituteFontTraits = [fontManager traitsOfFont:substituteFont];
507     NSInteger substituteFontWeight = [fontManager weightOfFont:substituteFont];
508
509     if (traits != substituteFontTraits || weight != substituteFontWeight || !nsFont) {
510         if (NSFont *bestVariation = [fontManager fontWithFamily:[substituteFont familyName] traits:traits weight:weight size:size]) {
511             if (!nsFont || (([fontManager traitsOfFont:bestVariation] != substituteFontTraits || [fontManager weightOfFont:bestVariation] != substituteFontWeight)
512                 && [[bestVariation coveredCharacterSet] longCharacterIsMember:character]))
513                 substituteFont = bestVariation;
514         }
515     }
516
517     substituteFont = [substituteFont printerFont];
518
519     substituteFontTraits = [fontManager traitsOfFont:substituteFont];
520     substituteFontWeight = [fontManager weightOfFont:substituteFont];
521
522     FontPlatformData alternateFont(reinterpret_cast<CTFontRef>(substituteFont), platformData.size(),
523         !isPlatformFont && isAppKitFontWeightBold(weight) && !isAppKitFontWeightBold(substituteFontWeight),
524         !isPlatformFont && (traits & NSFontItalicTrait) && !(substituteFontTraits & NSFontItalicTrait),
525         platformData.m_orientation);
526
527     return fontForPlatformData(alternateFont);
528 }
529
530 RefPtr<Font> FontCache::similarFont(const FontDescription& description)
531 {
532     // Attempt to find an appropriate font using a match based on 
533     // the presence of keywords in the the requested names.  For example, we'll
534     // match any name that contains "Arabic" to Geeza Pro.
535     RefPtr<Font> font;
536     for (unsigned i = 0; i < description.familyCount(); ++i) {
537         const AtomicString& family = description.familyAt(i);
538         if (family.isEmpty())
539             continue;
540         static String* matchWords[3] = { new String("Arabic"), new String("Pashto"), new String("Urdu") };
541         DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, geezaStr, ("Geeza Pro", AtomicString::ConstructFromLiteral));
542         for (unsigned j = 0; j < 3 && !font; ++j) {
543             if (family.contains(*matchWords[j], false))
544                 font = fontForFamily(description, geezaStr);
545         }
546     }
547     return font.release();
548 }
549
550 Ref<Font> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
551 {
552     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, timesStr, ("Times", AtomicString::ConstructFromLiteral));
553
554     // FIXME: Would be even better to somehow get the user's default font here.  For now we'll pick
555     // the default that the user would get without changing any prefs.
556     RefPtr<Font> font = fontForFamily(fontDescription, timesStr, false);
557     if (font)
558         return *font;
559
560     // The Times fallback will almost always work, but in the highly unusual case where
561     // the user doesn't have it, we fall back on Lucida Grande because that's
562     // guaranteed to be there, according to Nathan Taylor. This is good enough
563     // to avoid a crash at least.
564     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, lucidaGrandeStr, ("Lucida Grande", AtomicString::ConstructFromLiteral));
565     return *fontForFamily(fontDescription, lucidaGrandeStr, false);
566 }
567
568 void FontCache::getTraitsInFamily(const AtomicString& familyName, Vector<unsigned>& traitsMasks)
569 {
570     NSFontManager *fontManager = [NSFontManager sharedFontManager];
571
572     NSString *availableFamily;
573     for (availableFamily in [fontManager availableFontFamilies]) {
574         if ([familyName caseInsensitiveCompare:availableFamily] == NSOrderedSame)
575             break;
576     }
577
578     if (!availableFamily) {
579         // Match by PostScript name.
580         for (NSString *availableFont in [fontManager availableFonts]) {
581             if ([familyName caseInsensitiveCompare:availableFont] == NSOrderedSame) {
582                 NSFont *font = [NSFont fontWithName:availableFont size:10];
583                 NSInteger weight = [fontManager weightOfFont:font];
584                 traitsMasks.append(toTraitsMask([fontManager traitsOfFont:font], weight));
585                 break;
586             }
587         }
588         return;
589     }
590
591     NSArray *fonts = [fontManager availableMembersOfFontFamily:availableFamily];
592     traitsMasks.reserveCapacity([fonts count]);
593     for (NSArray *fontInfo in fonts) {
594         // Array indices must be hard coded because of lame AppKit API.
595         NSInteger fontWeight = [[fontInfo objectAtIndex:2] intValue];
596         NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
597         traitsMasks.uncheckedAppend(toTraitsMask(fontTraits, fontWeight));
598     }
599 }
600
601 std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
602 {
603     NSFontTraitMask traits = fontDescription.italic() ? NSFontItalicTrait : 0;
604     float size = fontDescription.computedPixelSize();
605
606     NSFont *nsFont = fontWithFamily(family, traits, fontDescription.weight(), size);
607     if (!nsFont) {
608         if (!shouldAutoActivateFontIfNeeded(family))
609             return nullptr;
610
611         // Auto activate the font before looking for it a second time.
612         // Ignore the result because we want to use our own algorithm to actually find the font.
613         [NSFont fontWithName:family size:size];
614
615         nsFont = fontWithFamily(family, traits, fontDescription.weight(), size);
616         if (!nsFont)
617             return nullptr;
618     }
619
620     NSFontManager *fontManager = [NSFontManager sharedFontManager];
621     NSFontTraitMask actualTraits = 0;
622     if (fontDescription.italic())
623         actualTraits = [fontManager traitsOfFont:nsFont];
624     NSInteger actualWeight = [fontManager weightOfFont:nsFont];
625
626     NSFont *platformFont = [nsFont printerFont];
627     bool syntheticBold = (fontDescription.fontSynthesis() & FontSynthesisWeight) && isAppKitFontWeightBold(toAppKitFontWeight(fontDescription.weight())) && !isAppKitFontWeightBold(actualWeight);
628     bool syntheticOblique = (fontDescription.fontSynthesis() & FontSynthesisStyle) && (traits & NSFontItalicTrait) && !(actualTraits & NSFontItalicTrait);
629
630     return std::make_unique<FontPlatformData>(reinterpret_cast<CTFontRef>(platformFont), size, syntheticBold, syntheticOblique, fontDescription.orientation(), fontDescription.widthVariant());
631 }
632
633 } // namespace WebCore
634
635 #endif // !PLATFORM(IOS)