Refactoring cfx_fontmapper

core/fxge/ge/cfx_fontmapper.cpp

 // Copyright 2016 PDFium Authors. All rights reserved.
 // 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/include/cfx_fontmapper.h"
 
 #include "core/fxge/include/ifx_systemfontinfo.h"
 #include "core/fxge/include/fx_font.h"
@@ skipping 143 matching lines @@
     {932, 128},  {936, 134},  {949, 129},  {950, 136},  {1250, 238},
     {1251, 204}, {1252, 0},   {1253, 161}, {1254, 162}, {1255, 177},
     {1256, 178}, {1257, 186}, {1258, 163}, {1361, 130}, {10000, 77},
     {10001, 78}, {10002, 81}, {10003, 79}, {10004, 84}, {10005, 83},
     {10006, 85}, {10007, 89}, {10008, 80}, {10021, 87}, {10029, 88},
     {10081, 86},
 };
 
 int CompareFontFamilyString(const void* key, const void* element) {
   CFX_ByteString str_key((const FX_CHAR*)key);
-  if (str_key.Find(((AltFontFamily*)element)->m_pFontName) != -1) {
+  if (str_key.Find(((AltFontFamily*)element)->m_pFontName) != -1)
     return 0;
-  }
   return FXSYS_stricmp((const FX_CHAR*)key,
                        ((AltFontFamily*)element)->m_pFontName);
 }
 
 int CompareString(const void* key, const void* element) {
   return FXSYS_stricmp((const FX_CHAR*)key, ((AltFontName*)element)->m_pName);
 }
 
 CFX_ByteString TT_NormalizeName(const FX_CHAR* family) {
   CFX_ByteString norm(family);
   norm.Remove(' ');
   norm.Remove('-');
   norm.Remove(',');
   int pos = norm.Find('+');
-  if (pos > 0) {
+  if (pos > 0)
     norm = norm.Left(pos);
-  }
   norm.MakeLower();
   return norm;
 }
 
 uint8_t GetCharsetFromCodePage(uint16_t codepage) {
   const CODEPAGE_MAP* pEnd =
       g_Codepage2CharsetTable + FX_ArraySize(g_Codepage2CharsetTable);
   const CODEPAGE_MAP* pCharmap =
       std::lower_bound(g_Codepage2CharsetTable, pEnd, codepage,
                        [](const CODEPAGE_MAP& charset, uint16_t page) {
                          return charset.codepage < page;
                        });
   if (pCharmap < pEnd && codepage == pCharmap->codepage)
     return pCharmap->charset;
   return FXFONT_DEFAULT_CHARSET;
 }
 
 CFX_ByteString GetFontFamily(CFX_ByteString fontName, int nStyle) {
   if (fontName.Find("Script") >= 0) {
-    if ((nStyle & FX_FONT_STYLE_Bold) == FX_FONT_STYLE_Bold) {
+    if ((nStyle & FX_FONT_STYLE_Bold) == FX_FONT_STYLE_Bold)
       fontName = "ScriptMTBold";
-    } else if (fontName.Find("Palace") >= 0) {
+    else if (fontName.Find("Palace") >= 0)
       fontName = "PalaceScriptMT";
-    } else if (fontName.Find("French") >= 0) {
+    else if (fontName.Find("French") >= 0)
       fontName = "FrenchScriptMT";
-    } else if (fontName.Find("FreeStyle") >= 0) {
+    else if (fontName.Find("FreeStyle") >= 0)
       fontName = "FreeStyleScript";
-    }
     return fontName;
   }
   AltFontFamily* found = (AltFontFamily*)FXSYS_bsearch(
       fontName.c_str(), g_AltFontFamilies,
       sizeof g_AltFontFamilies / sizeof(AltFontFamily), sizeof(AltFontFamily),
       CompareFontFamilyString);
   return found ? CFX_ByteString(found->m_pFontFamily) : fontName;
 }
 
 CFX_ByteString ParseStyle(const FX_CHAR* pStyle, int iLen, int iIndex) {
   CFX_ByteTextBuf buf;
-  if (!iLen || iLen <= iIndex) {
+  if (!iLen || iLen <= iIndex)
     return buf.MakeString();
-  }
   while (iIndex < iLen) {
-    if (pStyle[iIndex] == ',') {
+    if (pStyle[iIndex] == ',')
       break;
-    }
     buf.AppendChar(pStyle[iIndex]);
     ++iIndex;
   }
   return buf.MakeString();
 }
 
 int32_t GetStyleType(const CFX_ByteString& bsStyle, FX_BOOL bRevert) {
   int32_t iLen = bsStyle.GetLength();
-  if (!iLen) {
+  if (!iLen)
     return -1;
-  }
   int iSize = sizeof(g_FontStyles) / sizeof(FX_FontStyle);
   const FX_FontStyle* pStyle = nullptr;
   for (int i = iSize - 1; i >= 0; --i) {
     pStyle = g_FontStyles + i;
-    if (!pStyle || pStyle->len > iLen) {
+    if (!pStyle || pStyle->len > iLen)
       continue;
-    }
     if (!bRevert) {
-      if (bsStyle.Left(pStyle->len).Compare(pStyle->style) == 0) {
+      if (bsStyle.Left(pStyle->len).Compare(pStyle->style) == 0)
         return i;
-      }
     } else {
-      if (bsStyle.Right(pStyle->len).Compare(pStyle->style) == 0) {
+      if (bsStyle.Right(pStyle->len).Compare(pStyle->style) == 0)
         return i;
-      }
     }
   }
   return -1;
 }
 
 FX_BOOL CheckSupportThirdPartFont(CFX_ByteString name, int& PitchFamily) {
   if (name == "MyriadPro") {
     PitchFamily &= ~FXFONT_FF_ROMAN;
     return TRUE;
   }
   return FALSE;
 }
 
