527e3b659a00636de2135bdc3503b5e36e26cbcf
[WebKit-https.git] / Source / WebCore / platform / graphics / win / FontCacheWin.cpp
1 /*
2  * Copyright (C) 2006-2008, 2013-2014 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 #include "config.h"
30 #include <winsock2.h>
31 #include "Font.h"
32 #include "FontCache.h"
33 #include "HWndDC.h"
34 #include <mlang.h>
35 #include <windows.h>
36 #include <wtf/HashSet.h>
37 #include <wtf/NeverDestroyed.h>
38 #include <wtf/StdLibExtras.h>
39 #include <wtf/text/CString.h>
40 #include <wtf/text/StringHash.h>
41 #include <wtf/text/StringView.h>
42 #include <wtf/win/GDIObject.h>
43
44 #if USE(CG)
45 #include <ApplicationServices/ApplicationServices.h>
46 #include <WebKitSystemInterface/WebKitSystemInterface.h>
47 #include <pal/spi/cg/CoreGraphicsSPI.h>
48 #endif
49
50 #if USE(DIRECT2D)
51 #include <dwrite.h>
52 #endif
53
54 using std::min;
55
56 namespace WebCore
57 {
58
59 void FontCache::platformInit()
60 {
61 #if USE(CG)
62     // Turn on CG's local font cache.
63     size_t size = 1536 * 1024 * 4; // This size matches Mac.
64     CGFontSetShouldUseMulticache(true);
65     CGFontCache* fontCache = CGFontCacheGetLocalCache();
66     CGFontCacheSetShouldAutoExpire(fontCache, false);
67     CGFontCacheSetMaxSize(fontCache, size);
68 #endif
69 }
70
71 IMLangFontLinkType* FontCache::getFontLinkInterface()
72 {
73     static IMultiLanguage *multiLanguage;
74     if (!multiLanguage) {
75         if (CoCreateInstance(CLSID_CMultiLanguage, 0, CLSCTX_ALL, IID_IMultiLanguage, (void**)&multiLanguage) != S_OK)
76             return 0;
77     }
78
79     static IMLangFontLinkType* langFontLink;
80     if (!langFontLink) {
81         if (multiLanguage->QueryInterface(&langFontLink) != S_OK)
82             return 0;
83     }
84
85     return langFontLink;
86 }
87
88 static int CALLBACK metaFileEnumProc(HDC hdc, HANDLETABLE* table, CONST ENHMETARECORD* record, int tableEntries, LPARAM logFont)
89 {
90     if (record->iType == EMR_EXTCREATEFONTINDIRECTW) {
91         const EMREXTCREATEFONTINDIRECTW* createFontRecord = reinterpret_cast<const EMREXTCREATEFONTINDIRECTW*>(record);
92         *reinterpret_cast<LOGFONT*>(logFont) = createFontRecord->elfw.elfLogFont;
93     }
94     return true;
95 }
96
97 static int CALLBACK linkedFontEnumProc(CONST LOGFONT* logFont, CONST TEXTMETRIC* metrics, DWORD fontType, LPARAM hfont)
98 {
99     *reinterpret_cast<HFONT*>(hfont) = CreateFontIndirect(logFont);
100     return false;
101 }
102
103 WEBCORE_EXPORT void appendLinkedFonts(WCHAR* linkedFonts, unsigned length, Vector<String>* result)
104 {
105     unsigned i = 0;
106     while (i < length) {
107         while (i < length && linkedFonts[i] != ',')
108             i++;
109         // Break if we did not find a comma.
110         if (i == length)
111             break;
112         i++;
113         unsigned j = i;
114         while (j < length && linkedFonts[j])
115             j++;
116         result->append(String(linkedFonts + i, j - i));
117         i = j + 1;
118     }
119 }
120
121 static const Vector<String>* getLinkedFonts(String& family)
122 {
123     static HashMap<String, Vector<String>*> systemLinkMap;
124     Vector<String>* result = systemLinkMap.get(family);
125     if (result)
126         return result;
127
128     result = new Vector<String>;
129     systemLinkMap.set(family, result);
130     HKEY fontLinkKey = nullptr;
131     if (::RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\FontLink\\SystemLink", 0, KEY_READ, &fontLinkKey) != ERROR_SUCCESS)
132         return result;
133
134     DWORD linkedFontsBufferSize = 0;
135     if (::RegQueryValueEx(fontLinkKey, family.charactersWithNullTermination().data(), 0, nullptr, nullptr, &linkedFontsBufferSize) == ERROR_FILE_NOT_FOUND) {
136         WTFLogAlways("The font link key %s does not exist in the registry.", family.utf8().data());
137         return result;
138     }
139
140     static const constexpr unsigned InitialBufferSize { 256 / sizeof(WCHAR) };
141     Vector<WCHAR, InitialBufferSize> linkedFonts(roundUpToMultipleOf<sizeof(WCHAR)>(linkedFontsBufferSize) / sizeof(WCHAR));
142     if (::RegQueryValueEx(fontLinkKey, family.charactersWithNullTermination().data(), 0, nullptr, reinterpret_cast<BYTE*>(linkedFonts.data()), &linkedFontsBufferSize) == ERROR_SUCCESS) {
143         unsigned length = linkedFontsBufferSize / sizeof(WCHAR);
144         appendLinkedFonts(linkedFonts.data(), length, result);
145     }
146     RegCloseKey(fontLinkKey);
147     return result;
148 }
149
150 static const Vector<DWORD, 4>& getCJKCodePageMasks()
151 {
152     // The default order in which we look for a font for a CJK character. If the user's default code page is
153     // one of these, we will use it first.
154     static const UINT CJKCodePages[] = { 
155         932, /* Japanese */
156         936, /* Simplified Chinese */
157         950, /* Traditional Chinese */
158         949  /* Korean */
159     };
160
161     static Vector<DWORD, 4> codePageMasks;
162     static bool initialized;
163     if (!initialized) {
164         initialized = true;
165         IMLangFontLinkType* langFontLink = FontCache::singleton().getFontLinkInterface();
166         if (!langFontLink)
167             return codePageMasks;
168
169         UINT defaultCodePage;
170         DWORD defaultCodePageMask = 0;
171         if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_RETURN_NUMBER | LOCALE_IDEFAULTANSICODEPAGE, reinterpret_cast<LPWSTR>(&defaultCodePage), sizeof(defaultCodePage)))
172             langFontLink->CodePageToCodePages(defaultCodePage, &defaultCodePageMask);
173
174         if (defaultCodePage == CJKCodePages[0] || defaultCodePage == CJKCodePages[1] || defaultCodePage == CJKCodePages[2] || defaultCodePage == CJKCodePages[3])
175             codePageMasks.append(defaultCodePageMask);
176         for (unsigned i = 0; i < 4; ++i) {
177             if (defaultCodePage != CJKCodePages[i]) {
178                 DWORD codePageMask;
179                 langFontLink->CodePageToCodePages(CJKCodePages[i], &codePageMask);
180                 codePageMasks.append(codePageMask);
181             }
182         }
183     }
184     return codePageMasks;
185 }
186
187 static bool currentFontContainsCharacter(HDC hdc, UChar character)
188 {
189     static Vector<char, 512> glyphsetBuffer;
190     glyphsetBuffer.resize(GetFontUnicodeRanges(hdc, 0));
191     GLYPHSET* glyphset = reinterpret_cast<GLYPHSET*>(glyphsetBuffer.data());
192     GetFontUnicodeRanges(hdc, glyphset);
193
194     // FIXME: Change this to a binary search.
195     unsigned i = 0;
196     while (i < glyphset->cRanges && glyphset->ranges[i].wcLow <= character)
197         i++;
198
199     return i && glyphset->ranges[i - 1].wcLow + glyphset->ranges[i - 1].cGlyphs > character;
200 }
201
202 static HFONT createMLangFont(IMLangFontLinkType* langFontLink, HDC hdc, DWORD codePageMask, UChar character = 0)
203 {
204     HFONT MLangFont;
205     HFONT hfont = 0;
206     if (SUCCEEDED(langFontLink->MapFont(hdc, codePageMask, character, &MLangFont)) && MLangFont) {
207         LOGFONT lf;
208         GetObject(MLangFont, sizeof(LOGFONT), &lf);
209         langFontLink->ReleaseFont(MLangFont);
210         hfont = CreateFontIndirect(&lf);
211     }
212     return hfont;
213 }
214
215 RefPtr<Font> FontCache::systemFallbackForCharacters(const FontDescription& description, const Font* originalFontData, bool, const UChar* characters, unsigned length)
216 {
217     UChar character = characters[0];
218     RefPtr<Font> fontData;
219     HWndDC hdc(0);
220     HFONT primaryFont = originalFontData->platformData().hfont();
221     HGDIOBJ oldFont = SelectObject(hdc, primaryFont);
222     HFONT hfont = 0;
223
224     if (IMLangFontLinkType* langFontLink = getFontLinkInterface()) {
225         // Try MLang font linking first.
226         DWORD codePages = 0;
227         if (SUCCEEDED(langFontLink->GetCharCodePages(character, &codePages))) {
228             if (codePages && u_getIntPropertyValue(character, UCHAR_UNIFIED_IDEOGRAPH)) {
229                 // The CJK character may belong to multiple code pages. We want to
230                 // do font linking against a single one of them, preferring the default
231                 // code page for the user's locale.
232                 const Vector<DWORD, 4>& CJKCodePageMasks = getCJKCodePageMasks();
233                 unsigned numCodePages = CJKCodePageMasks.size();
234                 for (unsigned i = 0; i < numCodePages && !hfont; ++i) {
235                     hfont = createMLangFont(langFontLink, hdc, CJKCodePageMasks[i]);
236                     if (hfont && !(codePages & CJKCodePageMasks[i])) {
237                         // We asked about a code page that is not one of the code pages
238                         // returned by MLang, so the font might not contain the character.
239                         SelectObject(hdc, hfont);
240                         if (!currentFontContainsCharacter(hdc, character)) {
241                             DeleteObject(hfont);
242                             hfont = 0;
243                         }
244                         SelectObject(hdc, primaryFont);
245                     }
246                 }
247             } else
248                 hfont = createMLangFont(langFontLink, hdc, codePages, character);
249         }
250     }
251
252     // A font returned from MLang is trusted to contain the character.
253     bool containsCharacter = hfont;
254
255     if (!hfont) {
256         // To find out what font Uniscribe would use, we make it draw into a metafile and intercept
257         // calls to CreateFontIndirect().
258         HDC metaFileDc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
259         SelectObject(metaFileDc, primaryFont);
260
261         bool scriptStringOutSucceeded = false;
262         SCRIPT_STRING_ANALYSIS ssa;
263
264         // FIXME: If length is greater than 1, we actually return the font for the last character.
265         // This function should be renamed getFontDataForCharacter and take a single 32-bit character.
266         if (SUCCEEDED(ScriptStringAnalyse(metaFileDc, characters, length, 0, -1, SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK,
267             0, NULL, NULL, NULL, NULL, NULL, &ssa))) {
268             scriptStringOutSucceeded = SUCCEEDED(ScriptStringOut(ssa, 0, 0, 0, NULL, 0, 0, FALSE));
269             ScriptStringFree(&ssa);
270         }
271         HENHMETAFILE metaFile = CloseEnhMetaFile(metaFileDc);
272         if (scriptStringOutSucceeded) {
273             LOGFONT logFont;
274             logFont.lfFaceName[0] = 0;
275             EnumEnhMetaFile(0, metaFile, metaFileEnumProc, &logFont, NULL);
276             if (logFont.lfFaceName[0])
277                 hfont = CreateFontIndirect(&logFont);
278         }
279         DeleteEnhMetaFile(metaFile);
280     }
281
282     String familyName;
283     const Vector<String>* linkedFonts = 0;
284     unsigned linkedFontIndex = 0;
285     while (hfont) {
286         SelectObject(hdc, hfont);
287         WCHAR name[LF_FACESIZE];
288         GetTextFace(hdc, LF_FACESIZE, name);
289         familyName = name;
290
291         if (containsCharacter || currentFontContainsCharacter(hdc, character))
292             break;
293
294         if (!linkedFonts)
295             linkedFonts = getLinkedFonts(familyName);
296         SelectObject(hdc, oldFont);
297         DeleteObject(hfont);
298         hfont = 0;
299
300         if (linkedFonts->size() <= linkedFontIndex)
301             break;
302
303         LOGFONT logFont;
304         logFont.lfCharSet = DEFAULT_CHARSET;
305         StringView(linkedFonts->at(linkedFontIndex)).getCharactersWithUpconvert(logFont.lfFaceName);
306         logFont.lfFaceName[linkedFonts->at(linkedFontIndex).length()] = 0;
307         EnumFontFamiliesEx(hdc, &logFont, linkedFontEnumProc, reinterpret_cast<LPARAM>(&hfont), 0);
308         linkedFontIndex++;
309     }
310
311     if (hfont) {
312         if (!familyName.isEmpty()) {
313             FontPlatformData* result = getCachedFontPlatformData(description, familyName);
314             if (result)
315                 fontData = fontForPlatformData(*result);
316         }
317
318         SelectObject(hdc, oldFont);
319         DeleteObject(hfont);
320     }
321
322     return fontData;
323 }
324
325 Vector<String> FontCache::systemFontFamilies()
326 {
327     // FIXME: <https://webkit.org/b/147017> Web Inspector: [Win] Allow inspector to retrieve a list of system fonts
328     Vector<String> fontFamilies;
329     return fontFamilies;
330 }
331
332 RefPtr<Font> FontCache::fontFromDescriptionAndLogFont(const FontDescription& fontDescription, const LOGFONT& font, AtomicString& outFontFamilyName)
333 {
334     AtomicString familyName = String(font.lfFaceName, wcsnlen(font.lfFaceName, LF_FACESIZE));
335     RefPtr<Font> fontData = fontForFamily(fontDescription, familyName);
336     if (fontData)
337         outFontFamilyName = familyName;
338     return fontData;
339 }
340
341 Ref<Font> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
342 {
343     static NeverDestroyed<AtomicString> fallbackFontName;
344
345     if (!fallbackFontName.get().isEmpty())
346         return *fontForFamily(fontDescription, fallbackFontName);
347
348     // FIXME: Would be even better to somehow get the user's default font here.  For now we'll pick
349     // the default that the user would get without changing any prefs.
350
351     // Search all typical Windows-installed full Unicode fonts.
352     // Sorted by most to least glyphs according to http://en.wikipedia.org/wiki/Unicode_typefaces
353     // Start with Times New Roman also since it is the default if the user doesn't change prefs.
354     static AtomicString fallbackFonts[] = {
355         AtomicString("Times New Roman", AtomicString::ConstructFromLiteral),
356         AtomicString("Microsoft Sans Serif", AtomicString::ConstructFromLiteral),
357         AtomicString("Tahoma", AtomicString::ConstructFromLiteral),
358         AtomicString("Lucida Sans Unicode", AtomicString::ConstructFromLiteral),
359         AtomicString("Arial", AtomicString::ConstructFromLiteral)
360     };
361     RefPtr<Font> simpleFont;
362     for (size_t i = 0; i < WTF_ARRAY_LENGTH(fallbackFonts); ++i) {
363         if (simpleFont = fontForFamily(fontDescription, fallbackFonts[i])) {
364             fallbackFontName.get() = fallbackFonts[i];
365             return *simpleFont;
366         }
367     }
368
369     // Fall back to the DEFAULT_GUI_FONT if no known Unicode fonts are available.
370     if (HFONT defaultGUIFont = static_cast<HFONT>(GetStockObject(DEFAULT_GUI_FONT))) {
371         LOGFONT defaultGUILogFont;
372         GetObject(defaultGUIFont, sizeof(defaultGUILogFont), &defaultGUILogFont);
373         if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, defaultGUILogFont, fallbackFontName))
374             return *simpleFont;
375     }
376
377     // Fall back to Non-client metrics fonts.
378     NONCLIENTMETRICS nonClientMetrics = {0};
379     nonClientMetrics.cbSize = sizeof(nonClientMetrics);
380     if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(nonClientMetrics), &nonClientMetrics, 0)) {
381         if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfMessageFont, fallbackFontName))
382             return *simpleFont;
383         if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfMenuFont, fallbackFontName))
384             return *simpleFont;
385         if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfStatusFont, fallbackFontName))
386             return *simpleFont;
387         if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfCaptionFont, fallbackFontName))
388             return *simpleFont;
389         if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfSmCaptionFont, fallbackFontName))
390             return *simpleFont;
391     }
392     
393     ASSERT_NOT_REACHED();
394     return *simpleFont;
395 }
396
397 static LONG toGDIFontWeight(FontSelectionValue fontWeight)
398 {
399     if (fontWeight < FontSelectionValue(150))
400         return FW_THIN;
401     if (fontWeight < FontSelectionValue(250))
402         return FW_EXTRALIGHT;
403     if (fontWeight < FontSelectionValue(350))
404         return FW_LIGHT;
405     if (fontWeight < FontSelectionValue(450))
406         return FW_NORMAL;
407     if (fontWeight < FontSelectionValue(550))
408         return FW_MEDIUM;
409     if (fontWeight < FontSelectionValue(650))
410         return FW_SEMIBOLD;
411     if (fontWeight < FontSelectionValue(750))
412         return FW_BOLD;
413     if (fontWeight < FontSelectionValue(850))
414         return FW_EXTRABOLD;
415     return FW_HEAVY;
416 }
417
418 static inline bool isGDIFontWeightBold(LONG gdiFontWeight)
419 {
420     return gdiFontWeight >= FW_SEMIBOLD;
421 }
422
423 static LONG adjustedGDIFontWeight(LONG gdiFontWeight, const String& family)
424 {
425     if (equalLettersIgnoringASCIICase(family, "lucida grande")) {
426         if (gdiFontWeight == FW_NORMAL)
427             return FW_MEDIUM;
428         if (gdiFontWeight == FW_BOLD)
429             return FW_SEMIBOLD;
430     }
431     return gdiFontWeight;
432 }
433
434 struct MatchImprovingProcData {
435     MatchImprovingProcData(LONG desiredWeight, bool desiredItalic)
436         : m_desiredWeight(desiredWeight)
437         , m_desiredItalic(desiredItalic)
438         , m_hasMatched(false)
439     {
440     }
441
442     LONG m_desiredWeight;
443     bool m_desiredItalic;
444     bool m_hasMatched;
445     LOGFONT m_chosen;
446 };
447
448 static int CALLBACK matchImprovingEnumProc(CONST LOGFONT* candidate, CONST TEXTMETRIC* metrics, DWORD fontType, LPARAM lParam)
449 {
450     MatchImprovingProcData* matchData = reinterpret_cast<MatchImprovingProcData*>(lParam);
451
452     if (!matchData->m_hasMatched) {
453         matchData->m_hasMatched = true;
454         matchData->m_chosen = *candidate;
455         return 1;
456     }
457
458     if (!candidate->lfItalic != !matchData->m_chosen.lfItalic) {
459         if (!candidate->lfItalic == !matchData->m_desiredItalic)
460             matchData->m_chosen = *candidate;
461
462         return 1;
463     }
464
465     unsigned chosenWeightDeltaMagnitude = abs(matchData->m_chosen.lfWeight - matchData->m_desiredWeight);
466     unsigned candidateWeightDeltaMagnitude = abs(candidate->lfWeight - matchData->m_desiredWeight);
467
468     // If both are the same distance from the desired weight, prefer the candidate if it is further from regular.
469     if (chosenWeightDeltaMagnitude == candidateWeightDeltaMagnitude && abs(candidate->lfWeight - FW_NORMAL) > abs(matchData->m_chosen.lfWeight - FW_NORMAL)) {
470         matchData->m_chosen = *candidate;
471         return 1;
472     }
473
474     // Otherwise, prefer the one closer to the desired weight.
475     if (candidateWeightDeltaMagnitude < chosenWeightDeltaMagnitude)
476         matchData->m_chosen = *candidate;
477
478     return 1;
479 }
480
481 static GDIObject<HFONT> createGDIFont(const AtomicString& family, LONG desiredWeight, bool desiredItalic, int size, bool synthesizeItalic)
482 {
483     HWndDC hdc(0);
484
485     LOGFONT logFont;
486     logFont.lfCharSet = DEFAULT_CHARSET;
487     StringView truncatedFamily = StringView(family).substring(0, static_cast<unsigned>(LF_FACESIZE - 1));
488     truncatedFamily.getCharactersWithUpconvert(logFont.lfFaceName);
489     logFont.lfFaceName[truncatedFamily.length()] = 0;
490     logFont.lfPitchAndFamily = 0;
491
492     MatchImprovingProcData matchData(desiredWeight, desiredItalic);
493     EnumFontFamiliesEx(hdc, &logFont, matchImprovingEnumProc, reinterpret_cast<LPARAM>(&matchData), 0);
494
495     if (!matchData.m_hasMatched)
496         return nullptr;
497
498     matchData.m_chosen.lfHeight = -size;
499     matchData.m_chosen.lfWidth = 0;
500     matchData.m_chosen.lfEscapement = 0;
501     matchData.m_chosen.lfOrientation = 0;
502     matchData.m_chosen.lfUnderline = false;
503     matchData.m_chosen.lfStrikeOut = false;
504     matchData.m_chosen.lfCharSet = DEFAULT_CHARSET;
505 #if USE(CG) || USE(CAIRO)
506     matchData.m_chosen.lfOutPrecision = OUT_TT_ONLY_PRECIS;
507 #else
508     matchData.m_chosen.lfOutPrecision = OUT_TT_PRECIS;
509 #endif
510     matchData.m_chosen.lfQuality = DEFAULT_QUALITY;
511     matchData.m_chosen.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
512
513    if (desiredItalic && !matchData.m_chosen.lfItalic && synthesizeItalic)
514        matchData.m_chosen.lfItalic = 1;
515
516     auto chosenFont = adoptGDIObject(::CreateFontIndirect(&matchData.m_chosen));
517     if (!chosenFont)
518         return nullptr;
519
520     HWndDC dc(0);
521     SaveDC(dc);
522     SelectObject(dc, chosenFont.get());
523     WCHAR actualName[LF_FACESIZE];
524     GetTextFace(dc, LF_FACESIZE, actualName);
525     RestoreDC(dc, -1);
526
527     if (wcsicmp(matchData.m_chosen.lfFaceName, actualName))
528         return nullptr;
529
530     return chosenFont;
531 }
532
533 struct TraitsInFamilyProcData {
534     TraitsInFamilyProcData(const AtomicString& familyName)
535         : m_familyName(familyName)
536     {
537     }
538
539     const AtomicString& m_familyName;
540     Vector<FontSelectionCapabilities> m_capabilities;
541 };
542
543 static int CALLBACK traitsInFamilyEnumProc(CONST LOGFONT* logFont, CONST TEXTMETRIC* metrics, DWORD fontType, LPARAM lParam)
544 {
545     TraitsInFamilyProcData* procData = reinterpret_cast<TraitsInFamilyProcData*>(lParam);
546
547     FontSelectionValue italic = logFont->lfItalic ? italicThreshold() : FontSelectionValue();
548
549     FontSelectionValue weight;
550     switch (adjustedGDIFontWeight(logFont->lfWeight, procData->m_familyName)) {
551     case FW_THIN:
552         weight = FontSelectionValue(100);
553         break;
554     case FW_EXTRALIGHT:
555         weight = FontSelectionValue(200);
556         break;
557     case FW_LIGHT:
558         weight = FontSelectionValue(300);
559         break;
560     case FW_NORMAL:
561         weight = FontSelectionValue(400);
562         break;
563     case FW_MEDIUM:
564         weight = FontSelectionValue(500);
565         break;
566     case FW_SEMIBOLD:
567         weight = FontSelectionValue(600);
568         break;
569     case FW_BOLD:
570         weight = FontSelectionValue(700);
571         break;
572     case FW_EXTRABOLD:
573         weight = FontSelectionValue(800);
574         break;
575     default:
576         weight = FontSelectionValue(900);
577         break;
578     }
579
580     FontSelectionValue stretch = normalStretchValue();
581
582     FontSelectionCapabilities result;
583     result.weight = FontSelectionRange(weight, weight);
584     result.width = FontSelectionRange(stretch, stretch);
585     result.slope = FontSelectionRange(italic, italic);
586     procData->m_capabilities.append(WTFMove(result));
587     return 1;
588 }
589
590 Vector<FontSelectionCapabilities> FontCache::getFontSelectionCapabilitiesInFamily(const AtomicString& familyName)
591 {
592     HWndDC hdc(0);
593
594     LOGFONT logFont;
595     logFont.lfCharSet = DEFAULT_CHARSET;
596     StringView truncatedFamily = StringView(familyName).substring(0, static_cast<unsigned>(LF_FACESIZE - 1));
597     truncatedFamily.getCharactersWithUpconvert(logFont.lfFaceName);
598     logFont.lfFaceName[truncatedFamily.length()] = 0;
599     logFont.lfPitchAndFamily = 0;
600
601     TraitsInFamilyProcData procData(familyName);
602     EnumFontFamiliesEx(hdc, &logFont, traitsInFamilyEnumProc, reinterpret_cast<LPARAM>(&procData), 0);
603     Vector<FontSelectionCapabilities> result;
604     result.reserveInitialCapacity(procData.m_capabilities.size());
605     for (auto capabilities : procData.m_capabilities)
606         result.uncheckedAppend(capabilities);
607     return result;
608 }
609
610 std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family, const FontFeatureSettings*, const FontVariantSettings*, FontSelectionSpecifiedCapabilities)
611 {
612     bool isLucidaGrande = equalLettersIgnoringASCIICase(family, "lucida grande");
613
614     bool useGDI = fontDescription.renderingMode() == FontRenderingMode::Alternate && !isLucidaGrande;
615
616     // The logical size constant is 32. We do this for subpixel precision when rendering using Uniscribe.
617     // This masks rounding errors related to the HFONT metrics being  different from the CGFont metrics.
618     // FIXME: We will eventually want subpixel precision for GDI mode, but the scaled rendering doesn't
619     // look as nice. That may be solvable though.
620     LONG weight = adjustedGDIFontWeight(toGDIFontWeight(fontDescription.weight()), family);
621     auto hfont = createGDIFont(family, weight, fontDescription.italic(),
622         fontDescription.computedPixelSize() * (useGDI ? 1 : 32), useGDI);
623
624     if (!hfont)
625         return nullptr;
626
627     if (isLucidaGrande)
628         useGDI = false; // Never use GDI for Lucida Grande.
629
630     LOGFONT logFont;
631     GetObject(hfont.get(), sizeof(LOGFONT), &logFont);
632
633     bool synthesizeBold = isGDIFontWeightBold(weight) && !isGDIFontWeightBold(logFont.lfWeight);
634     bool synthesizeItalic = fontDescription.italic() && !logFont.lfItalic;
635
636     auto result = std::make_unique<FontPlatformData>(WTFMove(hfont), fontDescription.computedPixelSize(), synthesizeBold, synthesizeItalic, useGDI);
637
638 #if USE(CG)
639     bool fontCreationFailed = !result->cgFont();
640 #elif USE(DIRECT2D)
641     bool fontCreationFailed = !result->dwFont();
642 #elif USE(CAIRO)
643     bool fontCreationFailed = !result->scaledFont();
644 #endif
645
646     if (fontCreationFailed) {
647         // The creation of the CGFontRef failed for some reason.  We already asserted in debug builds, but to make
648         // absolutely sure that we don't use this font, go ahead and return 0 so that we can fall back to the next
649         // font.
650         return nullptr;
651     }
652
653     return result;
654 }
655
656 const AtomicString& FontCache::platformAlternateFamilyName(const AtomicString& familyName)
657 {
658     static NeverDestroyed<AtomicString> timesNewRoman("Times New Roman", AtomicString::ConstructFromLiteral);
659     static NeverDestroyed<AtomicString> microsoftSansSerif("Microsoft Sans Serif", AtomicString::ConstructFromLiteral);
660
661     switch (familyName.length()) {
662     // On Windows, we don't support bitmap fonts, but legacy content expects support.
663     // Thus we allow Times New Roman as an alternative for the bitmap font MS Serif,
664     // even if the webpage does not specify fallback.
665     // FIXME: Seems unlikely this is still needed. If it was really needed, I think we
666     // would need it on other platforms too.
667     case 8:
668         if (equalLettersIgnoringASCIICase(familyName, "ms serif"))
669             return timesNewRoman;
670         break;
671     // On Windows, we don't support bitmap fonts, but legacy content expects support.
672     // Thus we allow Microsoft Sans Serif as an alternative for the bitmap font MS Sans Serif,
673     // even if the webpage does not specify fallback.
674     // FIXME: Seems unlikely this is still needed. If it was really needed, I think we
675     // would need it on other platforms too.
676     case 13:
677         if (equalLettersIgnoringASCIICase(familyName, "ms sans serif"))
678             return microsoftSansSerif;
679         break;
680     }
681     return nullAtom();
682 }
683
684 }