Source/WebCore/platform/graphics/ios/FontCacheIOS.mm

   1 /*
   2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   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  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #import "config.h"
  30 #import "FontCache.h"
  31
  32 #import "CoreGraphicsSPI.h"
  33 #import "CoreTextSPI.h"
  34 #import "Font.h"
  35 #import "RenderThemeIOS.h"
  36 #import <wtf/NeverDestroyed.h>
  37 #import <wtf/RetainPtr.h>
  38 #import <wtf/text/CString.h>
  39
  40 namespace WebCore {
  41
  42 void FontCache::platformInit()
  43 {
  44 }
  45
  46 static inline bool isFontWeightBold(NSInteger fontWeight)
  47 {
  48     return fontWeight >= FontWeight600;
  49 }
  50
  51 static inline bool requiresCustomFallbackFont(const UInt32 character)
  52 {
  53     return character == AppleLogo || character == blackCircle || character == narrowNonBreakingSpace;
  54 }
  55
  56 static CFCharacterSetRef copyFontCharacterSet(CFStringRef fontName)
  57 {
  58     // The size, 10, is arbitrary.
  59     RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontDescriptorCreateWithNameAndSize(fontName, 10));
  60     RetainPtr<CTFontRef> font = adoptCF(CTFontCreateWithFontDescriptor(fontDescriptor.get(), 10, nullptr));
  61     return (CFCharacterSetRef)CTFontDescriptorCopyAttribute(fontDescriptor.get(), kCTFontCharacterSetAttribute);
  62 }
  63
  64 static CFCharacterSetRef appleColorEmojiCharacterSet()
  65 {
  66     static CFCharacterSetRef characterSet = copyFontCharacterSet(CFSTR("AppleColorEmoji"));
  67     return characterSet;
  68 }
  69
  70 static CFCharacterSetRef phoneFallbackCharacterSet()
  71 {
  72     static CFCharacterSetRef characterSet = copyFontCharacterSet(CFSTR(".PhoneFallback"));
  73     return characterSet;
  74 }
  75
  76 PassRefPtr<SimpleFontData> FontCache::getSystemFontFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, const UChar* characters, int length)
  77 {
  78     const FontPlatformData& platformData = originalFontData->platformData();
  79     CTFontRef ctFont = platformData.font();
  80
  81     CFIndex coveredLength = 0;
  82     RetainPtr<CTFontRef> substituteFont = adoptCF(CTFontCreatePhysicalFontForCharactersWithLanguage(ctFont, (const UTF16Char*)characters, (CFIndex)length, 0, &coveredLength));
  83     if (!substituteFont)
  84         return 0;
  85
  86     CTFontSymbolicTraits originalTraits = CTFontGetSymbolicTraits(ctFont);
  87     CTFontSymbolicTraits actualTraits = 0;
  88     if (isFontWeightBold(description.weight()) || description.italic())
  89         actualTraits = CTFontGetSymbolicTraits(substituteFont.get());
  90
  91     bool syntheticBold = (originalTraits & kCTFontTraitBold) && !(actualTraits & kCTFontTraitBold);
  92     bool syntheticOblique = (originalTraits & kCTFontTraitItalic) && !(actualTraits & kCTFontTraitItalic);
  93
  94     FontPlatformData alternateFont(substituteFont.get(), platformData.size(), platformData.isPrinterFont(), syntheticBold, syntheticOblique, platformData.m_orientation);
  95     alternateFont.m_isEmoji = CTFontIsAppleColorEmoji(substituteFont.get());
  96
  97     return getCachedFontData(&alternateFont, DoNotRetain);
  98 }
  99
 100 enum class LanguageSpecificFont {
 101     None,
 102     ChineseJapanese,
 103     Korean,
 104     Cyrillic,
 105     Arabic,
 106     Hebrew,
 107     Indic,
 108     Thai,
 109     Lao,
 110     Tibetan,
 111     CanadianAboriginalSyllabic,
 112     Khmer,
 113     Emoji,
 114 };
 115
 116 static LanguageSpecificFont languageSpecificFallbackFont(UChar32 c)
 117 {
 118     static bool isGB18030ComplianceRequired = wkIsGB18030ComplianceRequired();
 119
 120     // The following ranges are Korean Hangul and should be rendered by AppleSDGothicNeo
 121     // U+1100 - U+11FF
 122     // U+3130 - U+318F
 123     // U+AC00 - U+D7A3
 124
 125     // These are Cyrillic and should be rendered by Helvetica Neue
 126     // U+0400 - U+052F
 127
 128     if (c < 0x400)
 129         return LanguageSpecificFont::None;
 130     if (c < 0x530)
 131         return LanguageSpecificFont::Cyrillic;
 132     if (c < 0x590)
 133         return LanguageSpecificFont::None;
 134     if (c < 0x600)
 135         return LanguageSpecificFont::Hebrew;
 136     if (c < 0x700)
 137         return LanguageSpecificFont::Arabic;
 138     if (c < 0x900)
 139         return LanguageSpecificFont::None;
 140     if (c < 0xE00)
 141         return LanguageSpecificFont::Indic;
 142     if (c < 0xE80)
 143         return LanguageSpecificFont::Thai;
 144     if (c < 0x0F00)
 145         return LanguageSpecificFont::Lao;
 146     if (c < 0x1000)
 147         return LanguageSpecificFont::Tibetan;
 148     if (c < 0x1100)
 149         return LanguageSpecificFont::None;
 150     if (c < 0x1200)
 151         return LanguageSpecificFont::Korean;
 152     if (c < 0x1400)
 153         return LanguageSpecificFont::None;
 154     if (c < 0x1780)
 155         return LanguageSpecificFont::CanadianAboriginalSyllabic;
 156     if (c < 0x1800)
 157         return LanguageSpecificFont::Khmer;
 158     if (c < 0x2E80)
 159         return LanguageSpecificFont::None;
 160     if (c < 0x3130)
 161         return LanguageSpecificFont::ChineseJapanese;
 162     if (c < 0x3190)
 163         return LanguageSpecificFont::Korean;
 164     if (c < 0xAC00)
 165         return LanguageSpecificFont::ChineseJapanese;
 166     if (c < 0xD7A4)
 167         return LanguageSpecificFont::Korean;
 168     if (c < 0xE000)
 169         return LanguageSpecificFont::ChineseJapanese;
 170     if (c < 0xE600)
 171         return isGB18030ComplianceRequired ? LanguageSpecificFont::ChineseJapanese : LanguageSpecificFont::Emoji;
 172     if (c < 0xE865 && isGB18030ComplianceRequired)
 173         return LanguageSpecificFont::ChineseJapanese;
 174     if (c < 0xF900)
 175         return LanguageSpecificFont::None;
 176     if (c < 0xFB00)
 177         return LanguageSpecificFont::ChineseJapanese;
 178     if (c < 0xFB50)
 179         return LanguageSpecificFont::None;
 180     if (c < 0xFE00)
 181         return LanguageSpecificFont::Arabic;
 182     if (c < 0xFE20)
 183         return LanguageSpecificFont::None;
 184     if (c < 0xFE70)
 185         return LanguageSpecificFont::ChineseJapanese;
 186     if (c < 0xFF00)
 187         return LanguageSpecificFont::Arabic;
 188     if (c < 0xFFF0)
 189         return LanguageSpecificFont::ChineseJapanese;
 190     if (c < 0x20000)
 191         return LanguageSpecificFont::None;
 192     if (c < 0x30000)
 193         return LanguageSpecificFont::ChineseJapanese;
 194     return LanguageSpecificFont::None;
 195 }
 196
 197 PassRefPtr<SimpleFontData> FontCache::systemFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, bool, const UChar* characters, int length)
 198 {
 199     // Unlike OS X, our fallback font on iPhone is Arial Unicode, which doesn't have some apple-specific glyphs like F8FF.
 200     // Fall back to the Apple Fallback font in this case.
 201     if (length > 0 && requiresCustomFallbackFont(*characters))
 202         return getCachedFontData(getCustomFallbackFont(*characters, description), DoNotRetain);
 203
 204     UChar32 c = *characters;
 205     if (length > 1 && U16_IS_LEAD(c) && U16_IS_TRAIL(characters[1]))
 206         c = U16_GET_SUPPLEMENTARY(c, characters[1]);
 207
 208     // For system fonts we use CoreText fallback mechanism.
 209     if (length) {
 210         RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontCopyFontDescriptor(originalFontData->getCTFont()));
 211         if (CTFontDescriptorIsSystemUIFont(fontDescriptor.get()))
 212             return getSystemFontFallbackForCharacters(description, originalFontData, characters, length);
 213     }
 214
 215     LanguageSpecificFont languageSpecificFont = LanguageSpecificFont::None;
 216     if (length > 0)
 217         languageSpecificFont = languageSpecificFallbackFont(c);
 218
 219     RefPtr<SimpleFontData> simpleFontData;
 220
 221     switch (languageSpecificFont) {
 222     case LanguageSpecificFont::ChineseJapanese: {
 223         // By default, Chinese font is preferred, fall back on Japanese.
 224
 225         enum CJKFontVariant {
 226             kCJKFontUseHiragino = 0,
 227             kCJKFontUseSTHeitiSC,
 228             kCJKFontUseSTHeitiTC,
 229             kCJKFontUseSTHeitiJ,
 230             kCJKFontUseSTHeitiK,
 231             kCJKFontsUseHKGPW3UI
 232         };
 233
 234         static NeverDestroyed<AtomicString> plainHiragino("HiraKakuProN-W3", AtomicString::ConstructFromLiteral);
 235         static NeverDestroyed<AtomicString> plainSTHeitiSC("STHeitiSC-Light", AtomicString::ConstructFromLiteral);
 236         static NeverDestroyed<AtomicString> plainSTHeitiTC("STHeitiTC-Light", AtomicString::ConstructFromLiteral);
 237         static NeverDestroyed<AtomicString> plainSTHeitiJ("STHeitiJ-Light", AtomicString::ConstructFromLiteral);
 238         static NeverDestroyed<AtomicString> plainSTHeitiK("STHeitiK-Light", AtomicString::ConstructFromLiteral);
 239         static NeverDestroyed<AtomicString> plainHKGPW3UI("HKGPW3UI", AtomicString::ConstructFromLiteral);
 240         static AtomicString* cjkPlain[] = {
 241             &plainHiragino.get(),
 242             &plainSTHeitiSC.get(),
 243             &plainSTHeitiTC.get(),
 244             &plainSTHeitiJ.get(),
 245             &plainSTHeitiK.get(),
 246             &plainHKGPW3UI.get(),
 247         };
 248
 249         static NeverDestroyed<AtomicString> boldHiragino("HiraKakuProN-W6", AtomicString::ConstructFromLiteral);
 250         static NeverDestroyed<AtomicString> boldSTHeitiSC("STHeitiSC-Medium", AtomicString::ConstructFromLiteral);
 251         static NeverDestroyed<AtomicString> boldSTHeitiTC("STHeitiTC-Medium", AtomicString::ConstructFromLiteral);
 252         static NeverDestroyed<AtomicString> boldSTHeitiJ("STHeitiJ-Medium", AtomicString::ConstructFromLiteral);
 253         static NeverDestroyed<AtomicString> boldSTHeitiK("STHeitiK-Medium", AtomicString::ConstructFromLiteral);
 254         static NeverDestroyed<AtomicString> boldHKGPW3UI("HKGPW3UI", AtomicString::ConstructFromLiteral);
 255         static AtomicString* cjkBold[] = {
 256             &boldHiragino.get(),
 257             &boldSTHeitiSC.get(),
 258             &boldSTHeitiTC.get(),
 259             &boldSTHeitiJ.get(),
 260             &boldSTHeitiK.get(),
 261             &boldHKGPW3UI.get(),
 262         };
 263
 264         // Default below is for Simplified Chinese user: zh-Hans - note that Hiragino is the
 265         // the secondary font as we want its for Hiragana and Katakana. The other CJK fonts
 266         // do not, and should not, contain Hiragana or Katakana glyphs.
 267         static CJKFontVariant preferredCJKFont = kCJKFontUseSTHeitiSC;
 268         static CJKFontVariant secondaryCJKFont = kCJKFontsUseHKGPW3UI;
 269
 270         static bool CJKFontInitialized;
 271         if (!CJKFontInitialized) {
 272             CJKFontInitialized = true;
 273             // Testing: languageName = (CFStringRef)@"ja";
 274             NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
 275             NSArray *languages = [defaults stringArrayForKey:@"AppleLanguages"];
 276
 277             if (languages) {
 278                 for (NSString *language in languages) {
 279                     RetainPtr<CFStringRef> languageName = adoptCF(CFLocaleCreateCanonicalLanguageIdentifierFromString(nullptr, (CFStringRef)language));
 280                     if (CFEqual(languageName.get(), CFSTR("zh-Hans")))
 281                         break; // Simplified Chinese - default settings
 282                     else if (CFEqual(languageName.get(), CFSTR("ja"))) {
 283                         preferredCJKFont = kCJKFontUseHiragino; // Japanese - prefer Hiragino and STHeiti Japanse Variant
 284                         secondaryCJKFont = kCJKFontUseSTHeitiJ;
 285                         break;
 286                     } else if (CFEqual(languageName.get(), CFSTR("ko"))) {
 287                         preferredCJKFont = kCJKFontUseSTHeitiK; // Korean - prefer STHeiti Korean Variant
 288                         break;
 289                     } else if (CFEqual(languageName.get(), CFSTR("zh-Hant"))) {
 290                         preferredCJKFont = kCJKFontUseSTHeitiTC; // Traditional Chinese - prefer STHeiti Traditional Variant
 291                         break;
 292                     }
 293                 }
 294             }
 295         }
 296
 297         simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? *cjkBold[preferredCJKFont] : *cjkPlain[preferredCJKFont], false, DoNotRetain);
 298         bool useSecondaryFont = true;
 299         if (simpleFontData) {
 300             CGGlyph glyphs[2];
 301             // CGFontGetGlyphsForUnichars takes UTF-16 buffer. Should only be 1 codepoint but since we may pass in two UTF-16 characters,
 302             // make room for 2 glyphs just to be safe.
 303             CGFontGetGlyphsForUnichars(simpleFontData->platformData().cgFont(), characters, glyphs, length);
 304
 305             useSecondaryFont = (glyphs[0] == 0);
 306         }
 307
 308         if (useSecondaryFont)
 309             simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? *cjkBold[secondaryCJKFont] : *cjkPlain[secondaryCJKFont], false, DoNotRetain);
 310         break;
 311     }
 312     case LanguageSpecificFont::Korean: {
 313         static NeverDestroyed<AtomicString> koreanPlain("AppleSDGothicNeo-Medium", AtomicString::ConstructFromLiteral);
 314         static NeverDestroyed<AtomicString> koreanBold("AppleSDGothicNeo-Bold", AtomicString::ConstructFromLiteral);
 315         simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? koreanBold : koreanPlain, false, DoNotRetain);
 316         break;
 317     }
 318     case LanguageSpecificFont::Cyrillic: {
 319         static NeverDestroyed<AtomicString> cyrillicPlain("HelveticaNeue", AtomicString::ConstructFromLiteral);
 320         static NeverDestroyed<AtomicString> cyrillicBold("HelveticaNeue-Bold", AtomicString::ConstructFromLiteral);
 321         simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? cyrillicBold : cyrillicPlain, false, DoNotRetain);
 322         break;
 323     }
 324     case LanguageSpecificFont::Arabic: {
 325         static NeverDestroyed<AtomicString> arabicPlain("GeezaPro", AtomicString::ConstructFromLiteral);
 326         static NeverDestroyed<AtomicString> arabicBold("GeezaPro-Bold", AtomicString::ConstructFromLiteral);
 327         simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? arabicBold : arabicPlain, false, DoNotRetain);
 328         break;
 329     }
 330     case LanguageSpecificFont::Hebrew: {
 331         static NeverDestroyed<AtomicString> hebrewPlain("ArialHebrew", AtomicString::ConstructFromLiteral);
 332         static NeverDestroyed<AtomicString> hebrewBold("ArialHebrew-Bold", AtomicString::ConstructFromLiteral);
 333         simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? hebrewBold : hebrewPlain, false, DoNotRetain);
 334         break;
 335     }
 336     case LanguageSpecificFont::Indic: {
 337         static NeverDestroyed<AtomicString> devanagariFont("KohinoorDevanagari-Book", AtomicString::ConstructFromLiteral);
 338         static NeverDestroyed<AtomicString> bengaliFont("BanglaSangamMN", AtomicString::ConstructFromLiteral);
 339         static NeverDestroyed<AtomicString> gurmukhiFont("GurmukhiMN", AtomicString::ConstructFromLiteral); // Might be replaced in a future release with a Sangam version.
 340         static NeverDestroyed<AtomicString> gujaratiFont("GujaratiSangamMN", AtomicString::ConstructFromLiteral);
 341         static NeverDestroyed<AtomicString> oriyaFont("OriyaSangamMN", AtomicString::ConstructFromLiteral);
 342         static NeverDestroyed<AtomicString> tamilFont("TamilSangamMN", AtomicString::ConstructFromLiteral);
 343         static NeverDestroyed<AtomicString> teluguFont("TeluguSangamMN", AtomicString::ConstructFromLiteral);
 344         static NeverDestroyed<AtomicString> kannadaFont("KannadaSangamMN", AtomicString::ConstructFromLiteral);
 345         static NeverDestroyed<AtomicString> malayalamFont("MalayalamSangamMN", AtomicString::ConstructFromLiteral);
 346         static NeverDestroyed<AtomicString> sinhalaFont("SinhalaSangamMN", AtomicString::ConstructFromLiteral);
 347
 348         static NeverDestroyed<AtomicString> devanagariFontBold("KohinoorDevanagari-Medium", AtomicString::ConstructFromLiteral);
 349         static NeverDestroyed<AtomicString> bengaliFontBold("BanglaSangamMN-Bold", AtomicString::ConstructFromLiteral);
 350         static NeverDestroyed<AtomicString> gurmukhiFontBold("GurmukhiMN-Bold", AtomicString::ConstructFromLiteral); // Might be replaced in a future release with a Sangam version.
 351         static NeverDestroyed<AtomicString> gujaratiFontBold("GujaratiSangamMN-Bold", AtomicString::ConstructFromLiteral);
 352         static NeverDestroyed<AtomicString> oriyaFontBold("OriyaSangamMN-Bold", AtomicString::ConstructFromLiteral);
 353         static NeverDestroyed<AtomicString> tamilFontBold("TamilSangamMN-Bold", AtomicString::ConstructFromLiteral);
 354         static NeverDestroyed<AtomicString> teluguFontBold("TeluguSangamMN-Bold", AtomicString::ConstructFromLiteral);
 355         static NeverDestroyed<AtomicString> kannadaFontBold("KannadaSangamMN-Bold", AtomicString::ConstructFromLiteral);
 356         static NeverDestroyed<AtomicString> malayalamFontBold("MalayalamSangamMN-Bold", AtomicString::ConstructFromLiteral);
 357         static NeverDestroyed<AtomicString> sinhalaFontBold("SinhalaSangamMN-Bold", AtomicString::ConstructFromLiteral);
 358
 359         static AtomicString* indicUnicodePageFonts[] = {
 360             &devanagariFont.get(),
 361             &bengaliFont.get(),
 362             &gurmukhiFont.get(),
 363             &gujaratiFont.get(),
 364             &oriyaFont.get(),
 365             &tamilFont.get(),
 366             &teluguFont.get(),
 367             &kannadaFont.get(),
 368             &malayalamFont.get(),
 369             &sinhalaFont.get()
 370         };
 371
 372         static AtomicString* indicUnicodePageFontsBold[] = {
 373             &devanagariFontBold.get(),
 374             &bengaliFontBold.get(),
 375             &gurmukhiFontBold.get(),
 376             &gujaratiFontBold.get(),
 377             &oriyaFontBold.get(),
 378             &tamilFontBold.get(),
 379             &teluguFontBold.get(),
 380             &kannadaFontBold.get(),
 381             &malayalamFontBold.get(),
 382             &sinhalaFontBold.get()
 383         };
 384
 385         uint32_t indicPageOrderIndex = (c - 0x0900) / 0x0080; // Indic scripts start at 0x0900 in Unicode. Each script is allocalted a block of 0x80 characters.
 386         if (indicPageOrderIndex < (sizeof(indicUnicodePageFonts) / sizeof(AtomicString*))) {
 387             AtomicString* indicFontString = isFontWeightBold(description.weight()) ? indicUnicodePageFontsBold[indicPageOrderIndex] : indicUnicodePageFonts[indicPageOrderIndex];
 388             if (indicFontString)
 389                 simpleFontData = getCachedFontData(description, *indicFontString, false, DoNotRetain);
 390         }
 391         break;
 392     }
 393     case LanguageSpecificFont::Thai: {
 394         static NeverDestroyed<AtomicString> thaiPlain("Thonburi", AtomicString::ConstructFromLiteral);
 395         static NeverDestroyed<AtomicString> thaiBold("Thonburi-Bold", AtomicString::ConstructFromLiteral);
 396         simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? thaiBold : thaiPlain, false, DoNotRetain);
 397         break;
 398     }
 399     case LanguageSpecificFont::Tibetan: {
 400         static NeverDestroyed<AtomicString> tibetanPlain("Kailasa", AtomicString::ConstructFromLiteral);
 401         static NeverDestroyed<AtomicString> tibetanBold("Kailasa-Bold", AtomicString::ConstructFromLiteral);
 402         simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? tibetanBold : tibetanPlain, false, DoNotRetain);
 403         break;
 404     }
 405     case LanguageSpecificFont::CanadianAboriginalSyllabic: {
 406         static NeverDestroyed<AtomicString> casPlain("EuphemiaUCAS", AtomicString::ConstructFromLiteral);
 407         static NeverDestroyed<AtomicString> casBold("EuphemiaUCAS-Bold", AtomicString::ConstructFromLiteral);
 408         simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? casBold : casPlain, false, DoNotRetain);
 409         break;
 410     }
 411     case LanguageSpecificFont::Khmer: {
 412         static NeverDestroyed<AtomicString> khmer("KhmerSangamMN", AtomicString::ConstructFromLiteral);
 413         simpleFontData = getCachedFontData(description, khmer, false, DoNotRetain);
 414         break;
 415     }
 416     case LanguageSpecificFont::Lao: {
 417         static NeverDestroyed<AtomicString> lao("LaoSangamMN", AtomicString::ConstructFromLiteral);
 418         simpleFontData = getCachedFontData(description, lao, false, DoNotRetain);
 419         break;
 420     }
 421     default: {
 422         static NeverDestroyed<AtomicString> appleColorEmoji("AppleColorEmoji", AtomicString::ConstructFromLiteral);
 423         bool useEmojiFont = languageSpecificFont == LanguageSpecificFont::Emoji;
 424         if (!useEmojiFont) {
 425             if (!CFCharacterSetIsLongCharacterMember(phoneFallbackCharacterSet(), c))
 426                 useEmojiFont = CFCharacterSetIsLongCharacterMember(appleColorEmojiCharacterSet(), c);
 427         }
 428         if (useEmojiFont)
 429             simpleFontData = getCachedFontData(description, appleColorEmoji, false, DoNotRetain);
 430         else {
 431             RetainPtr<CTFontRef> fallbackFont = adoptCF(CTFontCreateForCharacters(originalFontData->getCTFont(), characters, length, nullptr));
 432             if (RetainPtr<CFStringRef> foundFontName = adoptCF(CTFontCopyPostScriptName(fallbackFont.get())))
 433                 simpleFontData = getCachedFontData(description, foundFontName.get(), false, DoNotRetain);
 434         }
 435         break;
 436     }
 437     }
 438
 439     if (simpleFontData)
 440         return simpleFontData.release();
 441
 442     return getNonRetainedLastResortFallbackFont(description);
 443 }
 444
 445 PassRefPtr<SimpleFontData> FontCache::similarFontPlatformData(const FontDescription& description)
 446 {
 447     // Attempt to find an appropriate font using a match based on the presence of keywords in
 448     // the requested names. For example, we'll match any name that contains "Arabic" to Geeza Pro.
 449     RefPtr<SimpleFontData> simpleFontData;
 450     for (unsigned i = 0; i < description.familyCount(); ++i) {
 451         const AtomicString& family = description.familyAt(i);
 452         if (family.isEmpty())
 453             continue;
 454
 455         // Substitute the default monospace font for well-known monospace fonts.
 456         static NeverDestroyed<AtomicString> monaco("monaco", AtomicString::ConstructFromLiteral);
 457         static NeverDestroyed<AtomicString> menlo("menlo", AtomicString::ConstructFromLiteral);
 458         static NeverDestroyed<AtomicString> courier("courier", AtomicString::ConstructFromLiteral);
 459         if (equalIgnoringCase(family, monaco) || equalIgnoringCase(family, menlo)) {
 460             simpleFontData = getCachedFontData(description, courier);
 461             continue;
 462         }
 463
 464         // Substitute Verdana for Lucida Grande.
 465         static NeverDestroyed<AtomicString> lucidaGrande("lucida grande", AtomicString::ConstructFromLiteral);
 466         static NeverDestroyed<AtomicString> verdana("verdana", AtomicString::ConstructFromLiteral);
 467         if (equalIgnoringCase(family, lucidaGrande)) {
 468             simpleFontData = getCachedFontData(description, verdana);
 469             continue;
 470         }
 471
 472         static NeverDestroyed<String> arabic(ASCIILiteral("Arabic"));
 473         static NeverDestroyed<String> pashto(ASCIILiteral("Pashto"));
 474         static NeverDestroyed<String> urdu(ASCIILiteral("Urdu"));
 475         static String* matchWords[3] = { &arabic.get(), &pashto.get(), &urdu.get() };
 476         static NeverDestroyed<AtomicString> geezaPlain("GeezaPro", AtomicString::ConstructFromLiteral);
 477         static NeverDestroyed<AtomicString> geezaBold("GeezaPro-Bold", AtomicString::ConstructFromLiteral);
 478         for (int j = 0; j < 3 && !simpleFontData; ++j)
 479             if (family.contains(*matchWords[j], false))
 480                 simpleFontData = getCachedFontData(description, isFontWeightBold(description.weight()) ? geezaBold : geezaPlain);
 481     }
 482
 483     return simpleFontData.release();
 484 }
 485
 486 PassRefPtr<SimpleFontData> FontCache::getLastResortFallbackFont(const FontDescription& fontDescription, ShouldRetain shouldRetain)
 487 {
 488     static NeverDestroyed<AtomicString> fallbackFontFamily(".PhoneFallback", AtomicString::ConstructFromLiteral);
 489     return getCachedFontData(fontDescription, fallbackFontFamily, false, shouldRetain);
 490 }
 491
 492 FontPlatformData* FontCache::getCustomFallbackFont(const UInt32 c, const FontDescription& description)
 493 {
 494     ASSERT(requiresCustomFallbackFont(c));
 495
 496     static NeverDestroyed<AtomicString> helveticaFamily("Helvetica Neue", AtomicString::ConstructFromLiteral);
 497     static NeverDestroyed<AtomicString> lockClockFamily("LockClock-Light", AtomicString::ConstructFromLiteral);
 498     static NeverDestroyed<AtomicString> timesNewRomanPSMTFamily("TimesNewRomanPSMT", AtomicString::ConstructFromLiteral);
 499
 500     AtomicString* family = nullptr;
 501     switch (c) {
 502     case AppleLogo:
 503         family = &helveticaFamily.get();
 504         break;
 505     case blackCircle:
 506         family = &lockClockFamily.get();
 507         break;
 508     case narrowNonBreakingSpace:
 509         family = &timesNewRomanPSMTFamily.get();
 510         break;
 511     default:
 512         ASSERT_NOT_REACHED();
 513         return nullptr;
 514     }
 515     ASSERT(family);
 516     if (!family)
 517         return nullptr;
 518     return getCachedFontPlatformData(description, *family);
 519 }
 520
 521 static inline FontTraitsMask toTraitsMask(CTFontSymbolicTraits ctFontTraits)
 522 {
 523     return static_cast<FontTraitsMask>(((ctFontTraits & kCTFontTraitItalic) ? FontStyleItalicMask : FontStyleNormalMask)
 524         | FontVariantNormalMask
 525         // FontWeight600 or higher is bold for CTFonts, so choose middle values for
 526         // bold (600-900) and non-bold (100-500)
 527         | ((ctFontTraits & kCTFontTraitBold) ? FontWeight700Mask : FontWeight300Mask));
 528 }
 529
 530 void FontCache::getTraitsInFamily(const AtomicString& familyName, Vector<unsigned>& traitsMasks)
 531 {
 532     RetainPtr<CFStringRef> familyNameStr = familyName.string().createCFString();
 533     NSDictionary *attributes = @{ (id)kCTFontFamilyNameAttribute: (NSString*)familyNameStr.get() };
 534     RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontDescriptorCreateWithAttributes((CFDictionaryRef)attributes));
 535     RetainPtr<NSArray> matchedDescriptors = adoptNS((NSArray *)CTFontDescriptorCreateMatchingFontDescriptors(fontDescriptor.get(), nullptr));
 536
 537     NSInteger numMatches = [matchedDescriptors.get() count];
 538     if (!matchedDescriptors || !numMatches)
 539         return;
 540
 541     for (NSInteger i = 0; i < numMatches; ++i) {
 542         RetainPtr<CFDictionaryRef> traits = adoptCF((CFDictionaryRef)CTFontDescriptorCopyAttribute((CTFontDescriptorRef)[matchedDescriptors.get() objectAtIndex:i], kCTFontTraitsAttribute));
 543         CFNumberRef resultRef = (CFNumberRef)CFDictionaryGetValue(traits.get(), kCTFontSymbolicTrait);
 544         if (resultRef) {
 545             CTFontSymbolicTraits symbolicTraits;
 546             CFNumberGetValue(resultRef, kCFNumberIntType, &symbolicTraits);
 547             traitsMasks.append(toTraitsMask(symbolicTraits));
 548         }
 549     }
 550 }
 551
 552 float FontCache::weightOfCTFont(CTFontRef font)
 553 {
 554     float result = 0;
 555     RetainPtr<CFDictionaryRef> traits = adoptCF(CTFontCopyTraits(font));
 556     if (!traits)
 557         return result;
 558
 559     CFNumberRef resultRef = (CFNumberRef)CFDictionaryGetValue(traits.get(), kCTFontWeightTrait);
 560     if (resultRef)
 561         CFNumberGetValue(resultRef, kCFNumberFloatType, &result);
 562
 563     return result;
 564 }
 565
 566 static CTFontRef createCTFontWithTextStyle(const String& familyName, CTFontSymbolicTraits traits, CGFloat size)
 567 {
 568     if (familyName.isNull())
 569         return nullptr;
 570
 571     CTFontSymbolicTraits symbolicTraits = 0;
 572     if (traits & kCTFontBoldTrait)
 573         symbolicTraits |= kCTFontBoldTrait;
 574     if (traits & kCTFontTraitItalic)
 575         symbolicTraits |= kCTFontTraitItalic;
 576     RetainPtr<CFStringRef> familyNameStr = familyName.createCFString();
 577     RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontDescriptorCreateWithTextStyle(familyNameStr.get(), RenderThemeIOS::contentSizeCategory(), nullptr));
 578     if (symbolicTraits)
 579         fontDescriptor = adoptCF(CTFontDescriptorCreateCopyWithSymbolicTraits(fontDescriptor.get(), symbolicTraits, symbolicTraits));
 580
 581     return CTFontCreateWithFontDescriptor(fontDescriptor.get(), size, nullptr);
 582 }
 583
 584 static CTFontRef createCTFontWithFamilyNameAndWeight(const String& familyName, CTFontSymbolicTraits traits, float size, uint16_t weight)
 585 {
 586     if (familyName.isNull())
 587         return nullptr;
 588
 589     static NeverDestroyed<AtomicString> systemUIFontWithWebKitPrefix("-webkit-system-font", AtomicString::ConstructFromLiteral);
 590     static NeverDestroyed<AtomicString> systemUIFontWithApplePrefix("-apple-system-font", AtomicString::ConstructFromLiteral);
 591     if (equalIgnoringCase(familyName, systemUIFontWithWebKitPrefix) || equalIgnoringCase(familyName, systemUIFontWithApplePrefix)) {
 592         CTFontUIFontType fontType = kCTFontUIFontSystem;
 593         if (weight > 300) {
 594             // The comment below has been copied from CoreText/UIFoundation. However, in WebKit we synthesize the oblique,
 595             // so we should investigate the result <rdar://problem/14449340>:
 596             // We don't do bold-italic for system fonts. If you ask for it, we'll assume that you're just kidding and that you really want bold. This is a feature.
 597             if (traits & kCTFontTraitBold)
 598                 fontType = kCTFontUIFontEmphasizedSystem;
 599             else if (traits & kCTFontTraitItalic)
 600                 fontType = static_cast<CTFontUIFontType>(kCTFontUIFontSystemItalic);
 601         } else if (weight > 250)
 602             fontType = static_cast<CTFontUIFontType>(kCTFontUIFontSystemLight);
 603         else if (weight > 150)
 604             fontType = static_cast<CTFontUIFontType>(kCTFontUIFontSystemThin);
 605         else
 606             fontType = static_cast<CTFontUIFontType>(kCTFontUIFontSystemUltraLight);
 607         RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontDescriptorCreateForUIType(fontType, size, nullptr));
 608         return CTFontCreateWithFontDescriptor(fontDescriptor.get(), size, nullptr);
 609     }
 610
 611     RetainPtr<CFStringRef> familyNameStr = familyName.createCFString();
 612     CTFontSymbolicTraits requestedTraits = (CTFontSymbolicTraits)(traits & (kCTFontBoldTrait | kCTFontItalicTrait));
 613     return CTFontCreateForCSS(familyNameStr.get(), weight, requestedTraits, size);
 614 }
 615
 616 static uint16_t toCTFontWeight(FontWeight fontWeight)
 617 {
 618     switch (fontWeight) {
 619     case FontWeight100:
 620         return 100;
 621     case FontWeight200:
 622         return 200;
 623     case FontWeight300:
 624         return 300;
 625     case FontWeight400:
 626         return 400;
 627     case FontWeight500:
 628         return 500;
 629     case FontWeight600:
 630         return 600;
 631     case FontWeight700:
 632         return 700;
 633     case FontWeight800:
 634         return 800;
 635     case FontWeight900:
 636         return 900;
 637     default:
 638         return 400;
 639     }
 640 }
 641
 642 std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
 643 {
 644     // Special case for "Courier" font. We used to have only an oblique variant on iOS, so prior to
 645     // iOS 6.0, we disallowed its use here. We'll fall back on "Courier New". <rdar://problem/5116477&10850227>
 646     static NeverDestroyed<AtomicString> courier("Courier", AtomicString::ConstructFromLiteral);
 647     static bool shouldDisallowCourier = !iosExecutableWasLinkedOnOrAfterVersion(wkIOSSystemVersion_6_0);
 648     if (shouldDisallowCourier && equalIgnoringCase(family, courier))
 649         return nullptr;
 650
 651     CTFontSymbolicTraits traits = 0;
 652     if (fontDescription.italic())
 653         traits |= kCTFontTraitItalic;
 654     if (isFontWeightBold(fontDescription.weight()))
 655         traits |= kCTFontTraitBold;
 656     float size = fontDescription.computedPixelSize();
 657
 658     RetainPtr<CTFontRef> ctFont;
 659     if (family.startsWith("UICTFontTextStyle"))
 660         ctFont = adoptCF(createCTFontWithTextStyle(family, traits, size));
 661     else
 662         ctFont = adoptCF(createCTFontWithFamilyNameAndWeight(family, traits, size, toCTFontWeight(fontDescription.weight())));
 663     if (!ctFont)
 664         return nullptr;
 665
 666     CTFontSymbolicTraits actualTraits = 0;
 667     if (isFontWeightBold(fontDescription.weight()) || fontDescription.italic())
 668         actualTraits = CTFontGetSymbolicTraits(ctFont.get());
 669
 670     bool isAppleColorEmoji = CTFontIsAppleColorEmoji(ctFont.get());
 671
 672     bool syntheticBold = (traits & kCTFontTraitBold) && !(actualTraits & kCTFontTraitBold) && !isAppleColorEmoji;
 673     bool syntheticOblique = (traits & kCTFontTraitItalic) && !(actualTraits & kCTFontTraitItalic) && !isAppleColorEmoji;
 674
 675     auto result = std::make_unique<FontPlatformData>(ctFont.get(), size, fontDescription.usePrinterFont(), syntheticBold, syntheticOblique, fontDescription.orientation(), fontDescription.widthVariant());
 676     if (isAppleColorEmoji)
 677         result->m_isEmoji = true;
 678     return result;
 679 }
 680
 681 } // namespace WebCore