+void UpdatePitchFamily(uint32_t flags, int& PitchFamily) {
+  if (flags & FXFONT_SERIF)
+    PitchFamily |= FXFONT_FF_ROMAN;
+  if (flags & FXFONT_SCRIPT)
+    PitchFamily |= FXFONT_FF_SCRIPT;
+  if (flags & FXFONT_FIXED_PITCH)
+    PitchFamily |= FXFONT_FF_FIXEDPITCH;
+}
+
 }  // namespace
 
 CFX_FontMapper::CFX_FontMapper(CFX_FontMgr* mgr)
     : m_bListLoaded(FALSE), m_pFontMgr(mgr) {
   m_MMFaces[0] = nullptr;
   m_MMFaces[1] = nullptr;
   FXSYS_memset(m_FoxitFaces, 0, sizeof(m_FoxitFaces));
 }
 
 CFX_FontMapper::~CFX_FontMapper() {
@@ skipping 76 matching lines @@
   m_pFontInfo->EnumFontList(this);
   m_bListLoaded = TRUE;
 }
 
 CFX_ByteString CFX_FontMapper::MatchInstalledFonts(
     const CFX_ByteString& norm_name) {
   LoadInstalledFonts();
   int i;
   for (i = pdfium::CollectionSize<int>(m_InstalledTTFonts) - 1; i >= 0; i--) {
     CFX_ByteString norm1 = TT_NormalizeName(m_InstalledTTFonts[i].c_str());
-    if (norm1 == norm_name) {
+    if (norm1 == norm_name)
       break;
-    }
   }
-  if (i < 0) {
+  if (i < 0)
     return CFX_ByteString();
-  }
   CFX_ByteString match = m_InstalledTTFonts[i];
-  if (match[0] == ' ') {
+  if (match[0] == ' ')
     match = m_InstalledTTFonts[i + 1];
-  }
   return match;
 }
 
 FXFT_Face CFX_FontMapper::UseInternalSubst(CFX_SubstFont* pSubstFont,
                                            int iBaseFont,
                                            int italic_angle,
                                            int weight,
                                            int picthfamily) {
   if (iBaseFont < 12) {
-    if (m_FoxitFaces[iBaseFont]) {
+    if (m_FoxitFaces[iBaseFont])
       return m_FoxitFaces[iBaseFont];
-    }
     const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     if (m_pFontMgr->GetBuiltinFont(iBaseFont, &pFontData, &size)) {
       m_FoxitFaces[iBaseFont] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
       return m_FoxitFaces[iBaseFont];
     }
   }
   pSubstFont->m_SubstFlags |= FXFONT_SUBST_MM;
   pSubstFont->m_ItalicAngle = italic_angle;
-  if (weight) {
+  if (weight)
     pSubstFont->m_Weight = weight;
-  }
   if (picthfamily & FXFONT_FF_ROMAN) {
     pSubstFont->m_Weight = pSubstFont->m_Weight * 4 / 5;
     pSubstFont->m_Family = "Chrome Serif";
-    if (m_MMFaces[1]) {
+    if (m_MMFaces[1])
       return m_MMFaces[1];
-    }
     const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(14, &pFontData, &size);
     m_MMFaces[1] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_MMFaces[1];
   }
   pSubstFont->m_Family = "Chrome Sans";
-  if (m_MMFaces[0]) {
+  if (m_MMFaces[0])
     return m_MMFaces[0];
-  }
   const uint8_t* pFontData = nullptr;
   uint32_t size = 0;
   m_pFontMgr->GetBuiltinFont(15, &pFontData, &size);
   m_MMFaces[0] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
   return m_MMFaces[0];
 }
 
 FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name,
                                         FX_BOOL bTrueType,
                                         uint32_t flags,
                                         int weight,
                                         int italic_angle,
                                         int WindowCP,
                                         CFX_SubstFont* pSubstFont) {
   if (!(flags & FXFONT_USEEXTERNATTR)) {
     weight = FXFONT_FW_NORMAL;
     italic_angle = 0;
   }
   CFX_ByteString SubstName = name;
   SubstName.Remove(0x20);
-  if (bTrueType) {
-    if (name[0] == '@') {
-      SubstName = name.Mid(1);
-    }
-  }
+  if (bTrueType && name[0] == '@')
+    SubstName = name.Mid(1);
   PDF_GetStandardFontName(&SubstName);
   if (SubstName == "Symbol" && !bTrueType) {
     pSubstFont->m_Family = "Chrome Symbol";
     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
-    if (m_FoxitFaces[12]) {
+    if (m_FoxitFaces[12])
       return m_FoxitFaces[12];
-    }
     const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(12, &pFontData, &size);
     m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_FoxitFaces[12];
   }
   if (SubstName == "ZapfDingbats") {
     pSubstFont->m_Family = "Chrome Dingbats";
     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
-    if (m_FoxitFaces[13]) {
+    if (m_FoxitFaces[13])
       return m_FoxitFaces[13];
-    }
     const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(13, &pFontData, &size);
     m_FoxitFaces[13] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_FoxitFaces[13];
   }
   int iBaseFont = 0;
   CFX_ByteString family, style;
   FX_BOOL bHasComma = FALSE;
   FX_BOOL bHasHypen = FALSE;
   int find = SubstName.Find(",", 0);
   if (find >= 0) {
     family = SubstName.Left(find);
     PDF_GetStandardFontName(&family);
     style = SubstName.Mid(find + 1);
     bHasComma = TRUE;
   } else {
     family = SubstName;
   }
-  for (; iBaseFont < 12; iBaseFont++)
-    if (family == CFX_ByteStringC(g_Base14FontNames[iBaseFont])) {
+  for (; iBaseFont < 12; iBaseFont++) {
+    if (family == CFX_ByteStringC(g_Base14FontNames[iBaseFont]))
       break;
-    }
+  }
   int PitchFamily = 0;
   FX_BOOL bItalic = FALSE;
   uint32_t nStyle = 0;
   FX_BOOL bStyleAvail = FALSE;
   if (iBaseFont < 12) {
-    family = g_Base14FontNames[iBaseFont];
-    if ((iBaseFont % 4) == 1 || (iBaseFont % 4) == 2) {
+    if ((iBaseFont % 4) == 1 || (iBaseFont % 4) == 2)
       nStyle |= FX_FONT_STYLE_Bold;
-    }
-    if ((iBaseFont % 4) / 2) {
+    if ((iBaseFont % 4) / 2)
       nStyle |= FX_FONT_STYLE_Italic;
-    }
-    if (iBaseFont < 4) {
+    if (iBaseFont < 4)
       PitchFamily |= FXFONT_FF_FIXEDPITCH;
-    }
-    if (iBaseFont >= 8) {
+    if (iBaseFont >= 8)
       PitchFamily |= FXFONT_FF_ROMAN;
-    }
   } else {
     if (!bHasComma) {
       find = family.ReverseFind('-');
       if (find >= 0) {
         style = family.Mid(find + 1);
         family = family.Left(find);
         bHasHypen = TRUE;
       }
     }
     if (!bHasHypen) {
       int nLen = family.GetLength();
       int32_t nRet = GetStyleType(family, TRUE);
       if (nRet > -1) {
         family = family.Left(nLen - g_FontStyles[nRet].len);
-        if (nRet == 0) {
+        if (nRet == 0)
           nStyle |= FX_FONT_STYLE_Bold;
-        }
-        if (nRet == 1) {
+        if (nRet == 1)
           nStyle |= FX_FONT_STYLE_Italic;
-        }
-        if (nRet == 2) {
+        if (nRet == 2)
           nStyle |= (FX_FONT_STYLE_Bold | FX_FONT_STYLE_Italic);
-        }
       }
     }
-    if (flags & FXFONT_SERIF) {
-      PitchFamily |= FXFONT_FF_ROMAN;
-    }
-    if (flags & FXFONT_SCRIPT) {
-      PitchFamily |= FXFONT_FF_SCRIPT;
-    }
-    if (flags & FXFONT_FIXED_PITCH) {
-      PitchFamily |= FXFONT_FF_FIXEDPITCH;
-    }
+    UpdatePitchFamily(flags, PitchFamily);
   }
   if (!style.IsEmpty()) {
     int nLen = style.GetLength();
     const FX_CHAR* pStyle = style.c_str();
     int i = 0;
     FX_BOOL bFirstItem = TRUE;
     CFX_ByteString buf;
     while (i < nLen) {
       buf = ParseStyle(pStyle, nLen, i);
       int32_t nRet = GetStyleType(buf, FALSE);
       if ((i && !bStyleAvail) || (!i && nRet < 0)) {
         family = SubstName;
         iBaseFont = 12;
         break;
       } else if (nRet >= 0) {
         bStyleAvail = TRUE;
       }
       if (nRet == 0) {
-        if (nStyle & FX_FONT_STYLE_Bold) {
+        if (nStyle & FX_FONT_STYLE_Bold)
           nStyle |= FX_FONT_STYLE_BoldBold;
-        } else {
+        else
           nStyle |= FX_FONT_STYLE_Bold;
-        }
         bFirstItem = FALSE;
       }
       if (nRet == 1) {
         if (bFirstItem) {
           nStyle |= FX_FONT_STYLE_Italic;
         } else {
           family = SubstName;
           iBaseFont = 12;
         }
         break;
       }
       if (nRet == 2) {
         nStyle |= FX_FONT_STYLE_Italic;
-        if (nStyle & FX_FONT_STYLE_Bold) {
+        if (nStyle & FX_FONT_STYLE_Bold)
           nStyle |= FX_FONT_STYLE_BoldBold;
-        } else {
+        else
           nStyle |= FX_FONT_STYLE_Bold;
-        }
         bFirstItem = FALSE;
       }
       i += buf.GetLength() + 1;
     }
   }
   weight = weight ? weight : FXFONT_FW_NORMAL;
   int old_weight = weight;
   if (nStyle) {
     weight =
         nStyle & FX_FONT_STYLE_BoldBold
             ? 900
             : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
   }
-  if (nStyle & FX_FONT_STYLE_Italic) {
+  if (nStyle & FX_FONT_STYLE_Italic)
     bItalic = TRUE;
-  }
   FX_BOOL bCJK = FALSE;
   int iExact = 0;
   int Charset = FXFONT_ANSI_CHARSET;
-  if (WindowCP) {
+  if (WindowCP)
     Charset = GetCharsetFromCodePage(WindowCP);
-  } else if (iBaseFont == 12 && (flags & FXFONT_SYMBOLIC)) {
+  else if (iBaseFont == 12 && (flags & FXFONT_SYMBOLIC))
     Charset = FXFONT_SYMBOL_CHARSET;
-  }
   if (Charset == FXFONT_SHIFTJIS_CHARSET || Charset == FXFONT_GB2312_CHARSET ||
       Charset == FXFONT_HANGEUL_CHARSET ||
       Charset == FXFONT_CHINESEBIG5_CHARSET) {
     bCJK = TRUE;
   }
   if (!m_pFontInfo) {
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
                             PitchFamily);
   }
   family = GetFontFamily(family, nStyle);
   CFX_ByteString match = MatchInstalledFonts(TT_NormalizeName(family.c_str()));
   if (match.IsEmpty() && family != SubstName &&
       (!bHasComma && (!bHasHypen || (bHasHypen && !bStyleAvail)))) {
     match = MatchInstalledFonts(TT_NormalizeName(SubstName.c_str()));
   }
   if (match.IsEmpty() && iBaseFont >= 12) {
     if (!bCJK) {
       if (!CheckSupportThirdPartFont(family, PitchFamily)) {
-        if (italic_angle != 0) {
+        if (italic_angle != 0)
           bItalic = TRUE;
-        } else {
+        else
           bItalic = FALSE;
-        }
         weight = old_weight;
       }
     } else {
       pSubstFont->m_bSubstCJK = true;
-      if (nStyle) {
+      if (nStyle)
         pSubstFont->m_WeightCJK = weight;
-      } else {
+      else
         pSubstFont->m_WeightCJK = FXFONT_FW_NORMAL;
-      }
-      if (nStyle & FX_FONT_STYLE_Italic) {
+      if (nStyle & FX_FONT_STYLE_Italic)
         pSubstFont->m_bItalicCJK = true;
-      }
     }
   } else {
     italic_angle = 0;
     weight =
         nStyle & FX_FONT_STYLE_BoldBold
             ? 900
             : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
   }
   if (!match.IsEmpty() || iBaseFont < 12) {
-    if (!match.IsEmpty()) {
+    if (!match.IsEmpty())
       family = match;
-    }
     if (iBaseFont < 12) {
       if (nStyle && !(iBaseFont % 4)) {
-        if ((nStyle & 0x3) == 1) {
+        if ((nStyle & 0x3) == 1)
           iBaseFont += 1;
-        }
-        if ((nStyle & 0x3) == 2) {
+        if ((nStyle & 0x3) == 2)
           iBaseFont += 3;
-        }
-        if ((nStyle & 0x3) == 3) {
+        if ((nStyle & 0x3) == 3)
           iBaseFont += 2;
-        }
       }
       family = g_Base14FontNames[iBaseFont];
       pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     }
   } else {
-    if (flags & FXFONT_ITALIC) {
+    if (flags & FXFONT_ITALIC)
       bItalic = TRUE;
-    }
   }
   iExact = !match.IsEmpty();
   void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily,
                                      family.c_str(), iExact);
