FontCache should only deal with SimpleFontData
[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 "Font.h"
37 #import "SimpleFontData.h"
38 #import "FontPlatformData.h"
39 #import "NSFontSPI.h"
40 #import "WebCoreNSStringExtras.h"
41 #import "WebCoreSystemInterface.h"
42 #import <AppKit/AppKit.h>
43 #import <wtf/MainThread.h>
44 #import <wtf/NeverDestroyed.h>
45 #import <wtf/StdLibExtras.h>
46 #import <wtf/Threading.h>
47 #import <wtf/text/AtomicStringHash.h>
48
49 namespace WebCore {
50
51 #define SYNTHESIZED_FONT_TRAITS (NSBoldFontMask | NSItalicFontMask)
52
53 #define IMPORTANT_FONT_TRAITS (0 \
54     | NSCompressedFontMask \
55     | NSCondensedFontMask \
56     | NSExpandedFontMask \
57     | NSItalicFontMask \
58     | NSNarrowFontMask \
59     | NSPosterFontMask \
60     | NSSmallCapsFontMask \
61 )
62
63 static bool acceptableChoice(NSFontTraitMask desiredTraits, NSFontTraitMask candidateTraits)
64 {
65     desiredTraits &= ~SYNTHESIZED_FONT_TRAITS;
66     return (candidateTraits & desiredTraits) == desiredTraits;
67 }
68
69 static bool betterChoice(NSFontTraitMask desiredTraits, int desiredWeight, NSFontTraitMask chosenTraits, int chosenWeight, NSFontTraitMask candidateTraits, int candidateWeight)
70 {
71     if (!acceptableChoice(desiredTraits, candidateTraits))
72         return false;
73
74     // A list of the traits we care about.
75     // The top item in the list is the worst trait to mismatch; if a font has this
76     // and we didn't ask for it, we'd prefer any other font in the family.
77     const NSFontTraitMask masks[] = {
78         NSPosterFontMask,
79         NSSmallCapsFontMask,
80         NSItalicFontMask,
81         NSCompressedFontMask,
82         NSCondensedFontMask,
83         NSExpandedFontMask,
84         NSNarrowFontMask,
85         0
86     };
87
88     int i = 0;
89     NSFontTraitMask mask;
90     while ((mask = masks[i++])) {
91         bool desired = desiredTraits & mask;
92         bool chosenHasUnwantedTrait = desired != (chosenTraits & mask);
93         bool candidateHasUnwantedTrait = desired != (candidateTraits & mask);
94         if (!candidateHasUnwantedTrait && chosenHasUnwantedTrait)
95             return true;
96         if (!chosenHasUnwantedTrait && candidateHasUnwantedTrait)
97             return false;
98     }
99
100     int chosenWeightDeltaMagnitude = abs(chosenWeight - desiredWeight);
101     int candidateWeightDeltaMagnitude = abs(candidateWeight - desiredWeight);
102
103     // If both are the same distance from the desired weight, prefer the candidate if it is further from medium.
104     if (chosenWeightDeltaMagnitude == candidateWeightDeltaMagnitude)
105         return abs(candidateWeight - 6) > abs(chosenWeight - 6);
106
107     // Otherwise, prefer the one closer to the desired weight.
108     return candidateWeightDeltaMagnitude < chosenWeightDeltaMagnitude;
109 }
110
111 static inline FontTraitsMask toTraitsMask(NSFontTraitMask appKitTraits, NSInteger appKitWeight)
112 {
113     return static_cast<FontTraitsMask>(((appKitTraits & NSFontItalicTrait) ? FontStyleItalicMask : FontStyleNormalMask)
114         | FontVariantNormalMask
115         | (appKitWeight == 1 ? FontWeight100Mask :
116             appKitWeight == 2 ? FontWeight200Mask :
117             appKitWeight <= 4 ? FontWeight300Mask :
118             appKitWeight == 5 ? FontWeight400Mask :
119             appKitWeight == 6 ? FontWeight500Mask :
120             appKitWeight <= 8 ? FontWeight600Mask :
121             appKitWeight == 9 ? FontWeight700Mask :
122             appKitWeight <= 11 ? FontWeight800Mask :
123                 FontWeight900Mask));
124 }
125
126 // Keep a cache for mapping desired font families to font families actually
127 // available on the system for performance.
128 static NSMutableDictionary* desiredFamilyToAvailableFamilyDictionary()
129 {
130     ASSERT(isMainThread());
131     static NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] init];
132     return dictionary;
133 }
134
135 static inline void rememberDesiredFamilyToAvailableFamilyMapping(NSString* desiredFamily, NSString* availableFamily)
136 {
137     static const NSUInteger maxCacheSize = 128;
138     NSMutableDictionary *familyMapping = desiredFamilyToAvailableFamilyDictionary();
139     ASSERT([familyMapping count] <= maxCacheSize);
140     if ([familyMapping count] == maxCacheSize) {
141         for (NSString *key in familyMapping) {
142             [familyMapping removeObjectForKey:key];
143             break;
144         }
145     }
146     id value = availableFamily ? availableFamily : [NSNull null];
147     [familyMapping setObject:value forKey:desiredFamily];
148 }
149
150 // Family name is somewhat of a misnomer here. We first attempt to find an exact match
151 // comparing the desiredFamily to the PostScript name of the installed fonts. If that fails
152 // we then do a search based on the family names of the installed fonts.
153 static NSFont *fontWithFamily(NSString *desiredFamily, NSFontTraitMask desiredTraits, int desiredWeight, float size)
154 {
155     if (stringIsCaseInsensitiveEqualToString(desiredFamily, @"-webkit-system-font")
156         || stringIsCaseInsensitiveEqualToString(desiredFamily, @"-apple-system-font")) {
157         // We ignore italic for system font.
158         return (desiredWeight >= 7) ? [NSFont boldSystemFontOfSize:size] : [NSFont systemFontOfSize:size];
159     }
160
161     id cachedAvailableFamily = [desiredFamilyToAvailableFamilyDictionary() objectForKey:desiredFamily];
162     if (cachedAvailableFamily == [NSNull null]) {
163         // We already know this font is not available.
164         return nil;
165     }
166
167     NSFontManager *fontManager = [NSFontManager sharedFontManager];
168     NSString *availableFamily = cachedAvailableFamily;
169     if (!availableFamily) {
170         // Do a simple case insensitive search for a matching font family.
171         // NSFontManager requires exact name matches.
172         // This addresses the problem of matching arial to Arial, etc., but perhaps not all the issues.
173         for (availableFamily in [fontManager availableFontFamilies]) {
174             if ([desiredFamily caseInsensitiveCompare:availableFamily] == NSOrderedSame)
175                 break;
176         }
177
178         if (!availableFamily) {
179             // Match by PostScript name.
180             NSFont *nameMatchedFont = nil;
181             NSFontTraitMask desiredTraitsForNameMatch = desiredTraits | (desiredWeight >= 7 ? NSBoldFontMask : 0);
182             for (NSString *availableFont in [fontManager availableFonts]) {
183                 if ([desiredFamily caseInsensitiveCompare:availableFont] == NSOrderedSame) {
184                     nameMatchedFont = [NSFont fontWithName:availableFont size:size];
185
186                     // Special case Osaka-Mono. According to <rdar://problem/3999467>, we need to
187                     // treat Osaka-Mono as fixed pitch.
188                     if ([desiredFamily caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame && !desiredTraitsForNameMatch)
189                         return nameMatchedFont;
190
191                     NSFontTraitMask traits = [fontManager traitsOfFont:nameMatchedFont];
192                     if ((traits & desiredTraitsForNameMatch) == desiredTraitsForNameMatch)
193                         return [fontManager convertFont:nameMatchedFont toHaveTrait:desiredTraitsForNameMatch];
194
195                     availableFamily = [nameMatchedFont familyName];
196                     break;
197                 }
198             }
199         }
200
201         rememberDesiredFamilyToAvailableFamilyMapping(desiredFamily, availableFamily);
202         if (!availableFamily)
203             return nil;
204     }
205
206     // Found a family, now figure out what weight and traits to use.
207     bool choseFont = false;
208     int chosenWeight = 0;
209     NSFontTraitMask chosenTraits = 0;
210     NSString *chosenFullName = 0;
211
212     NSArray *fonts = [fontManager availableMembersOfFontFamily:availableFamily];
213     for (NSArray *fontInfo in fonts) {
214         // Array indices must be hard coded because of lame AppKit API.
215         NSString *fontFullName = [fontInfo objectAtIndex:0];
216         NSInteger fontWeight = [[fontInfo objectAtIndex:2] intValue];
217         NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
218
219         BOOL newWinner;
220         if (!choseFont)
221             newWinner = acceptableChoice(desiredTraits, fontTraits);
222         else
223             newWinner = betterChoice(desiredTraits, desiredWeight, chosenTraits, chosenWeight, fontTraits, fontWeight);
224
225         if (newWinner) {
226             choseFont = YES;
227             chosenWeight = fontWeight;
228             chosenTraits = fontTraits;
229             chosenFullName = fontFullName;
230
231             if (chosenWeight == desiredWeight && (chosenTraits & IMPORTANT_FONT_TRAITS) == (desiredTraits & IMPORTANT_FONT_TRAITS))
232                 break;
233         }
234     }
235
236     if (!choseFont)
237         return nil;
238
239     NSFont *font = [NSFont fontWithName:chosenFullName size:size];
240
241     if (!font)
242         return nil;
243
244     NSFontTraitMask actualTraits = 0;
245     if (desiredTraits & NSFontItalicTrait)
246         actualTraits = [fontManager traitsOfFont:font];
247     int actualWeight = [fontManager weightOfFont:font];
248
249     bool syntheticBold = desiredWeight >= 7 && actualWeight < 7;
250     bool syntheticOblique = (desiredTraits & NSFontItalicTrait) && !(actualTraits & NSFontItalicTrait);
251
252     // There are some malformed fonts that will be correctly returned by -fontWithFamily:traits:weight:size: as a match for a particular trait,
253     // though -[NSFontManager traitsOfFont:] incorrectly claims the font does not have the specified trait. This could result in applying 
254     // 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
255     // 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 
256     // the same family without those traits (to apply the synthetic traits to later).
257     NSFontTraitMask nonSyntheticTraits = desiredTraits;
258
259     if (syntheticBold)
260         nonSyntheticTraits &= ~NSBoldFontMask;
261
262     if (syntheticOblique)
263         nonSyntheticTraits &= ~NSItalicFontMask;
264
265     if (nonSyntheticTraits != desiredTraits) {
266         NSFont *fontWithoutSyntheticTraits = [fontManager fontWithFamily:availableFamily traits:nonSyntheticTraits weight:chosenWeight size:size];
267         if (fontWithoutSyntheticTraits)
268             font = fontWithoutSyntheticTraits;
269     }
270
271     return font;
272 }
273
274 // The "void*" parameter makes the function match the prototype for callbacks from callOnMainThread.
275 static void invalidateFontCache(void*)
276 {
277     if (!isMainThread()) {
278         callOnMainThread(&invalidateFontCache, 0);
279         return;
280     }
281     fontCache().invalidate();
282     [desiredFamilyToAvailableFamilyDictionary() removeAllObjects];
283 }
284
285 static void fontCacheRegisteredFontsChangedNotificationCallback(CFNotificationCenterRef, void* observer, CFStringRef name, const void *, CFDictionaryRef)
286 {
287     ASSERT_UNUSED(observer, observer == &fontCache());
288     ASSERT_UNUSED(name, CFEqual(name, kCTFontManagerRegisteredFontsChangedNotification));
289     invalidateFontCache(0);
290 }
291
292 void FontCache::platformInit()
293 {
294 #if __MAC_OS_X_VERSION_MIN_REQUIRED <= 1080
295     CGFontSetShouldUseMulticache(true);
296 #endif
297     CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(), this, fontCacheRegisteredFontsChangedNotificationCallback, kCTFontManagerRegisteredFontsChangedNotification, 0, CFNotificationSuspensionBehaviorDeliverImmediately);
298 }
299
300 static int toAppKitFontWeight(FontWeight fontWeight)
301 {
302     static int appKitFontWeights[] = {
303         2,  // FontWeight100
304         3,  // FontWeight200
305         4,  // FontWeight300
306         5,  // FontWeight400
307         6,  // FontWeight500
308         8,  // FontWeight600
309         9,  // FontWeight700
310         10, // FontWeight800
311         12, // FontWeight900
312     };
313     return appKitFontWeights[fontWeight];
314 }
315
316 static inline bool isAppKitFontWeightBold(NSInteger appKitFontWeight)
317 {
318     return appKitFontWeight >= 7;
319 }
320
321 static bool shouldAutoActivateFontIfNeeded(const AtomicString& family)
322 {
323 #ifndef NDEBUG
324     // This cache is not thread safe so the following assertion is there to
325     // make sure this function is always called from the same thread.
326     static ThreadIdentifier initThreadId = currentThread();
327     ASSERT(currentThread() == initThreadId);
328 #endif
329
330     static NeverDestroyed<HashSet<AtomicString>> knownFamilies;
331     static const int maxCacheSize = 128;
332     ASSERT(knownFamilies.get().size() <= maxCacheSize);
333     if (knownFamilies.get().size() == maxCacheSize)
334         knownFamilies.get().remove(knownFamilies.get().begin());
335
336     // Only attempt to auto-activate fonts once for performance reasons.
337     return knownFamilies.get().add(family).isNewEntry;
338 }
339
340 RefPtr<SimpleFontData> FontCache::systemFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, bool isPlatformFont, const UChar* characters, int length)
341 {
342     UChar32 character;
343     U16_GET(characters, 0, 0, length, character);
344     const FontPlatformData& platformData = originalFontData->platformData();
345     NSFont *nsFont = platformData.nsFont();
346
347     NSString *string = [[NSString alloc] initWithCharactersNoCopy:const_cast<UChar*>(characters) length:length freeWhenDone:NO];
348     NSFont *substituteFont = [NSFont findFontLike:nsFont forString:string withRange:NSMakeRange(0, [string length]) inLanguage:nil];
349     [string release];
350
351     if (!substituteFont && length == 1)
352         substituteFont = [NSFont findFontLike:nsFont forCharacter:characters[0] inLanguage:nil];
353     if (!substituteFont)
354         return 0;
355
356     // Use the family name from the AppKit-supplied substitute font, requesting the
357     // traits, weight, and size we want. One way this does better than the original
358     // AppKit request is that it takes synthetic bold and oblique into account.
359     // But it does create the possibility that we could end up with a font that
360     // doesn't actually cover the characters we need.
361
362     NSFontManager *fontManager = [NSFontManager sharedFontManager];
363
364     NSFontTraitMask traits = 0;
365     NSInteger weight;
366     CGFloat size;
367
368     if (nsFont) {
369         if (description.italic())
370             traits = [fontManager traitsOfFont:nsFont];
371         if (platformData.m_syntheticBold)
372             traits |= NSBoldFontMask;
373         if (platformData.m_syntheticOblique)
374             traits |= NSFontItalicTrait;
375         weight = [fontManager weightOfFont:nsFont];
376         size = [nsFont pointSize];
377     } else {
378         // For custom fonts nsFont is nil.
379         traits = description.italic() ? NSFontItalicTrait : 0;
380         weight = toAppKitFontWeight(description.weight());
381         size = description.computedPixelSize();
382     }
383
384     NSFontTraitMask substituteFontTraits = [fontManager traitsOfFont:substituteFont];
385     NSInteger substituteFontWeight = [fontManager weightOfFont:substituteFont];
386
387     if (traits != substituteFontTraits || weight != substituteFontWeight || !nsFont) {
388         if (NSFont *bestVariation = [fontManager fontWithFamily:[substituteFont familyName] traits:traits weight:weight size:size]) {
389             if (!nsFont || (([fontManager traitsOfFont:bestVariation] != substituteFontTraits || [fontManager weightOfFont:bestVariation] != substituteFontWeight)
390                 && [[bestVariation coveredCharacterSet] longCharacterIsMember:character]))
391                 substituteFont = bestVariation;
392         }
393     }
394
395     substituteFont = description.usePrinterFont() ? [substituteFont printerFont] : [substituteFont screenFont];
396
397     substituteFontTraits = [fontManager traitsOfFont:substituteFont];
398     substituteFontWeight = [fontManager weightOfFont:substituteFont];
399
400     FontPlatformData alternateFont(substituteFont, platformData.size(), platformData.isPrinterFont(),
401         !isPlatformFont && isAppKitFontWeightBold(weight) && !isAppKitFontWeightBold(substituteFontWeight),
402         !isPlatformFont && (traits & NSFontItalicTrait) && !(substituteFontTraits & NSFontItalicTrait),
403         platformData.m_orientation);
404
405     return fontForPlatformData(alternateFont);
406 }
407
408 RefPtr<SimpleFontData> FontCache::similarFontPlatformData(const FontDescription& description)
409 {
410     // Attempt to find an appropriate font using a match based on 
411     // the presence of keywords in the the requested names.  For example, we'll
412     // match any name that contains "Arabic" to Geeza Pro.
413     RefPtr<SimpleFontData> simpleFontData;
414     for (unsigned i = 0; i < description.familyCount(); ++i) {
415         const AtomicString& family = description.familyAt(i);
416         if (family.isEmpty())
417             continue;
418         static String* matchWords[3] = { new String("Arabic"), new String("Pashto"), new String("Urdu") };
419         DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, geezaStr, ("Geeza Pro", AtomicString::ConstructFromLiteral));
420         for (int j = 0; j < 3 && !simpleFontData; ++j)
421             if (family.contains(*matchWords[j], false))
422                 simpleFontData = fontForFamily(description, geezaStr);
423     }
424     return simpleFontData.release();
425 }
426
427 Ref<SimpleFontData> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
428 {
429     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, timesStr, ("Times", AtomicString::ConstructFromLiteral));
430
431     // FIXME: Would be even better to somehow get the user's default font here.  For now we'll pick
432     // the default that the user would get without changing any prefs.
433     RefPtr<SimpleFontData> simpleFontData = fontForFamily(fontDescription, timesStr, false);
434     if (simpleFontData)
435         return *simpleFontData;
436
437     // The Times fallback will almost always work, but in the highly unusual case where
438     // the user doesn't have it, we fall back on Lucida Grande because that's
439     // guaranteed to be there, according to Nathan Taylor. This is good enough
440     // to avoid a crash at least.
441     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, lucidaGrandeStr, ("Lucida Grande", AtomicString::ConstructFromLiteral));
442     return *fontForFamily(fontDescription, lucidaGrandeStr, false);
443 }
444
445 void FontCache::getTraitsInFamily(const AtomicString& familyName, Vector<unsigned>& traitsMasks)
446 {
447     NSFontManager *fontManager = [NSFontManager sharedFontManager];
448
449     NSString *availableFamily;
450     for (availableFamily in [fontManager availableFontFamilies]) {
451         if ([familyName caseInsensitiveCompare:availableFamily] == NSOrderedSame)
452             break;
453     }
454
455     if (!availableFamily) {
456         // Match by PostScript name.
457         for (NSString *availableFont in [fontManager availableFonts]) {
458             if ([familyName caseInsensitiveCompare:availableFont] == NSOrderedSame) {
459                 NSFont *font = [NSFont fontWithName:availableFont size:10];
460                 NSInteger weight = [fontManager weightOfFont:font];
461                 traitsMasks.append(toTraitsMask([fontManager traitsOfFont:font], weight));
462                 break;
463             }
464         }
465         return;
466     }
467
468     NSArray *fonts = [fontManager availableMembersOfFontFamily:availableFamily];
469     traitsMasks.reserveCapacity([fonts count]);
470     for (NSArray *fontInfo in fonts) {
471         // Array indices must be hard coded because of lame AppKit API.
472         NSInteger fontWeight = [[fontInfo objectAtIndex:2] intValue];
473         NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
474         traitsMasks.uncheckedAppend(toTraitsMask(fontTraits, fontWeight));
475     }
476 }
477
478 std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
479 {
480     NSFontTraitMask traits = fontDescription.italic() ? NSFontItalicTrait : 0;
481     NSInteger weight = toAppKitFontWeight(fontDescription.weight());
482     float size = fontDescription.computedPixelSize();
483
484     NSFont *nsFont = fontWithFamily(family, traits, weight, size);
485     if (!nsFont) {
486         if (!shouldAutoActivateFontIfNeeded(family))
487             return nullptr;
488
489         // Auto activate the font before looking for it a second time.
490         // Ignore the result because we want to use our own algorithm to actually find the font.
491         [NSFont fontWithName:family size:size];
492
493         nsFont = fontWithFamily(family, traits, weight, size);
494         if (!nsFont)
495             return nullptr;
496     }
497
498     NSFontManager *fontManager = [NSFontManager sharedFontManager];
499     NSFontTraitMask actualTraits = 0;
500     if (fontDescription.italic())
501         actualTraits = [fontManager traitsOfFont:nsFont];
502     NSInteger actualWeight = [fontManager weightOfFont:nsFont];
503
504     NSFont *platformFont = fontDescription.usePrinterFont() ? [nsFont printerFont] : [nsFont screenFont];
505     bool syntheticBold = isAppKitFontWeightBold(weight) && !isAppKitFontWeightBold(actualWeight);
506     bool syntheticOblique = (traits & NSFontItalicTrait) && !(actualTraits & NSFontItalicTrait);
507
508     return std::make_unique<FontPlatformData>(platformFont, size, fontDescription.usePrinterFont(), syntheticBold, syntheticOblique, fontDescription.orientation(), fontDescription.widthVariant());
509 }
510
511 } // namespace WebCore
512
513 #endif // !PLATFORM(IOS)