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