-  if (iExact) {
+  if (iExact)
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
-  }
   if (!hFont) {
 #ifdef PDF_ENABLE_XFA
-    if (flags & FXFONT_EXACTMATCH) {
+    if (flags & FXFONT_EXACTMATCH)
       return nullptr;
-    }
 #endif  // PDF_ENABLE_XFA
     if (bCJK) {
-      if (italic_angle != 0) {
+      if (italic_angle != 0)
         bItalic = TRUE;
-      } else {
+      else
         bItalic = FALSE;
-      }
       weight = old_weight;
     }
     if (!match.IsEmpty()) {
       hFont = m_pFontInfo->GetFont(match.c_str());
       if (!hFont) {
         return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
                                 PitchFamily);
       }
     } else {
       if (Charset == FXFONT_SYMBOL_CHARSET) {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_
         if (SubstName == "Symbol") {
           pSubstFont->m_Family = "Chrome Symbol";
           pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
           pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
-          if (m_FoxitFaces[12]) {
+          if (m_FoxitFaces[12])
             return m_FoxitFaces[12];
-          }
           const uint8_t* pFontData = nullptr;
           uint32_t size = 0;
           m_pFontMgr->GetBuiltinFont(12, &pFontData, &size);
           m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
           return m_FoxitFaces[12];
         }
 #endif
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
         return FindSubstFont(family, bTrueType, flags & ~FXFONT_SYMBOLIC,
                              weight, italic_angle, 0, pSubstFont);
@@ skipping 14 matching lines @@
                                 PitchFamily);
       }
       hFont = m_pFontInfo->GetFont(it->name.c_str());
     }
   }
   pSubstFont->m_ExtHandle = m_pFontInfo->RetainFont(hFont);
   if (!hFont)
     return nullptr;
 
   m_pFontInfo->GetFaceName(hFont, SubstName);
