Slightly simplify CFX_FontMapper::FindSubstFont

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/cfx_fontmapper.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "core/fxge/cfx_substfont.h"
 #include "core/fxge/fx_font.h"
 #include "core/fxge/ifx_systemfontinfo.h"
 
 #include "third_party/base/stl_util.h"
 
 #define FX_FONT_STYLE_None 0x00
 #define FX_FONT_STYLE_Bold 0x01
 #define FX_FONT_STYLE_Italic 0x02
 #define FX_FONT_STYLE_BoldBold 0x04
 
 namespace {
 
-const int kExternalFontIndex = 12;
+const int kNumStandardFonts = 14;
 
-const FX_CHAR* const g_Base14FontNames[14] = {
+const FX_CHAR* const g_Base14FontNames[kNumStandardFonts] = {
     "Courier",
     "Courier-Bold",
     "Courier-BoldOblique",
     "Courier-Oblique",
     "Helvetica",
     "Helvetica-Bold",
     "Helvetica-BoldOblique",
     "Helvetica-Oblique",
     "Times-Roman",
     "Times-Bold",
@@ skipping 341 matching lines @@
   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 < kExternalFontIndex) {
+  if (iBaseFont < kNumStandardFonts) {

[dsinclair, 2016/10/11 14:11:37]

Doesn't this change the meaning? Previously it was if < 12, now it's if < 14.

Are Symbol and ZapfDingbats considered external fonts?

[npm, 2016/10/11 14:19:55]

That is precisely what I want because I now use it for Symbol (12) and
ZapfDingbats (13). I disagree with the previous naming. Those two fonts are the
two symbolic standard fonts. The other 12 fonts are the nonsymbolic standard
fonts. 

     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;
@@ skipping 33 matching lines @@
     italic_angle = 0;
   }
   CFX_ByteString SubstName = name;
   SubstName.Remove(' ');
   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])
-      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];
+    return UseInternalSubst(pSubstFont, 12, italic_angle, weight, 0);
   }
   if (SubstName == "ZapfDingbats") {
     pSubstFont->m_Family = "Chrome Dingbats";
     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
-    pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
-    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];
+    return UseInternalSubst(pSubstFont, 13, italic_angle, weight, 0);
   }
   int iBaseFont = 0;
   CFX_ByteString family;
   CFX_ByteString style;
   bool bHasComma = false;
   bool bHasHyphen = 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 < kExternalFontIndex; iBaseFont++) {
+  for (; iBaseFont < 12; iBaseFont++) {
     if (family == CFX_ByteStringC(g_Base14FontNames[iBaseFont]))
       break;
   }
   int PitchFamily = 0;
   bool bItalic = false;
   uint32_t nStyle = 0;
   bool bStyleAvail = false;
-  if (iBaseFont < kExternalFontIndex) {
+  if (iBaseFont < 12) {
     if ((iBaseFont % 4) == 1 || (iBaseFont % 4) == 2)
       nStyle |= FX_FONT_STYLE_Bold;
     if ((iBaseFont % 4) / 2)
       nStyle |= FX_FONT_STYLE_Italic;
     if (iBaseFont < 4)
       PitchFamily |= FXFONT_FF_FIXEDPITCH;
     if (iBaseFont >= 8)
       PitchFamily |= FXFONT_FF_ROMAN;
   } else {
+    iBaseFont = kNumStandardFonts;
     if (!bHasComma) {
       find = family.ReverseFind('-');
       if (find >= 0) {
         style = family.Mid(find + 1);
         family = family.Left(find);
         bHasHyphen = true;
       }
     }
     if (!bHasHyphen) {
       int nLen = family.GetLength();
@@ skipping 14 matching lines @@
     int nLen = style.GetLength();
     const FX_CHAR* pStyle = style.c_str();
     int i = 0;
     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 = kExternalFontIndex;
+        iBaseFont = kNumStandardFonts;
         break;
       }
       if (nRet >= 0) {
         bStyleAvail = true;
       }
       if (nRet == 1) {
         if (bFirstItem) {
           nStyle |= FX_FONT_STYLE_Italic;
         } else {
           family = SubstName;
-          iBaseFont = kExternalFontIndex;
+          iBaseFont = kNumStandardFonts;
         }
         break;
       }
       if (nRet == 0) {
         if (nStyle & FX_FONT_STYLE_Bold)
           nStyle |= FX_FONT_STYLE_BoldBold;
         else
           nStyle |= FX_FONT_STYLE_Bold;
         bFirstItem = false;
       } else if (nRet == 2) {
@@ skipping 14 matching lines @@
         nStyle & FX_FONT_STYLE_BoldBold
             ? 900
             : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
   }
   if (nStyle & FX_FONT_STYLE_Italic)
     bItalic = true;
   int iExact = 0;
   int Charset = FXFONT_ANSI_CHARSET;
   if (WindowCP)
     Charset = GetCharsetFromCodePage(WindowCP);
-  else if (iBaseFont == kExternalFontIndex && (flags & FXFONT_SYMBOLIC))
+  else if (iBaseFont == kNumStandardFonts && (flags & FXFONT_SYMBOLIC))
     Charset = FXFONT_SYMBOL_CHARSET;
   bool bCJK =
       (Charset == FXFONT_SHIFTJIS_CHARSET || Charset == FXFONT_GB2312_CHARSET ||
        Charset == FXFONT_HANGUL_CHARSET ||
        Charset == FXFONT_CHINESEBIG5_CHARSET);
   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 && (!bHasHyphen || (bHasHyphen && !bStyleAvail)))) {
     match = MatchInstalledFonts(TT_NormalizeName(SubstName.c_str()));
   }
-  if (match.IsEmpty() && iBaseFont >= kExternalFontIndex) {
+  if (match.IsEmpty() && iBaseFont >= kNumStandardFonts) {
     if (!bCJK) {
       if (!CheckSupportThirdPartFont(family, PitchFamily)) {
         bItalic = italic_angle != 0;
         weight = old_weight;
       }
     } else {
       pSubstFont->m_bSubstCJK = true;
       if (nStyle)
         pSubstFont->m_WeightCJK = nStyle ? weight : FXFONT_FW_NORMAL;
       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 < kExternalFontIndex) {
+  if (!match.IsEmpty() || iBaseFont < kNumStandardFonts) {
     if (!match.IsEmpty())
       family = match;
-    if (iBaseFont < kExternalFontIndex) {
+    if (iBaseFont < kNumStandardFonts) {
       if (nStyle && !(iBaseFont % 4)) {
         if ((nStyle & 0x3) == 1)
           iBaseFont += 1;
         if ((nStyle & 0x3) == 2)
           iBaseFont += 3;
         if ((nStyle & 0x3) == 3)
           iBaseFont += 2;
       }
       family = g_Base14FontNames[iBaseFont];
-      pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     }
   } else {
     if (flags & FXFONT_ITALIC)
       bItalic = true;
   }
   iExact = !match.IsEmpty();
   void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily,
                                      family.c_str(), iExact);
   if (iExact)
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
@@ skipping 11 matching lines @@
       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])
-            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];
+          return UseInternalSubst(pSubstFont, 12, italic_angle, old_weight,
+                                  PitchFamily);
         }
 #endif
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
         return FindSubstFont(family, bTrueType, flags & ~FXFONT_SYMBOLIC,
                              weight, italic_angle, 0, pSubstFont);
       }
       if (Charset == FXFONT_ANSI_CHARSET) {
-        pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
         return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
                                 PitchFamily);
       }
 
       auto it =
           std::find_if(m_FaceArray.begin(), m_FaceArray.end(),
                        [Charset](const FaceData& face) {
                          return face.charset == static_cast<uint32_t>(Charset);
                        });
       if (it == m_FaceArray.end()) {
@@ skipping 139 matching lines @@
 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;
 }