Flutter Engine
The Flutter Engine
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
SkFontConfigInterface_direct.cpp
Go to the documentation of this file.
1/*
2 * Copyright 2009-2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8/* migrated from chrome/src/skia/ext/SkFontHost_fontconfig_direct.cpp */
9
20#include "src/base/SkBuffer.h"
22
23#include <fontconfig/fontconfig.h>
24#include <unistd.h>
25
26namespace {
27
28// FontConfig was thread antagonistic until 2.10.91 with known thread safety issues until 2.13.93.
29// Before that, lock with a global mutex.
30// See https://bug.skia.org/1497 and cl/339089311 for background.
31static SkMutex& f_c_mutex() {
32 static SkMutex& mutex = *(new SkMutex);
33 return mutex;
34}
35
36struct FCLocker {
37 inline static constexpr int FontConfigThreadSafeVersion = 21393;
38
39 // Assume FcGetVersion() has always been thread safe.
40 FCLocker() {
41 if (FcGetVersion() < FontConfigThreadSafeVersion) {
42 f_c_mutex().acquire();
43 }
44 }
45
46 ~FCLocker() {
47 AssertHeld();
48 if (FcGetVersion() < FontConfigThreadSafeVersion) {
49 f_c_mutex().release();
50 }
51 }
52
53 static void AssertHeld() { SkDEBUGCODE(
54 if (FcGetVersion() < FontConfigThreadSafeVersion) {
55 f_c_mutex().assertHeld();
56 }
57 ) }
58};
59
60using UniqueFCConfig = std::unique_ptr<FcConfig, SkFunctionObject<FcConfigDestroy>>;
61
62} // namespace
63
65 size_t size = sizeof(fID) + sizeof(fTTCIndex);
66 size += sizeof(int32_t) + sizeof(int32_t) + sizeof(uint8_t); // weight, width, italic
67 size += sizeof(int32_t) + fString.size(); // store length+data
68 if (addr) {
70
71 buffer.write32(fID);
72 buffer.write32(fTTCIndex);
73 buffer.write32(fString.size());
74 buffer.write32(fStyle.weight());
75 buffer.write32(fStyle.width());
76 buffer.write8(fStyle.slant());
77 buffer.write(fString.c_str(), fString.size());
78 buffer.padToAlign4();
79
80 SkASSERT(buffer.pos() == size);
81 }
82 return size;
83}
84
86 size_t size) {
88
89 (void)buffer.readU32(&fID);
90 (void)buffer.readS32(&fTTCIndex);
91 uint32_t strLen, weight, width;
92 (void)buffer.readU32(&strLen);
93 (void)buffer.readU32(&weight);
94 (void)buffer.readU32(&width);
95 uint8_t u8;
96 (void)buffer.readU8(&u8);
98 fStyle = SkFontStyle(weight, width, slant);
99 fString.resize(strLen);
100 (void)buffer.read(fString.data(), strLen);
101 buffer.skipToAlign4();
102
103 return buffer.pos(); // the actual number of bytes read
104}
105
106#ifdef SK_DEBUG
107static void make_iden(SkFontConfigInterface::FontIdentity* iden) {
108 iden->fID = 10;
109 iden->fTTCIndex = 2;
110 iden->fString.set("Hello world");
112}
113
114static void test_writeToMemory(const SkFontConfigInterface::FontIdentity& iden0,
115 int initValue) {
117
118 size_t size0 = iden0.writeToMemory(nullptr);
119
120 SkAutoMalloc storage(size0);
121 memset(storage.get(), initValue, size0);
122
123 size_t size1 = iden0.writeToMemory(storage.get());
124 SkASSERT(size0 == size1);
125
126 SkASSERT(iden0 != iden1);
127 size_t size2 = iden1.readFromMemory(storage.get(), size1);
128 SkASSERT(size2 == size1);
129 SkASSERT(iden0 == iden1);
130}
131
132static void fontconfiginterface_unittest() {
134
135 SkASSERT(iden0 == iden1);
136
137 make_iden(&iden0);
138 SkASSERT(iden0 != iden1);
139
140 make_iden(&iden1);
141 SkASSERT(iden0 == iden1);
142
143 test_writeToMemory(iden0, 0);
144 test_writeToMemory(iden0, 0);
145}
146#endif
147
148///////////////////////////////////////////////////////////////////////////////
149
150// Returns the string from the pattern, or nullptr
151static const char* get_string(FcPattern* pattern, const char field[], int index = 0) {
152 char* name;
153 if (FcPatternGetString(pattern, field, index, (FcChar8**)&name) != FcResultMatch) {
154 name = nullptr;
155 }
156 return name;
157}
158
159///////////////////////////////////////////////////////////////////////////////
160
161namespace {
162
163// Equivalence classes, used to match the Liberation and other fonts
164// with their metric-compatible replacements. See the discussion in
165// GetFontEquivClass().
166enum FontEquivClass
167{
168 OTHER,
169 SANS,
170 SERIF,
171 MONO,
172 SYMBOL,
173 PGOTHIC,
174 GOTHIC,
175 PMINCHO,
176 MINCHO,
177 SIMSUN,
178 NSIMSUN,
179 SIMHEI,
180 PMINGLIU,
181 MINGLIU,
182 PMINGLIUHK,
183 MINGLIUHK,
184 CAMBRIA,
185 CALIBRI,
186};
187
188// Match the font name against a whilelist of fonts, returning the equivalence
189// class.
190FontEquivClass GetFontEquivClass(const char* fontname)
191{
192 // It would be nice for fontconfig to tell us whether a given suggested
193 // replacement is a "strong" match (that is, an equivalent font) or
194 // a "weak" match (that is, fontconfig's next-best attempt at finding a
195 // substitute). However, I played around with the fontconfig API for
196 // a good few hours and could not make it reveal this information.
197 //
198 // So instead, we hardcode. Initially this function emulated
199 // /etc/fonts/conf.d/30-metric-aliases.conf
200 // from my Ubuntu system, but we're better off being very conservative.
201
202 // Arimo, Tinos and Cousine are a set of fonts metric-compatible with
203 // Arial, Times New Roman and Courier New with a character repertoire
204 // much larger than Liberation. Note that Cousine is metrically
205 // compatible with Courier New, but the former is sans-serif while
206 // the latter is serif.
207
208
209 struct FontEquivMap {
210 FontEquivClass clazz;
211 const char name[40];
212 };
213
214 static const FontEquivMap kFontEquivMap[] = {
215 { SANS, "Arial" },
216 { SANS, "Arimo" },
217 { SANS, "Liberation Sans" },
218
219 { SERIF, "Times New Roman" },
220 { SERIF, "Tinos" },
221 { SERIF, "Liberation Serif" },
222
223 { MONO, "Courier New" },
224 { MONO, "Cousine" },
225 { MONO, "Liberation Mono" },
226
227 { SYMBOL, "Symbol" },
228 { SYMBOL, "Symbol Neu" },
229
230 // MS Pゴシック
231 { PGOTHIC, "MS PGothic" },
232 { PGOTHIC, "\xef\xbc\xad\xef\xbc\xb3 \xef\xbc\xb0"
233 "\xe3\x82\xb4\xe3\x82\xb7\xe3\x83\x83\xe3\x82\xaf" },
234 { PGOTHIC, "Noto Sans CJK JP" },
235 { PGOTHIC, "IPAPGothic" },
236 { PGOTHIC, "MotoyaG04Gothic" },
237
238 // MS ゴシック
239 { GOTHIC, "MS Gothic" },
240 { GOTHIC, "\xef\xbc\xad\xef\xbc\xb3 "
241 "\xe3\x82\xb4\xe3\x82\xb7\xe3\x83\x83\xe3\x82\xaf" },
242 { GOTHIC, "Noto Sans Mono CJK JP" },
243 { GOTHIC, "IPAGothic" },
244 { GOTHIC, "MotoyaG04GothicMono" },
245
246 // MS P明朝
247 { PMINCHO, "MS PMincho" },
248 { PMINCHO, "\xef\xbc\xad\xef\xbc\xb3 \xef\xbc\xb0"
249 "\xe6\x98\x8e\xe6\x9c\x9d"},
250 { PMINCHO, "Noto Serif CJK JP" },
251 { PMINCHO, "IPAPMincho" },
252 { PMINCHO, "MotoyaG04Mincho" },
253
254 // MS 明朝
255 { MINCHO, "MS Mincho" },
256 { MINCHO, "\xef\xbc\xad\xef\xbc\xb3 \xe6\x98\x8e\xe6\x9c\x9d" },
257 { MINCHO, "Noto Serif CJK JP" },
258 { MINCHO, "IPAMincho" },
259 { MINCHO, "MotoyaG04MinchoMono" },
260
261 // 宋体
262 { SIMSUN, "Simsun" },
263 { SIMSUN, "\xe5\xae\x8b\xe4\xbd\x93" },
264 { SIMSUN, "Noto Serif CJK SC" },
265 { SIMSUN, "MSung GB18030" },
266 { SIMSUN, "Song ASC" },
267
268 // 新宋体
269 { NSIMSUN, "NSimsun" },
270 { NSIMSUN, "\xe6\x96\xb0\xe5\xae\x8b\xe4\xbd\x93" },
271 { NSIMSUN, "Noto Serif CJK SC" },
272 { NSIMSUN, "MSung GB18030" },
273 { NSIMSUN, "N Song ASC" },
274
275 // 黑体
276 { SIMHEI, "Simhei" },
277 { SIMHEI, "\xe9\xbb\x91\xe4\xbd\x93" },
278 { SIMHEI, "Noto Sans CJK SC" },
279 { SIMHEI, "MYingHeiGB18030" },
280 { SIMHEI, "MYingHeiB5HK" },
281
282 // 新細明體
283 { PMINGLIU, "PMingLiU"},
284 { PMINGLIU, "\xe6\x96\xb0\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94" },
285 { PMINGLIU, "Noto Serif CJK TC"},
286 { PMINGLIU, "MSung B5HK"},
287
288 // 細明體
289 { MINGLIU, "MingLiU"},
290 { MINGLIU, "\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94" },
291 { MINGLIU, "Noto Serif CJK TC"},
292 { MINGLIU, "MSung B5HK"},
293
294 // 新細明體
295 { PMINGLIUHK, "PMingLiU_HKSCS"},
296 { PMINGLIUHK, "\xe6\x96\xb0\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94_HKSCS" },
297 { PMINGLIUHK, "Noto Serif CJK TC"},
298 { PMINGLIUHK, "MSung B5HK"},
299
300 // 細明體
301 { MINGLIUHK, "MingLiU_HKSCS"},
302 { MINGLIUHK, "\xe7\xb4\xb0\xe6\x98\x8e\xe9\xab\x94_HKSCS" },
303 { MINGLIUHK, "Noto Serif CJK TC"},
304 { MINGLIUHK, "MSung B5HK"},
305
306 // Cambria
307 { CAMBRIA, "Cambria" },
308 { CAMBRIA, "Caladea" },
309
310 // Calibri
311 { CALIBRI, "Calibri" },
312 { CALIBRI, "Carlito" },
313 };
314
315 static const size_t kFontCount =
316 sizeof(kFontEquivMap)/sizeof(kFontEquivMap[0]);
317
318 // TODO(jungshik): If this loop turns out to be hot, turn
319 // the array to a static (hash)map to speed it up.
320 for (size_t i = 0; i < kFontCount; ++i) {
321 if (strcasecmp(kFontEquivMap[i].name, fontname) == 0)
322 return kFontEquivMap[i].clazz;
323 }
324 return OTHER;
325}
326
327
328// Return true if |font_a| and |font_b| are visually and at the metrics
329// level interchangeable.
330bool IsMetricCompatibleReplacement(const char* font_a, const char* font_b)
331{
332 FontEquivClass class_a = GetFontEquivClass(font_a);
333 FontEquivClass class_b = GetFontEquivClass(font_b);
334
335 return class_a != OTHER && class_a == class_b;
336}
337
338// Normally we only return exactly the font asked for. In last-resort
339// cases, the request either doesn't specify a font or is one of the
340// basic font names like "Sans", "Serif" or "Monospace". This function
341// tells you whether a given request is for such a fallback.
342bool IsFallbackFontAllowed(const SkString& family) {
343 const char* family_cstr = family.c_str();
344 return family.isEmpty() ||
345 strcasecmp(family_cstr, "sans") == 0 ||
346 strcasecmp(family_cstr, "serif") == 0 ||
347 strcasecmp(family_cstr, "monospace") == 0;
348}
349
350// Retrieves |is_bold|, |is_italic| and |font_family| properties from |font|.
351static int get_int(FcPattern* pattern, const char object[], int missing) {
352 int value;
353 if (FcPatternGetInteger(pattern, object, 0, &value) != FcResultMatch) {
354 return missing;
355 }
356 return value;
357}
358
359static int map_range(SkScalar value,
360 SkScalar old_min, SkScalar old_max,
361 SkScalar new_min, SkScalar new_max)
362{
363 SkASSERT(old_min < old_max);
364 SkASSERT(new_min <= new_max);
365 return new_min + ((value - old_min) * (new_max - new_min) / (old_max - old_min));
366}
367
368struct MapRanges {
369 SkScalar old_val;
370 SkScalar new_val;
371};
372
373static SkScalar map_ranges(SkScalar val, MapRanges const ranges[], int rangesCount) {
374 // -Inf to [0]
375 if (val < ranges[0].old_val) {
376 return ranges[0].new_val;
377 }
378
379 // Linear from [i] to [i+1]
380 for (int i = 0; i < rangesCount - 1; ++i) {
381 if (val < ranges[i+1].old_val) {
382 return map_range(val, ranges[i].old_val, ranges[i+1].old_val,
383 ranges[i].new_val, ranges[i+1].new_val);
384 }
385 }
386
387 // From [n] to +Inf
388 // if (fcweight < Inf)
389 return ranges[rangesCount-1].new_val;
390}
391
392#ifndef FC_WEIGHT_DEMILIGHT
393#define FC_WEIGHT_DEMILIGHT 65
394#endif
395
396static SkFontStyle skfontstyle_from_fcpattern(FcPattern* pattern) {
397 typedef SkFontStyle SkFS;
398
399 static constexpr MapRanges weightRanges[] = {
400 { FC_WEIGHT_THIN, SkFS::kThin_Weight },
401 { FC_WEIGHT_EXTRALIGHT, SkFS::kExtraLight_Weight },
402 { FC_WEIGHT_LIGHT, SkFS::kLight_Weight },
403 { FC_WEIGHT_DEMILIGHT, 350 },
404 { FC_WEIGHT_BOOK, 380 },
405 { FC_WEIGHT_REGULAR, SkFS::kNormal_Weight },
406 { FC_WEIGHT_MEDIUM, SkFS::kMedium_Weight },
407 { FC_WEIGHT_DEMIBOLD, SkFS::kSemiBold_Weight },
408 { FC_WEIGHT_BOLD, SkFS::kBold_Weight },
409 { FC_WEIGHT_EXTRABOLD, SkFS::kExtraBold_Weight },
410 { FC_WEIGHT_BLACK, SkFS::kBlack_Weight },
411 { FC_WEIGHT_EXTRABLACK, SkFS::kExtraBlack_Weight },
412 };
413 SkScalar weight = map_ranges(get_int(pattern, FC_WEIGHT, FC_WEIGHT_REGULAR),
414 weightRanges, std::size(weightRanges));
415
416 static constexpr MapRanges widthRanges[] = {
417 { FC_WIDTH_ULTRACONDENSED, SkFS::kUltraCondensed_Width },
418 { FC_WIDTH_EXTRACONDENSED, SkFS::kExtraCondensed_Width },
419 { FC_WIDTH_CONDENSED, SkFS::kCondensed_Width },
420 { FC_WIDTH_SEMICONDENSED, SkFS::kSemiCondensed_Width },
421 { FC_WIDTH_NORMAL, SkFS::kNormal_Width },
422 { FC_WIDTH_SEMIEXPANDED, SkFS::kSemiExpanded_Width },
423 { FC_WIDTH_EXPANDED, SkFS::kExpanded_Width },
424 { FC_WIDTH_EXTRAEXPANDED, SkFS::kExtraExpanded_Width },
425 { FC_WIDTH_ULTRAEXPANDED, SkFS::kUltraExpanded_Width },
426 };
427 SkScalar width = map_ranges(get_int(pattern, FC_WIDTH, FC_WIDTH_NORMAL),
428 widthRanges, std::size(widthRanges));
429
430 SkFS::Slant slant = SkFS::kUpright_Slant;
431 switch (get_int(pattern, FC_SLANT, FC_SLANT_ROMAN)) {
432 case FC_SLANT_ROMAN: slant = SkFS::kUpright_Slant; break;
433 case FC_SLANT_ITALIC : slant = SkFS::kItalic_Slant ; break;
434 case FC_SLANT_OBLIQUE: slant = SkFS::kOblique_Slant; break;
435 default: SkASSERT(false); break;
436 }
437
439}
440
441static void fcpattern_from_skfontstyle(SkFontStyle style, FcPattern* pattern) {
442 typedef SkFontStyle SkFS;
443
444 static constexpr MapRanges weightRanges[] = {
445 { SkFS::kThin_Weight, FC_WEIGHT_THIN },
446 { SkFS::kExtraLight_Weight, FC_WEIGHT_EXTRALIGHT },
447 { SkFS::kLight_Weight, FC_WEIGHT_LIGHT },
448 { 350, FC_WEIGHT_DEMILIGHT },
449 { 380, FC_WEIGHT_BOOK },
450 { SkFS::kNormal_Weight, FC_WEIGHT_REGULAR },
451 { SkFS::kMedium_Weight, FC_WEIGHT_MEDIUM },
452 { SkFS::kSemiBold_Weight, FC_WEIGHT_DEMIBOLD },
453 { SkFS::kBold_Weight, FC_WEIGHT_BOLD },
454 { SkFS::kExtraBold_Weight, FC_WEIGHT_EXTRABOLD },
455 { SkFS::kBlack_Weight, FC_WEIGHT_BLACK },
456 { SkFS::kExtraBlack_Weight, FC_WEIGHT_EXTRABLACK },
457 };
458 int weight = map_ranges(style.weight(), weightRanges, std::size(weightRanges));
459
460 static constexpr MapRanges widthRanges[] = {
461 { SkFS::kUltraCondensed_Width, FC_WIDTH_ULTRACONDENSED },
462 { SkFS::kExtraCondensed_Width, FC_WIDTH_EXTRACONDENSED },
463 { SkFS::kCondensed_Width, FC_WIDTH_CONDENSED },
464 { SkFS::kSemiCondensed_Width, FC_WIDTH_SEMICONDENSED },
465 { SkFS::kNormal_Width, FC_WIDTH_NORMAL },
466 { SkFS::kSemiExpanded_Width, FC_WIDTH_SEMIEXPANDED },
467 { SkFS::kExpanded_Width, FC_WIDTH_EXPANDED },
468 { SkFS::kExtraExpanded_Width, FC_WIDTH_EXTRAEXPANDED },
469 { SkFS::kUltraExpanded_Width, FC_WIDTH_ULTRAEXPANDED },
470 };
471 int width = map_ranges(style.width(), widthRanges, std::size(widthRanges));
472
473 int slant = FC_SLANT_ROMAN;
474 switch (style.slant()) {
475 case SkFS::kUpright_Slant: slant = FC_SLANT_ROMAN ; break;
476 case SkFS::kItalic_Slant : slant = FC_SLANT_ITALIC ; break;
477 case SkFS::kOblique_Slant: slant = FC_SLANT_OBLIQUE; break;
478 default: SkASSERT(false); break;
479 }
480
481 FcPatternAddInteger(pattern, FC_WEIGHT, weight);
482 FcPatternAddInteger(pattern, FC_WIDTH , width);
483 FcPatternAddInteger(pattern, FC_SLANT , slant);
484}
485
486} // anonymous namespace
487
488///////////////////////////////////////////////////////////////////////////////
489
490#define kMaxFontFamilyLength 2048
491#ifdef SK_FONT_CONFIG_INTERFACE_ONLY_ALLOW_SFNT_FONTS
492const char* kFontFormatTrueType = "TrueType";
493const char* kFontFormatCFF = "CFF";
494#endif
495
497{
498 SkDEBUGCODE(fontconfiginterface_unittest();)
499}
500
502 if (fFC) {
503 FcConfigDestroy(fFC);
504 }
505}
506
508 if (access(filename, R_OK) != 0) {
509 return false;
510 }
511 return true;
512}
513
514bool SkFontConfigInterfaceDirect::isValidPattern(FcPattern* pattern) {
515#ifdef SK_FONT_CONFIG_INTERFACE_ONLY_ALLOW_SFNT_FONTS
516 const char* font_format = get_string(pattern, FC_FONTFORMAT);
517 if (font_format
518 && 0 != strcmp(font_format, kFontFormatTrueType)
519 && 0 != strcmp(font_format, kFontFormatCFF))
520 {
521 return false;
522 }
523#endif
524
525 // fontconfig can also return fonts which are unreadable
526 const char* c_filename = get_string(pattern, FC_FILE);
527 if (!c_filename) {
528 return false;
529 }
530
531 FcConfig* fc = fFC;
532 UniqueFCConfig fcStorage;
533 if (!fc) {
534 fcStorage.reset(FcConfigReference(nullptr));
535 fc = fcStorage.get();
536 }
537
538 const char* sysroot = (const char*)FcConfigGetSysRoot(fc);
539 SkString resolvedFilename;
540 if (sysroot) {
541 resolvedFilename = sysroot;
542 resolvedFilename += c_filename;
543 c_filename = resolvedFilename.c_str();
544 }
545 return this->isAccessible(c_filename);
546}
547
548// Find matching font from |font_set| for the given font family.
549FcPattern* SkFontConfigInterfaceDirect::MatchFont(FcFontSet* font_set,
550 const char* post_config_family,
551 const SkString& family) {
552 // Older versions of fontconfig have a bug where they cannot select
553 // only scalable fonts so we have to manually filter the results.
554 FcPattern* match = nullptr;
555 for (int i = 0; i < font_set->nfont; ++i) {
556 FcPattern* current = font_set->fonts[i];
557 if (this->isValidPattern(current)) {
558 match = current;
559 break;
560 }
561 }
562
563 if (match && !IsFallbackFontAllowed(family)) {
564 bool acceptable_substitute = false;
565 for (int id = 0; id < 255; ++id) {
566 const char* post_match_family = get_string(match, FC_FAMILY, id);
567 if (!post_match_family)
568 break;
569 acceptable_substitute =
570 (strcasecmp(post_config_family, post_match_family) == 0 ||
571 // Workaround for Issue 12530:
572 // requested family: "Bitstream Vera Sans"
573 // post_config_family: "Arial"
574 // post_match_family: "Bitstream Vera Sans"
575 // -> We should treat this case as a good match.
576 strcasecmp(family.c_str(), post_match_family) == 0) ||
577 IsMetricCompatibleReplacement(family.c_str(), post_match_family);
578 if (acceptable_substitute)
579 break;
580 }
581 if (!acceptable_substitute)
582 return nullptr;
583 }
584
585 return match;
586}
587
589 SkFontStyle style,
590 FontIdentity* outIdentity,
591 SkString* outFamilyName,
592 SkFontStyle* outStyle) {
593 SkString familyStr(familyName ? familyName : "");
594 if (familyStr.size() > kMaxFontFamilyLength) {
595 return false;
596 }
597
598 FcConfig* fc = fFC;
599 UniqueFCConfig fcStorage;
600 if (!fc) {
601 fcStorage.reset(FcConfigReference(nullptr));
602 fc = fcStorage.get();
603 }
604
605 FCLocker lock;
606 FcPattern* pattern = FcPatternCreate();
607
608 if (familyName) {
609 FcPatternAddString(pattern, FC_FAMILY, (const FcChar8*)familyName);
610 }
611 fcpattern_from_skfontstyle(style, pattern);
612
613 FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
614
615 FcConfigSubstitute(fc, pattern, FcMatchPattern);
616 FcDefaultSubstitute(pattern);
617
618 // Font matching:
619 // CSS often specifies a fallback list of families:
620 // font-family: a, b, c, serif;
621 // However, fontconfig will always do its best to find *a* font when asked
622 // for something so we need a way to tell if the match which it has found is
623 // "good enough" for us. Otherwise, we can return nullptr which gets piped up
624 // and lets WebKit know to try the next CSS family name. However, fontconfig
625 // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we
626 // wish to support that.
627 //
628 // Thus, if a specific family is requested we set @family_requested. Then we
629 // record two strings: the family name after config processing and the
630 // family name after resolving. If the two are equal, it's a good match.
631 //
632 // So consider the case where a user has mapped Arial to Helvetica in their
633 // config.
634 // requested family: "Arial"
635 // post_config_family: "Helvetica"
636 // post_match_family: "Helvetica"
637 // -> good match
638 //
639 // and for a missing font:
640 // requested family: "Monaco"
641 // post_config_family: "Monaco"
642 // post_match_family: "Times New Roman"
643 // -> BAD match
644 //
645 // However, we special-case fallback fonts; see IsFallbackFontAllowed().
646
647 const char* post_config_family = get_string(pattern, FC_FAMILY);
648 if (!post_config_family) {
649 // we can just continue with an empty name, e.g. default font
650 post_config_family = "";
651 }
652
653 FcResult result;
654 FcFontSet* font_set = FcFontSort(fc, pattern, 0, nullptr, &result);
655 if (!font_set) {
656 FcPatternDestroy(pattern);
657 return false;
658 }
659
660 FcPattern* match = this->MatchFont(font_set, post_config_family, familyStr);
661 if (!match) {
662 FcPatternDestroy(pattern);
663 FcFontSetDestroy(font_set);
664 return false;
665 }
666
667 FcPatternDestroy(pattern);
668
669 // From here out we just extract our results from 'match'
670
671 post_config_family = get_string(match, FC_FAMILY);
672 if (!post_config_family) {
673 FcFontSetDestroy(font_set);
674 return false;
675 }
676
677 const char* c_filename = get_string(match, FC_FILE);
678 if (!c_filename) {
679 FcFontSetDestroy(font_set);
680 return false;
681 }
682 const char* sysroot = (const char*)FcConfigGetSysRoot(fc);
683 SkString resolvedFilename;
684 if (sysroot) {
685 resolvedFilename = sysroot;
686 resolvedFilename += c_filename;
687 c_filename = resolvedFilename.c_str();
688 }
689
690 int face_index = get_int(match, FC_INDEX, 0);
691
692 FcFontSetDestroy(font_set);
693
694 if (outIdentity) {
695 outIdentity->fTTCIndex = face_index;
696 outIdentity->fString.set(c_filename);
697 }
698 if (outFamilyName) {
699 outFamilyName->set(post_config_family);
700 }
701 if (outStyle) {
703 }
704 return true;
705}
706
708 return SkStream::MakeFromFile(identity.fString.c_str()).release();
709}
SkStrokeRec::Style fStyle
#define SkASSERT(cond)
Definition: SkAssert.h:116
static uint32_t get_int(const uint8_t *buffer, uint32_t i)
Definition: SkCodecPriv.h:168
#define kMaxFontFamilyLength
static const char * get_string(FcPattern *pattern, const char field[], int index=0)
#define FC_WEIGHT_DEMILIGHT
static SkFontStyle skfontstyle_from_fcpattern(FcPattern *pattern)
static SkScalar map_ranges(SkScalar val, MapRanges const ranges[], int rangesCount)
static int map_range(SkScalar value, SkScalar old_min, SkScalar old_max, SkScalar new_min, SkScalar new_max)
static void fcpattern_from_skfontstyle(SkFontStyle style, FcPattern *pattern)
#define SkScalarRoundToInt(x)
Definition: SkScalar.h:37
SkDEBUGCODE(SK_SPI) SkThreadID SkGetThreadID()
SkStreamAsset * openStream(const FontIdentity &) override
virtual bool isAccessible(const char *filename)
bool matchFamilyName(const char familyName[], SkFontStyle requested, FontIdentity *outFontIdentifier, SkString *outFamilyName, SkFontStyle *outStyle) override
Slant slant() const
Definition: SkFontStyle.h:64
int width() const
Definition: SkFontStyle.h:63
int weight() const
Definition: SkFontStyle.h:62
static std::unique_ptr< SkStreamAsset > MakeFromFile(const char path[])
Definition: SkStream.cpp:922
size_t size() const
Definition: SkString.h:131
void set(const SkString &src)
Definition: SkString.h:186
bool isEmpty() const
Definition: SkString.h:130
const char * c_str() const
Definition: SkString.h:133
float SkScalar
Definition: extension.cpp:12
uint8_t value
GAsyncResult * result
def match(bench, filt)
Definition: benchmark.py:23
DEF_SWITCHES_START aot vmservice shared library name
Definition: switches.h:32
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace buffer
Definition: switches.h:126
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Definition: switches.h:259
int32_t width
size_t readFromMemory(const void *buffer, size_t length)
size_t writeToMemory(void *buffer=nullptr) const
const uintptr_t id