-  if (Charset == FXFONT_DEFAULT_CHARSET) {
+  if (Charset == FXFONT_DEFAULT_CHARSET)
     m_pFontInfo->GetFontCharset(hFont, Charset);
-  }
   uint32_t ttc_size = m_pFontInfo->GetFontData(hFont, kTableTTCF, nullptr, 0);
   uint32_t font_size = m_pFontInfo->GetFontData(hFont, 0, nullptr, 0);
   if (font_size == 0 && ttc_size == 0) {
     m_pFontInfo->DeleteFont(hFont);
     return nullptr;
   }
   FXFT_Face face = nullptr;
-  if (ttc_size) {
-    uint8_t temp[1024];
-    m_pFontInfo->GetFontData(hFont, kTableTTCF, temp, 1024);
-    uint32_t checksum = 0;
-    for (int i = 0; i < 256; i++) {
-      checksum += ((uint32_t*)temp)[i];
-    }
-    uint8_t* pFontData;
-    face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum,
-                                        ttc_size - font_size, pFontData);
-    if (!face) {
-      pFontData = FX_Alloc(uint8_t, ttc_size);
-      m_pFontInfo->GetFontData(hFont, kTableTTCF, pFontData, ttc_size);
-      face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData,
-                                          ttc_size, ttc_size - font_size);
-    }
-  } else {
-    uint8_t* pFontData;
-    face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
-    if (!face) {
-      pFontData = FX_Alloc(uint8_t, font_size);
-      m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
-      face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData,
-                                       font_size,
-                                       m_pFontInfo->GetFaceIndex(hFont));
-    }
-  }
+  if (ttc_size)
+    face = GetCachedTTCFace(hFont, kTableTTCF, ttc_size, font_size);
+  else
+    face = GetCachedFace(hFont, SubstName, weight, bItalic, font_size);
   if (!face) {
     m_pFontInfo->DeleteFont(hFont);
     return nullptr;
   }
   pSubstFont->m_Family = SubstName;
   pSubstFont->m_Charset = Charset;
   FX_BOOL bNeedUpdateWeight = FALSE;
   if (FXFT_Is_Face_Bold(face)) {
-    if (weight == FXFONT_FW_BOLD) {
+    if (weight == FXFONT_FW_BOLD)
       bNeedUpdateWeight = FALSE;
-    } else {
+    else
       bNeedUpdateWeight = TRUE;
-    }
   } else {
-    if (weight == FXFONT_FW_NORMAL) {
+    if (weight == FXFONT_FW_NORMAL)
       bNeedUpdateWeight = FALSE;
-    } else {
+    else
       bNeedUpdateWeight = TRUE;
-    }
   }
