| // Copyright 2016 The PDFium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | |
| #include "core/fxge/cfx_folderfontinfo.h" | |
| #include <array> | |
| #include <iterator> | |
| #include <limits> | |
| #include <utility> | |
| #include "build/build_config.h" | |
| #include "core/fxcrt/byteorder.h" | |
| #include "core/fxcrt/check_op.h" | |
| #include "core/fxcrt/compiler_specific.h" | |
| #include "core/fxcrt/containers/contains.h" | |
| #include "core/fxcrt/fixed_size_data_vector.h" | |
| #include "core/fxcrt/fx_codepage.h" | |
| #include "core/fxcrt/fx_extension.h" | |
| #include "core/fxcrt/fx_folder.h" | |
| #include "core/fxcrt/fx_safe_types.h" | |
| #include "core/fxcrt/fx_system.h" | |
| #include "core/fxcrt/span_io.h" | |
| #include "core/fxge/cfx_fontmapper.h" | |
| #include "core/fxge/fx_font.h" | |
| namespace { | |
| struct FontSubst { | |
| const char* name_; | |
| const char* subst_name_; | |
| }; | |
| constexpr auto kBase14Substs = std::to_array<const FontSubst>({ | |
| {"Courier", "Courier New"}, | |
| {"Courier-Bold", "Courier New Bold"}, | |
| {"Courier-BoldOblique", "Courier New Bold Italic"}, | |
| {"Courier-Oblique", "Courier New Italic"}, | |
| {"Helvetica", "Arial"}, | |
| {"Helvetica-Bold", "Arial Bold"}, | |
| {"Helvetica-BoldOblique", "Arial Bold Italic"}, | |
| {"Helvetica-Oblique", "Arial Italic"}, | |
| {"Times-Roman", "Times New Roman"}, | |
| {"Times-Bold", "Times New Roman Bold"}, | |
| {"Times-BoldItalic", "Times New Roman Bold Italic"}, | |
| {"Times-Italic", "Times New Roman Italic"}, | |
| }); | |
| // Used with std::unique_ptr to automatically call fclose(). | |
| struct FxFileCloser { | |
| inline void operator()(FILE* h) const { | |
| if (h) { | |
| fclose(h); | |
| } | |
| } | |
| }; | |
| std::optional<FixedSizeDataVector<uint8_t>> DataVectorAtLocation( | |
| FILE* file, | |
| FX_FILESIZE filesize, | |
| const FontTableLocation& loc) { | |
| FX_SAFE_FILESIZE safe_end = loc.offset; | |
| safe_end += loc.size; | |
| if (!safe_end.IsValid() || safe_end.ValueOrDie() > filesize) { | |
| return std::nullopt; | |
| } | |
| auto result_data = FixedSizeDataVector<uint8_t>::Uninit(loc.size); | |
| if (fseek(file, loc.offset, SEEK_SET) < 0 || | |
| fxcrt::spanread(result_data.span(), file).size() != loc.size) { | |
| return std::nullopt; | |
| } | |
| return std::move(result_data); | |
| } | |
| } // namespace | |
| // static | |
| bool CFX_FolderFontInfo::FindFamilyNameMatch( | |
| ByteStringView family_name, | |
| const ByteString& installed_font_name) { | |
| std::optional<size_t> result = installed_font_name.Find(family_name, 0); | |
| if (!result.has_value()) { | |
| return false; | |
| } | |
| size_t next_index = result.value() + family_name.GetLength(); | |
| // Rule out the case that |family_name| is a substring of | |
| // |installed_font_name| but their family names are actually different words. | |
| // For example: "Univers" and "Universal" are not a match because they have | |
| // different family names, but "Univers" and "Univers Bold" are a match. | |
| if (installed_font_name.IsValidIndex(next_index) && | |
| FXSYS_IsLowerASCII(installed_font_name[next_index])) { | |
| return false; | |
| } | |
| return true; | |
| } | |
| // static | |
| ByteString CFX_FolderFontInfo::ReadStringFromFile(FILE* pFile, uint32_t size) { | |
| ByteString result; | |
| { | |
| // Span's lifetime must end before ReleaseBuffer() below. | |
| pdfium::span<char> buffer = result.GetBuffer(size); | |
| if (fxcrt::spanread(buffer.first(size), pFile).size() != size) { | |
| return ByteString(); | |
| } | |
| } | |
| result.ReleaseBuffer(size); | |
| return result; | |
| } | |
| CFX_FolderFontInfo::CFX_FolderFontInfo() = default; | |
| CFX_FolderFontInfo::~CFX_FolderFontInfo() = default; | |
| void CFX_FolderFontInfo::AddPath(const ByteString& path) { | |
| path_list_.push_back(path); | |
| } | |
| void CFX_FolderFontInfo::EnumFontList(CFX_FontMapper* pMapper) { | |
| for (const auto& path : path_list_) { | |
| ScanPath(pMapper, path); | |
| } | |
| } | |
| void CFX_FolderFontInfo::ScanPath(CFX_FontMapper* mapper, | |
| const ByteString& path) { | |
| std::unique_ptr<FX_Folder> handle = FX_Folder::OpenFolder(path); | |
| if (!handle) { | |
| return; | |
| } | |
| ByteString filename; | |
| bool bFolder; | |
| while (handle->GetNextFile(&filename, &bFolder)) { | |
| if (bFolder) { | |
| if (filename == "." || filename == "..") { | |
| continue; | |
| } | |
| } else { | |
| ByteString ext = filename.Last(4); | |
| ext.MakeLower(); | |
| if (ext != ".ttf" && ext != ".ttc" && ext != ".otf") { | |
| continue; | |
| } | |
| } | |
| ByteString fullpath = path; | |
| #if BUILDFLAG(IS_WIN) | |
| fullpath += "\\"; | |
| #else | |
| fullpath += "/"; | |
| #endif | |
| fullpath += filename; | |
| bFolder ? ScanPath(mapper, fullpath) : ScanFile(mapper, fullpath); | |
| } | |
| } | |
| void CFX_FolderFontInfo::ScanFile(CFX_FontMapper* mapper, | |
| const ByteString& path) { | |
| std::unique_ptr<FILE, FxFileCloser> pFile(fopen(path.c_str(), "rb")); | |
| if (!pFile) { | |
| return; | |
| } | |
| fseek(pFile.get(), 0, SEEK_END); | |
| FX_FILESIZE filesize = ftell(pFile.get()); | |
| fseek(pFile.get(), 0, SEEK_SET); | |
| uint8_t buffer[12]; | |
| if (fxcrt::spanread(buffer, pFile.get()).size() != sizeof(buffer)) { | |
| return; | |
| } | |
| uint32_t magic = fxcrt::GetUInt32MSBFirst(pdfium::span(buffer).first<4u>()); | |
| if (magic != SystemFontInfoIface::kTableTTCF) { | |
| ReportFace(mapper, path, pFile.get(), filesize, 0); | |
| return; | |
| } | |
| uint32_t nFaces = | |
| fxcrt::GetUInt32MSBFirst(pdfium::span(buffer).subspan<8u, 4u>()); | |
| FX_SAFE_SIZE_T safe_face_bytes = nFaces; | |
| safe_face_bytes *= 4; | |
| if (!safe_face_bytes.IsValid()) { | |
| return; | |
| } | |
| auto offsets = | |
| FixedSizeDataVector<uint8_t>::Uninit(safe_face_bytes.ValueOrDie()); | |
| if (fxcrt::spanread(offsets.span(), pFile.get()).size() != offsets.size()) { | |
| return; | |
| } | |
| for (uint32_t i = 0; i < nFaces; i++) { | |
| ReportFace(mapper, path, pFile.get(), filesize, | |
| fxcrt::GetUInt32MSBFirst(offsets.subspan(i * 4).first<4u>())); | |
| } | |
| } | |
| void CFX_FolderFontInfo::ReportFace(CFX_FontMapper* mapper, | |
| const ByteString& path, | |
| FILE* pFile, | |
| FX_FILESIZE filesize, | |
| uint32_t offset) { | |
| if (fseek(pFile, offset, SEEK_SET) < 0) { | |
| return; | |
| } | |
| uint8_t buffer[12]; | |
| if (fxcrt::spanread(buffer, pFile).size() != sizeof(buffer)) { | |
| return; | |
| } | |
| uint16_t nTables = | |
| fxcrt::GetUInt16MSBFirst(pdfium::span(buffer).subspan<4, 2>()); | |
| ByteString tables = ReadStringFromFile(pFile, nTables * 16); | |
| if (tables.IsEmpty()) { | |
| return; | |
| } | |
| constexpr uint32_t kNameTag = CFX_FontMapper::MakeTag('n', 'a', 'm', 'e'); | |
| std::optional<FontTableLocation> loc = | |
| FindFontTableLocation(tables.unsigned_span(), kNameTag); | |
| if (!loc) { | |
| return; | |
| } | |
| std::optional<FixedSizeDataVector<uint8_t>> names_data = | |
| DataVectorAtLocation(pFile, filesize, *loc); | |
| if (!names_data) { | |
| return; | |
| } | |
| ByteString facename = GetNameFromTT(names_data->span(), 1); | |
| if (facename.IsEmpty()) { | |
| return; | |
| } | |
| ByteString style = GetNameFromTT(names_data->span(), 2); | |
| if (style != "Regular") { | |
| facename += " " + style; | |
| } | |
| if (pdfium::Contains(font_list_, facename)) { | |
| return; | |
| } | |
| auto pInfo = | |
| std::make_unique<FontFaceInfo>(path, facename, tables, offset, filesize); | |
| static constexpr uint32_t kOs2Tag = | |
| CFX_FontMapper::MakeTag('O', 'S', '/', '2'); | |
| std::optional<FontTableLocation> os2_loc = | |
| FindFontTableLocation(tables.unsigned_span(), kOs2Tag); | |
| // `codepages` corresponds to OS/2 table ulCodePageRange1. | |
| // See https://learn.microsoft.com/en-us/typography/opentype/spec/os2 | |
| uint32_t codepages = 0; | |
| if (os2_loc) { | |
| std::optional<FixedSizeDataVector<uint8_t>> os2_data = | |
| DataVectorAtLocation(pFile, filesize, *os2_loc); | |
| if (os2_data) { | |
| codepages = GetCodePageRangeFromOS2(os2_data->span()); | |
| } | |
| } | |
| if (codepages) { | |
| if (codepages & (1U << 1)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kMSWin_EasternEuropean); | |
| pInfo->charsets_ |= FX_CharsetFlag::kMSWin_EasternEuropean; | |
| } | |
| if (codepages & (1U << 2)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kMSWin_Cyrillic); | |
| pInfo->charsets_ |= FX_CharsetFlag::kMSWin_Cyrillic; | |
| } | |
| if (codepages & (1U << 3)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kMSWin_Greek); | |
| pInfo->charsets_ |= FX_CharsetFlag::kMSWin_Greek; | |
| } | |
| if (codepages & (1U << 4)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kMSWin_Turkish); | |
| pInfo->charsets_ |= FX_CharsetFlag::kMSWin_Turkish; | |
| } | |
| if (codepages & (1U << 5)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kMSWin_Hebrew); | |
| pInfo->charsets_ |= FX_CharsetFlag::kMSWin_Hebrew; | |
| } | |
| if (codepages & (1U << 6)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kMSWin_Arabic); | |
| pInfo->charsets_ |= FX_CharsetFlag::kMSWin_Arabic; | |
| } | |
| if (codepages & (1U << 7)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kMSWin_Baltic); | |
| pInfo->charsets_ |= FX_CharsetFlag::kMSWin_Baltic; | |
| } | |
| if (codepages & (1U << 8)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kMSWin_Vietnamese); | |
| pInfo->charsets_ |= FX_CharsetFlag::kMSWin_Vietnamese; | |
| } | |
| if (codepages & (1U << 16)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kThai); | |
| pInfo->charsets_ |= FX_CharsetFlag::kThai; | |
| } | |
| if (codepages & (1U << 17)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kShiftJIS); | |
| pInfo->charsets_ |= FX_CharsetFlag::kShiftJIS; | |
| } | |
| if (codepages & (1U << 18)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kChineseSimplified); | |
| pInfo->charsets_ |= FX_CharsetFlag::kChineseSimplified; | |
| } | |
| if (codepages & (1U << 19)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kHangul); | |
| pInfo->charsets_ |= FX_CharsetFlag::kHangul; | |
| } | |
| if (codepages & (1U << 20)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kChineseTraditional); | |
| pInfo->charsets_ |= FX_CharsetFlag::kChineseTraditional; | |
| } | |
| if (codepages & (1U << 21)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kJohab); | |
| pInfo->charsets_ |= FX_CharsetFlag::kJohab; | |
| } | |
| if (codepages & (1U << 30)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kOEM); | |
| pInfo->charsets_ |= FX_CharsetFlag::kOEM; | |
| } | |
| if (codepages & (1U << 31)) { | |
| mapper->AddInstalledFont(facename, FX_Charset::kSymbol); | |
| pInfo->charsets_ |= FX_CharsetFlag::kSymbol; | |
| } | |
| } | |
| static constexpr uint32_t kMaxpTag = | |
| CFX_FontMapper::MakeTag('m', 'a', 'x', 'p'); | |
| std::optional<FontTableLocation> maxp_loc = | |
| FindFontTableLocation(tables.unsigned_span(), kMaxpTag); | |
| if (maxp_loc) { | |
| std::optional<FixedSizeDataVector<uint8_t>> maxp_data = | |
| DataVectorAtLocation(pFile, filesize, *maxp_loc); | |
| if (maxp_data) { | |
| pInfo->glyph_count_ = GetGlyphCountFromMaxp(maxp_data->span()); | |
| } | |
| } | |
| mapper->AddInstalledFont(facename, FX_Charset::kANSI); | |
| pInfo->charsets_ |= FX_CharsetFlag::kANSI; | |
| pInfo->styles_ = 0; | |
| if (style.Contains("Bold")) { | |
| pInfo->styles_ |= pdfium::kFontStyleForceBold; | |
| } | |
| if (style.Contains("Italic") || style.Contains("Oblique")) { | |
| pInfo->styles_ |= pdfium::kFontStyleItalic; | |
| } | |
| if (facename.Contains("Serif")) { | |
| pInfo->styles_ |= pdfium::kFontStyleSerif; | |
| } | |
| font_list_[facename] = std::move(pInfo); | |
| } | |
| void* CFX_FolderFontInfo::GetSubstFont(const ByteString& face) { | |
| for (size_t iBaseFont = 0; iBaseFont < std::size(kBase14Substs); | |
| iBaseFont++) { | |
| if (face == kBase14Substs[iBaseFont].name_) { | |
| return GetFont(kBase14Substs[iBaseFont].subst_name_); | |
| } | |
| } | |
| return nullptr; | |
| } | |
| void* CFX_FolderFontInfo::FindFont(int weight, | |
| bool italic, | |
| FX_Charset charset, | |
| int pitch_family, | |
| const ByteString& family, | |
| bool must_match_name) { | |
| FontFaceInfo* pFind = nullptr; | |
| FX_CharsetFlag charset_flag = FX_CharsetFlagForCharset(charset); | |
| int32_t iBestSimilar = 0; | |
| if (must_match_name) { | |
| // Try a direct lookup for either a perfect score or to determine a | |
| // baseline similarity score. | |
| auto direct_it = font_list_.find(family); | |
| if (direct_it != font_list_.end()) { | |
| FontFaceInfo* font = direct_it->second.get(); | |
| if (font->IsEligibleForFindFont(charset_flag, charset)) { | |
| iBestSimilar = font->SimilarityScore(weight, italic, pitch_family, | |
| must_match_name); | |
| pFind = font; | |
| if (iBestSimilar == FontFaceInfo::kSimilarityScoreMax) { | |
| return font; | |
| } | |
| } | |
| } | |
| } | |
| ByteStringView bsFamily = family.AsStringView(); | |
| for (const auto& it : font_list_) { | |
| FontFaceInfo* font = it.second.get(); | |
| if (!font->IsEligibleForFindFont(charset_flag, charset)) { | |
| continue; | |
| } | |
| int32_t iSimilarValue = font->SimilarityScore( | |
| weight, italic, pitch_family, | |
| must_match_name && | |
| bsFamily.GetLength() == font->face_name_.GetLength()); | |
| if (IsBetterMatch(font, iSimilarValue, pFind, iBestSimilar, charset, family, | |
| must_match_name)) { | |
| iBestSimilar = iSimilarValue; | |
| pFind = font; | |
| } | |
| } | |
| if (pFind) { | |
| return pFind; | |
| } | |
| if (charset == FX_Charset::kANSI && FontFamilyIsFixedPitch(pitch_family)) { | |
| auto* courier_new = GetFont("Courier New"); | |
| if (courier_new) { | |
| return courier_new; | |
| } | |
| } | |
| return nullptr; | |
| } | |
| void* CFX_FolderFontInfo::MapFont(CFX_FontMapper* mapper, | |
| int weight, | |
| bool italic, | |
| FX_Charset charset, | |
| int pitch_family, | |
| const ByteString& face) { | |
| return nullptr; | |
| } | |
| void* CFX_FolderFontInfo::GetFont(const ByteString& face) { | |
| auto it = font_list_.find(face); | |
| return it != font_list_.end() ? it->second.get() : nullptr; | |
| } | |
| size_t CFX_FolderFontInfo::GetFontData(void* hFont, | |
| uint32_t table, | |
| pdfium::span<uint8_t> buffer) { | |
| if (!hFont) { | |
| return 0; | |
| } | |
| const FontFaceInfo* font = static_cast<FontFaceInfo*>(hFont); | |
| uint32_t datasize = 0; | |
| uint32_t offset = 0; | |
| if (table == SystemFontInfoIface::kTableNone) { | |
| datasize = font->font_offset_ ? 0 : font->file_size_; | |
| } else if (table == SystemFontInfoIface::kTableTTCF) { | |
| datasize = font->font_offset_ ? font->file_size_ : 0; | |
| } else { | |
| std::optional<FontTableLocation> loc = | |
| FindFontTableLocation(font->font_tables_.unsigned_span(), table); | |
| if (loc) { | |
| datasize = loc->size; | |
| offset = loc->offset; | |
| } | |
| } | |
| if (!datasize || buffer.size() < datasize) { | |
| return datasize; | |
| } | |
| std::unique_ptr<FILE, FxFileCloser> pFile( | |
| fopen(font->file_path_.c_str(), "rb")); | |
| if (!pFile) { | |
| return 0; | |
| } | |
| if (fseek(pFile.get(), offset, SEEK_SET) < 0) { | |
| return 0; | |
| } | |
| if (fxcrt::spanread(buffer.first(datasize), pFile.get()).size() != datasize) { | |
| return 0; | |
| } | |
| return datasize; | |
| } | |
| void CFX_FolderFontInfo::DeleteFont(void* hFont) {} | |
| bool CFX_FolderFontInfo::GetFaceName(void* hFont, ByteString* name) { | |
| if (!hFont) { | |
| return false; | |
| } | |
| *name = static_cast<FontFaceInfo*>(hFont)->face_name_; | |
| return true; | |
| } | |
| // Check supported charsets in order of specificity (Symbol and CJK first, | |
| // then regional, then ANSI last) to ensure resolving kDefault to the most | |
| // specific charset supported by the font (e.g. preventing CJK fonts that | |
| // also support ANSI from being incorrectly resolved as ANSI). | |
| bool CFX_FolderFontInfo::GetFontCharset(void* hFont, FX_Charset* charset) { | |
| if (!hFont) { | |
| return false; | |
| } | |
| FontFaceInfo* font = static_cast<FontFaceInfo*>(hFont); | |
| if (font->charsets_ & FX_CharsetFlag::kSymbol) { | |
| *charset = FX_Charset::kSymbol; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kShiftJIS) { | |
| *charset = FX_Charset::kShiftJIS; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kChineseSimplified) { | |
| *charset = FX_Charset::kChineseSimplified; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kChineseTraditional) { | |
| *charset = FX_Charset::kChineseTraditional; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kHangul) { | |
| *charset = FX_Charset::kHangul; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kJohab) { | |
| *charset = FX_Charset::kJohab; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kMSWin_Cyrillic) { | |
| *charset = FX_Charset::kMSWin_Cyrillic; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kMSWin_Greek) { | |
| *charset = FX_Charset::kMSWin_Greek; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kMSWin_Turkish) { | |
| *charset = FX_Charset::kMSWin_Turkish; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kMSWin_Hebrew) { | |
| *charset = FX_Charset::kMSWin_Hebrew; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kMSWin_Arabic) { | |
| *charset = FX_Charset::kMSWin_Arabic; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kMSWin_Baltic) { | |
| *charset = FX_Charset::kMSWin_Baltic; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kMSWin_Vietnamese) { | |
| *charset = FX_Charset::kMSWin_Vietnamese; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kThai) { | |
| *charset = FX_Charset::kThai; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kMSWin_EasternEuropean) { | |
| *charset = FX_Charset::kMSWin_EasternEuropean; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kOEM) { | |
| *charset = FX_Charset::kOEM; | |
| return true; | |
| } | |
| if (font->charsets_ & FX_CharsetFlag::kANSI) { | |
| *charset = FX_Charset::kANSI; | |
| return true; | |
| } | |
| return false; | |
| } | |
| CFX_FolderFontInfo::FontFaceInfo::FontFaceInfo(ByteString filePath, | |
| ByteString faceName, | |
| ByteString fontTables, | |
| uint32_t fontOffset, | |
| uint32_t fileSize) | |
| : file_path_(filePath), | |
| face_name_(faceName), | |
| font_tables_(fontTables), | |
| font_offset_(fontOffset), | |
| file_size_(fileSize) {} | |
| bool CFX_FolderFontInfo::FontFaceInfo::IsEligibleForFindFont( | |
| FX_CharsetFlag flag, | |
| FX_Charset charset) const { | |
| return (charsets_ & flag) || charset == FX_Charset::kDefault; | |
| } | |
| int32_t CFX_FolderFontInfo::FontFaceInfo::SimilarityScore( | |
| int weight, | |
| bool italic, | |
| int pitch_family, | |
| bool exact_match_bonus) const { | |
| int32_t score = 0; | |
| if (FontStyleIsForceBold(styles_) == (weight > 400)) { | |
| score += 16; | |
| } | |
| if (FontStyleIsItalic(styles_) == italic) { | |
| score += 16; | |
| } | |
| if (FontStyleIsSerif(styles_) == FontFamilyIsRoman(pitch_family)) { | |
| score += 16; | |
| } | |
| if (FontStyleIsScript(styles_) == FontFamilyIsScript(pitch_family)) { | |
| score += 8; | |
| } | |
| if (FontStyleIsFixedPitch(styles_) == FontFamilyIsFixedPitch(pitch_family)) { | |
| score += 8; | |
| } | |
| if (exact_match_bonus) { | |
| score += 4; | |
| } | |
| DCHECK_LE(score, kSimilarityScoreMax); | |
| return score; | |
| } | |
| bool CFX_FolderFontInfo::IsBetterMatch(const FontFaceInfo* candidate, | |
| int32_t candidate_score, | |
| const FontFaceInfo* current_best, | |
| int32_t current_best_score, | |
| FX_Charset charset, | |
| const ByteString& family, | |
| bool must_match_name) const { | |
| // Avoid the relatively expensive FindFamilyNameMatch() unless there might | |
| // be a better match. | |
| if (candidate_score <= current_best_score) { | |
| return false; | |
| } | |
| if (!must_match_name) { | |
| return true; | |
| } | |
| return FindFamilyNameMatch(family.AsStringView(), candidate->face_name_); | |
| } |