-  if (bNeedUpdateWeight) {
+  if (bNeedUpdateWeight)
     pSubstFont->m_Weight = weight;
-  }
   if (bItalic && !FXFT_Is_Face_Italic(face)) {
-    if (italic_angle == 0) {
+    if (italic_angle == 0)
       italic_angle = -12;
-    } else if (FXSYS_abs(italic_angle) < 5) {
+    else if (FXSYS_abs(italic_angle) < 5)
       italic_angle = 0;
-    }
     pSubstFont->m_ItalicAngle = italic_angle;
   }
   m_pFontInfo->DeleteFont(hFont);
   return face;
 }
+
 #ifdef PDF_ENABLE_XFA
 FXFT_Face CFX_FontMapper::FindSubstFontByUnicode(uint32_t dwUnicode,
                                                  uint32_t flags,
                                                  int weight,
                                                  int italic_angle) {
   if (!m_pFontInfo)
     return nullptr;
 
   FX_BOOL bItalic = (flags & FXFONT_ITALIC) != 0;
   int PitchFamily = 0;
-  if (flags & FXFONT_SERIF) {
-    PitchFamily |= FXFONT_FF_ROMAN;
-  }
-  if (flags & FXFONT_SCRIPT) {
-    PitchFamily |= FXFONT_FF_SCRIPT;
-  }
-  if (flags & FXFONT_FIXED_PITCH) {
-    PitchFamily |= FXFONT_FF_FIXEDPITCH;
-  }
+  UpdatePitchFamily(flags, PitchFamily);
   void* hFont =
       m_pFontInfo->MapFontByUnicode(dwUnicode, weight, bItalic, PitchFamily);
   if (!hFont)
     return nullptr;
 
   uint32_t ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, nullptr, 0);
   uint32_t font_size = m_pFontInfo->GetFontData(hFont, 0, nullptr, 0);
   if (font_size == 0 && ttc_size == 0) {
     m_pFontInfo->DeleteFont(hFont);
     return nullptr;
   }
   FXFT_Face face = nullptr;
   if (ttc_size) {
-    uint8_t temp[1024];
-    m_pFontInfo->GetFontData(hFont, 0x74746366, temp, 1024);
-    uint32_t checksum = 0;
-    for (int i = 0; i < 256; i++) {
-      checksum += ((uint32_t*)temp)[i];
-    }
-    uint8_t* pFontData;
-    face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum,
-                                        ttc_size - font_size, pFontData);
-    if (!face) {
-      pFontData = FX_Alloc(uint8_t, ttc_size);
-      if (pFontData) {
-        m_pFontInfo->GetFontData(hFont, 0x74746366, pFontData, ttc_size);
-        face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData,
-                                            ttc_size, ttc_size - font_size);
-      }
-    }
+    face = GetCachedTTCFace(hFont, 0x74746366, ttc_size, font_size);
   } else {
     CFX_ByteString SubstName;
     m_pFontInfo->GetFaceName(hFont, SubstName);
-    uint8_t* pFontData;
-    face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
-    if (!face) {
-      pFontData = FX_Alloc(uint8_t, font_size);
-      if (!pFontData) {
-        m_pFontInfo->DeleteFont(hFont);
-        return nullptr;
-      }
-      m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
-      face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData,
-                                       font_size,
-                                       m_pFontInfo->GetFaceIndex(hFont));
-    }
+    face = GetCachedFace(hFont, SubstName, weight, bItalic, font_size);
   }
   m_pFontInfo->DeleteFont(hFont);
   return face;
 }
 #endif  // PDF_ENABLE_XFA
 
 int CFX_FontMapper::GetFaceSize() const {
   return pdfium::CollectionSize<int>(m_FaceArray);
 }
 
 FX_BOOL CFX_FontMapper::IsBuiltinFace(const FXFT_Face face) const {
   for (size_t i = 0; i < MM_FACE_COUNT; ++i) {
-    if (m_MMFaces[i] == face) {
+    if (m_MMFaces[i] == face)
       return TRUE;
-    }
   }
   for (size_t i = 0; i < FOXIT_FACE_COUNT; ++i) {
-    if (m_FoxitFaces[i] == face) {
+    if (m_FoxitFaces[i] == face)
       return TRUE;
-    }
   }
   return FALSE;
 }
 
+FXFT_Face CFX_FontMapper::GetCachedTTCFace(void* hFont,
+                                           const uint32_t tableTTCF,
+                                           uint32_t ttc_size,
+                                           uint32_t font_size) {
+  FXFT_Face face;
+  uint8_t temp[1024];
+  m_pFontInfo->GetFontData(hFont, tableTTCF, temp, 1024);
+  uint32_t checksum = 0;
+  for (int i = 0; i < 256; i++)
+    checksum += ((uint32_t*)temp)[i];
+  uint8_t* pFontData;
+  face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum, ttc_size - font_size,
+                                      pFontData);
+  if (!face) {
+    pFontData = FX_Alloc(uint8_t, ttc_size);
+    m_pFontInfo->GetFontData(hFont, tableTTCF, pFontData, ttc_size);
+    face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData, ttc_size,
+                                        ttc_size - font_size);
+  }
+  return face;
+}
+
+FXFT_Face CFX_FontMapper::GetCachedFace(void* hFont,
+                                        CFX_ByteString SubstName,
+                                        int weight,
+                                        FX_BOOL bItalic,
+                                        uint32_t font_size) {
+  FXFT_Face face;
+  uint8_t* pFontData;
+  face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
+  if (!face) {
+    pFontData = FX_Alloc(uint8_t, font_size);
+    m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
+    face =
+        m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData,
+                                  font_size, m_pFontInfo->GetFaceIndex(hFont));
+  }
+  return face;
+}
+
 int PDF_GetStandardFontName(CFX_ByteString* name) {
   AltFontName* found = static_cast<AltFontName*>(
       FXSYS_bsearch(name->c_str(), g_AltFontNames, FX_ArraySize(g_AltFontNames),
                     sizeof(AltFontName), CompareString));
   if (!found)
     return -1;
 
   *name = g_Base14FontNames[found->m_Index];
   return found->m_Index;
 }