diff --git a/core/fpdfapi/font/cfx_stockfontarray.cpp b/core/fpdfapi/font/cfx_stockfontarray.cpp
index 7dd9646..235f38c 100644
--- a/core/fpdfapi/font/cfx_stockfontarray.cpp
+++ b/core/fpdfapi/font/cfx_stockfontarray.cpp
@@ -24,13 +24,14 @@
   }
 }
 
-CPDF_Font* CFX_StockFontArray::GetFont(uint32_t index) const {
+CPDF_Font* CFX_StockFontArray::GetFont(
+    CFX_FontMapper::StandardFont index) const {
   if (index >= FX_ArraySize(m_StockFonts))
     return nullptr;
   return m_StockFonts[index].get();
 }
 
-CPDF_Font* CFX_StockFontArray::SetFont(uint32_t index,
+CPDF_Font* CFX_StockFontArray::SetFont(CFX_FontMapper::StandardFont index,
                                        std::unique_ptr<CPDF_Font> pFont) {
   CPDF_Font* result = pFont.get();
   if (index < FX_ArraySize(m_StockFonts))
diff --git a/core/fpdfapi/font/cfx_stockfontarray.h b/core/fpdfapi/font/cfx_stockfontarray.h
index 57573b4..d5a8739 100644
--- a/core/fpdfapi/font/cfx_stockfontarray.h
+++ b/core/fpdfapi/font/cfx_stockfontarray.h
@@ -9,6 +9,8 @@
 
 #include <memory>
 
+#include "core/fxge/cfx_fontmapper.h"
+
 class CPDF_Font;
 
 class CFX_StockFontArray {
@@ -17,8 +19,9 @@
   ~CFX_StockFontArray();
 
   // Takes ownership of |pFont|, returns unowned pointer to it.
-  CPDF_Font* SetFont(uint32_t index, std::unique_ptr<CPDF_Font> pFont);
-  CPDF_Font* GetFont(uint32_t index) const;
+  CPDF_Font* SetFont(CFX_FontMapper::StandardFont index,
+                     std::unique_ptr<CPDF_Font> pFont);
+  CPDF_Font* GetFont(CFX_FontMapper::StandardFont index) const;
 
  private:
   std::unique_ptr<CPDF_Font> m_StockFonts[14];
diff --git a/core/fpdfapi/font/cpdf_font.cpp b/core/fpdfapi/font/cpdf_font.cpp
index f45de85..5fbffd5 100644
--- a/core/fpdfapi/font/cpdf_font.cpp
+++ b/core/fpdfapi/font/cpdf_font.cpp
@@ -286,12 +286,13 @@
 // static
 CPDF_Font* CPDF_Font::GetStockFont(CPDF_Document* pDoc, ByteStringView name) {
   ByteString fontname(name);
-  int font_id = CFX_FontMapper::GetStandardFontName(&fontname);
-  if (font_id < 0)
+  Optional<CFX_FontMapper::StandardFont> font_id =
+      CFX_FontMapper::GetStandardFontName(&fontname);
+  if (!font_id.has_value())
     return nullptr;
 
   auto* pFontGlobals = CPDF_FontGlobals::GetInstance();
-  CPDF_Font* pFont = pFontGlobals->Find(pDoc, font_id);
+  CPDF_Font* pFont = pFontGlobals->Find(pDoc, font_id.value());
   if (pFont)
     return pFont;
 
@@ -300,7 +301,7 @@
   pDict->SetNewFor<CPDF_Name>("Subtype", "Type1");
   pDict->SetNewFor<CPDF_Name>("BaseFont", fontname);
   pDict->SetNewFor<CPDF_Name>("Encoding", "WinAnsiEncoding");
-  return pFontGlobals->Set(pDoc, font_id,
+  return pFontGlobals->Set(pDoc, font_id.value(),
                            CPDF_Font::Create(nullptr, pDict.Get()));
 }
 
diff --git a/core/fpdfapi/font/cpdf_fontglobals.cpp b/core/fpdfapi/font/cpdf_fontglobals.cpp
index a520466..f4350eb 100644
--- a/core/fpdfapi/font/cpdf_fontglobals.cpp
+++ b/core/fpdfapi/font/cpdf_fontglobals.cpp
@@ -45,7 +45,8 @@
 
 CPDF_FontGlobals::~CPDF_FontGlobals() = default;
 
-CPDF_Font* CPDF_FontGlobals::Find(CPDF_Document* pDoc, uint32_t index) {
+CPDF_Font* CPDF_FontGlobals::Find(CPDF_Document* pDoc,
+                                  CFX_FontMapper::StandardFont index) {
   auto it = m_StockMap.find(pDoc);
   if (it == m_StockMap.end())
     return nullptr;
@@ -53,7 +54,7 @@
 }
 
 CPDF_Font* CPDF_FontGlobals::Set(CPDF_Document* pDoc,
-                                 uint32_t index,
+                                 CFX_FontMapper::StandardFont index,
                                  std::unique_ptr<CPDF_Font> pFont) {
   if (!pdfium::ContainsKey(m_StockMap, pDoc))
     m_StockMap[pDoc] = pdfium::MakeUnique<CFX_StockFontArray>();
diff --git a/core/fpdfapi/font/cpdf_fontglobals.h b/core/fpdfapi/font/cpdf_fontglobals.h
index fde71d8..1f856e3 100644
--- a/core/fpdfapi/font/cpdf_fontglobals.h
+++ b/core/fpdfapi/font/cpdf_fontglobals.h
@@ -12,6 +12,7 @@
 
 #include "core/fpdfapi/cmaps/cmap_int.h"
 #include "core/fpdfapi/font/cpdf_cmapmanager.h"
+#include "core/fxge/cfx_fontmapper.h"
 #include "third_party/base/span.h"
 
 class CFX_StockFontArray;
@@ -24,11 +25,11 @@
   static CPDF_FontGlobals* GetInstance();
 
   void Clear(CPDF_Document* pDoc);
-  CPDF_Font* Find(CPDF_Document* pDoc, uint32_t index);
+  CPDF_Font* Find(CPDF_Document* pDoc, CFX_FontMapper::StandardFont index);
 
   // Takes ownership of |pFont|, returns unowned pointer to it.
   CPDF_Font* Set(CPDF_Document* key,
-                 uint32_t index,
+                 CFX_FontMapper::StandardFont index,
                  std::unique_ptr<CPDF_Font> pFont);
 
   void SetEmbeddedCharset(size_t idx, pdfium::span<const FXCMAP_CMap> map) {
diff --git a/core/fpdfapi/font/cpdf_type1font.cpp b/core/fpdfapi/font/cpdf_type1font.cpp
index 9df9606..4660458 100644
--- a/core/fpdfapi/font/cpdf_type1font.cpp
+++ b/core/fpdfapi/font/cpdf_type1font.cpp
@@ -91,18 +91,20 @@
     return LoadCommon();
 
   const CPDF_Dictionary* pFontDesc = m_pFontDict->GetDictFor("FontDescriptor");
-  if (pFontDesc && pFontDesc->KeyExist("Flags"))
+  if (pFontDesc && pFontDesc->KeyExist("Flags")) {
     m_Flags = pFontDesc->GetIntegerFor("Flags");
-  else
-    m_Flags = m_Base14Font >= 12 ? FXFONT_SYMBOLIC : FXFONT_NONSYMBOLIC;
-
-  if (m_Base14Font < 4) {
+  } else if (IsSymbolicFont()) {
+    m_Flags = FXFONT_SYMBOLIC;
+  } else {
+    m_Flags = FXFONT_NONSYMBOLIC;
+  }
+  if (IsFixedFont()) {
     for (int i = 0; i < 256; i++)
       m_CharWidth[i] = 600;
   }
-  if (m_Base14Font == 12)
+  if (m_Base14Font == CFX_FontMapper::kSymbol)
     m_BaseEncoding = PDFFONT_ENCODING_ADOBE_SYMBOL;
-  else if (m_Base14Font == 13)
+  else if (m_Base14Font == CFX_FontMapper::kDingbats)
     m_BaseEncoding = PDFFONT_ENCODING_ZAPFDINGBATS;
   else if (FontStyleIsNonSymbolic(m_Flags))
     m_BaseEncoding = PDFFONT_ENCODING_STANDARD;
@@ -138,7 +140,7 @@
       bCoreText = false;
   }
 #endif
-  if (!IsEmbedded() && (m_Base14Font < 12) && m_Font.IsTTFont()) {
+  if (!IsEmbedded() && !IsSymbolicFont() && m_Font.IsTTFont()) {
     if (FT_UseTTCharmap(m_Font.GetFaceRec(), 3, 0)) {
       bool bGotOne = false;
       for (uint32_t charcode = 0; charcode < 256; charcode++) {
@@ -323,6 +325,16 @@
 #endif
 }
 
+bool CPDF_Type1Font::IsSymbolicFont() const {
+  return m_Base14Font.has_value() &&
+         CFX_FontMapper::IsSymbolicFont(m_Base14Font.value());
+}
+
+bool CPDF_Type1Font::IsFixedFont() const {
+  return m_Base14Font.has_value() &&
+         CFX_FontMapper::IsFixedFont(m_Base14Font.value());
+}
+
 #if defined(OS_MACOSX)
 void CPDF_Type1Font::SetExtGID(const char* name, uint32_t charcode) {
   CFStringRef name_ct = CFStringCreateWithCStringNoCopy(
diff --git a/core/fpdfapi/font/cpdf_type1font.h b/core/fpdfapi/font/cpdf_type1font.h
index 862e41b..eb01ec7 100644
--- a/core/fpdfapi/font/cpdf_type1font.h
+++ b/core/fpdfapi/font/cpdf_type1font.h
@@ -10,6 +10,7 @@
 #include "build/build_config.h"
 #include "core/fpdfapi/font/cpdf_simplefont.h"
 #include "core/fxcrt/fx_system.h"
+#include "core/fxge/cfx_fontmapper.h"
 
 class CPDF_Type1Font final : public CPDF_SimpleFont {
  public:
@@ -24,7 +25,7 @@
   int GlyphFromCharCodeExt(uint32_t charcode) override;
 #endif
 
-  bool IsBase14Font() const { return m_Base14Font >= 0; }
+  bool IsBase14Font() const { return m_Base14Font.has_value(); }
 
  private:
   // CPDF_Font:
@@ -33,6 +34,9 @@
   // CPDF_SimpleFont:
   void LoadGlyphMap() override;
 
+  bool IsSymbolicFont() const;
+  bool IsFixedFont() const;
+
 #if defined(OS_MACOSX)
   void SetExtGID(const char* name, uint32_t charcode);
   void CalcExtGID(uint32_t charcode);
@@ -40,7 +44,7 @@
   uint16_t m_ExtGID[256];
 #endif
 
-  int m_Base14Font = -1;
+  Optional<CFX_FontMapper::StandardFont> m_Base14Font;
 };
 
 #endif  // CORE_FPDFAPI_FONT_CPDF_TYPE1FONT_H_
diff --git a/core/fpdfapi/page/cpdf_docpagedata.cpp b/core/fpdfapi/page/cpdf_docpagedata.cpp
index 4d7a33b..5199f76 100644
--- a/core/fpdfapi/page/cpdf_docpagedata.cpp
+++ b/core/fpdfapi/page/cpdf_docpagedata.cpp
@@ -609,7 +609,7 @@
     const char* font,
     const CPDF_FontEncoding* pEncoding) {
   ByteString name(font);
-  if (CFX_FontMapper::GetStandardFontName(&name) < 0)
+  if (!CFX_FontMapper::GetStandardFontName(&name))
     return nullptr;
   return GetStandardFont(name, pEncoding);
 }
diff --git a/core/fxge/cfx_fontmapper.cpp b/core/fxge/cfx_fontmapper.cpp
index 1e17ae6..6a81aff 100644
--- a/core/fxge/cfx_fontmapper.cpp
+++ b/core/fxge/cfx_fontmapper.cpp
@@ -24,6 +24,8 @@
 namespace {
 
 const int kNumStandardFonts = 14;
+static_assert(CFX_FontMapper::kDingbats + 1 == kNumStandardFonts,
+              "StandardFont enum count mismatch");
 
 const char* const g_Base14FontNames[kNumStandardFonts] = {
     "Courier",
@@ -44,99 +46,99 @@
 
 struct AltFontName {
   const char* m_pName;  // Raw, POD struct.
-  int m_Index;
+  CFX_FontMapper::StandardFont m_Index;
 };
 
 const AltFontName g_AltFontNames[] = {
-    {"Arial", 4},
-    {"Arial,Bold", 5},
-    {"Arial,BoldItalic", 6},
-    {"Arial,Italic", 7},
-    {"Arial-Bold", 5},
-    {"Arial-BoldItalic", 6},
-    {"Arial-BoldItalicMT", 6},
-    {"Arial-BoldMT", 5},
-    {"Arial-Italic", 7},
-    {"Arial-ItalicMT", 7},
-    {"ArialBold", 5},
-    {"ArialBoldItalic", 6},
-    {"ArialItalic", 7},
-    {"ArialMT", 4},
-    {"ArialMT,Bold", 5},
-    {"ArialMT,BoldItalic", 6},
-    {"ArialMT,Italic", 7},
-    {"ArialRoundedMTBold", 5},
-    {"Courier", 0},
-    {"Courier,Bold", 1},
-    {"Courier,BoldItalic", 2},
-    {"Courier,Italic", 3},
-    {"Courier-Bold", 1},
-    {"Courier-BoldOblique", 2},
-    {"Courier-Oblique", 3},
-    {"CourierBold", 1},
-    {"CourierBoldItalic", 2},
-    {"CourierItalic", 3},
-    {"CourierNew", 0},
-    {"CourierNew,Bold", 1},
-    {"CourierNew,BoldItalic", 2},
-    {"CourierNew,Italic", 3},
-    {"CourierNew-Bold", 1},
-    {"CourierNew-BoldItalic", 2},
-    {"CourierNew-Italic", 3},
-    {"CourierNewBold", 1},
-    {"CourierNewBoldItalic", 2},
-    {"CourierNewItalic", 3},
-    {"CourierNewPS-BoldItalicMT", 2},
-    {"CourierNewPS-BoldMT", 1},
-    {"CourierNewPS-ItalicMT", 3},
-    {"CourierNewPSMT", 0},
-    {"CourierStd", 0},
-    {"CourierStd-Bold", 1},
-    {"CourierStd-BoldOblique", 2},
-    {"CourierStd-Oblique", 3},
-    {"Helvetica", 4},
-    {"Helvetica,Bold", 5},
-    {"Helvetica,BoldItalic", 6},
-    {"Helvetica,Italic", 7},
-    {"Helvetica-Bold", 5},
-    {"Helvetica-BoldItalic", 6},
-    {"Helvetica-BoldOblique", 6},
-    {"Helvetica-Italic", 7},
-    {"Helvetica-Oblique", 7},
-    {"HelveticaBold", 5},
-    {"HelveticaBoldItalic", 6},
-    {"HelveticaItalic", 7},
-    {"Symbol", 12},
-    {"SymbolMT", 12},
-    {"Times-Bold", 9},
-    {"Times-BoldItalic", 10},
-    {"Times-Italic", 11},
-    {"Times-Roman", 8},
-    {"TimesBold", 9},
-    {"TimesBoldItalic", 10},
-    {"TimesItalic", 11},
-    {"TimesNewRoman", 8},
-    {"TimesNewRoman,Bold", 9},
-    {"TimesNewRoman,BoldItalic", 10},
-    {"TimesNewRoman,Italic", 11},
-    {"TimesNewRoman-Bold", 9},
-    {"TimesNewRoman-BoldItalic", 10},
-    {"TimesNewRoman-Italic", 11},
-    {"TimesNewRomanBold", 9},
-    {"TimesNewRomanBoldItalic", 10},
-    {"TimesNewRomanItalic", 11},
-    {"TimesNewRomanPS", 8},
-    {"TimesNewRomanPS-Bold", 9},
-    {"TimesNewRomanPS-BoldItalic", 10},
-    {"TimesNewRomanPS-BoldItalicMT", 10},
-    {"TimesNewRomanPS-BoldMT", 9},
-    {"TimesNewRomanPS-Italic", 11},
-    {"TimesNewRomanPS-ItalicMT", 11},
-    {"TimesNewRomanPSMT", 8},
-    {"TimesNewRomanPSMT,Bold", 9},
-    {"TimesNewRomanPSMT,BoldItalic", 10},
-    {"TimesNewRomanPSMT,Italic", 11},
-    {"ZapfDingbats", 13},
+    {"Arial", CFX_FontMapper::kHelvetica},
+    {"Arial,Bold", CFX_FontMapper::kHelveticaBold},
+    {"Arial,BoldItalic", CFX_FontMapper::kHelveticaBoldOblique},
+    {"Arial,Italic", CFX_FontMapper::kHelveticaOblique},
+    {"Arial-Bold", CFX_FontMapper::kHelveticaBold},
+    {"Arial-BoldItalic", CFX_FontMapper::kHelveticaBoldOblique},
+    {"Arial-BoldItalicMT", CFX_FontMapper::kHelveticaBoldOblique},
+    {"Arial-BoldMT", CFX_FontMapper::kHelveticaBold},
+    {"Arial-Italic", CFX_FontMapper::kHelveticaOblique},
+    {"Arial-ItalicMT", CFX_FontMapper::kHelveticaOblique},
+    {"ArialBold", CFX_FontMapper::kHelveticaBold},
+    {"ArialBoldItalic", CFX_FontMapper::kHelveticaBoldOblique},
+    {"ArialItalic", CFX_FontMapper::kHelveticaOblique},
+    {"ArialMT", CFX_FontMapper::kHelvetica},
+    {"ArialMT,Bold", CFX_FontMapper::kHelveticaBold},
+    {"ArialMT,BoldItalic", CFX_FontMapper::kHelveticaBoldOblique},
+    {"ArialMT,Italic", CFX_FontMapper::kHelveticaOblique},
+    {"ArialRoundedMTBold", CFX_FontMapper::kHelveticaBold},
+    {"Courier", CFX_FontMapper::kCourier},
+    {"Courier,Bold", CFX_FontMapper::kCourierBold},
+    {"Courier,BoldItalic", CFX_FontMapper::kCourierBoldOblique},
+    {"Courier,Italic", CFX_FontMapper::kCourierOblique},
+    {"Courier-Bold", CFX_FontMapper::kCourierBold},
+    {"Courier-BoldOblique", CFX_FontMapper::kCourierBoldOblique},
+    {"Courier-Oblique", CFX_FontMapper::kCourierOblique},
+    {"CourierBold", CFX_FontMapper::kCourierBold},
+    {"CourierBoldItalic", CFX_FontMapper::kCourierBoldOblique},
+    {"CourierItalic", CFX_FontMapper::kCourierOblique},
+    {"CourierNew", CFX_FontMapper::kCourier},
+    {"CourierNew,Bold", CFX_FontMapper::kCourierBold},
+    {"CourierNew,BoldItalic", CFX_FontMapper::kCourierBoldOblique},
+    {"CourierNew,Italic", CFX_FontMapper::kCourierOblique},
+    {"CourierNew-Bold", CFX_FontMapper::kCourierBold},
+    {"CourierNew-BoldItalic", CFX_FontMapper::kCourierBoldOblique},
+    {"CourierNew-Italic", CFX_FontMapper::kCourierOblique},
+    {"CourierNewBold", CFX_FontMapper::kCourierBold},
+    {"CourierNewBoldItalic", CFX_FontMapper::kCourierBoldOblique},
+    {"CourierNewItalic", CFX_FontMapper::kCourierOblique},
+    {"CourierNewPS-BoldItalicMT", CFX_FontMapper::kCourierBoldOblique},
+    {"CourierNewPS-BoldMT", CFX_FontMapper::kCourierBold},
+    {"CourierNewPS-ItalicMT", CFX_FontMapper::kCourierOblique},
+    {"CourierNewPSMT", CFX_FontMapper::kCourier},
+    {"CourierStd", CFX_FontMapper::kCourier},
+    {"CourierStd-Bold", CFX_FontMapper::kCourierBold},
+    {"CourierStd-BoldOblique", CFX_FontMapper::kCourierBoldOblique},
+    {"CourierStd-Oblique", CFX_FontMapper::kCourierOblique},
+    {"Helvetica", CFX_FontMapper::kHelvetica},
+    {"Helvetica,Bold", CFX_FontMapper::kHelveticaBold},
+    {"Helvetica,BoldItalic", CFX_FontMapper::kHelveticaBoldOblique},
+    {"Helvetica,Italic", CFX_FontMapper::kHelveticaOblique},
+    {"Helvetica-Bold", CFX_FontMapper::kHelveticaBold},
+    {"Helvetica-BoldItalic", CFX_FontMapper::kHelveticaBoldOblique},
+    {"Helvetica-BoldOblique", CFX_FontMapper::kHelveticaBoldOblique},
+    {"Helvetica-Italic", CFX_FontMapper::kHelveticaOblique},
+    {"Helvetica-Oblique", CFX_FontMapper::kHelveticaOblique},
+    {"HelveticaBold", CFX_FontMapper::kHelveticaBold},
+    {"HelveticaBoldItalic", CFX_FontMapper::kHelveticaBoldOblique},
+    {"HelveticaItalic", CFX_FontMapper::kHelveticaOblique},
+    {"Symbol", CFX_FontMapper::kSymbol},
+    {"SymbolMT", CFX_FontMapper::kSymbol},
+    {"Times-Bold", CFX_FontMapper::kTimesBold},
+    {"Times-BoldItalic", CFX_FontMapper::kTimesBoldOblique},
+    {"Times-Italic", CFX_FontMapper::kTimesOblique},
+    {"Times-Roman", CFX_FontMapper::kTimes},
+    {"TimesBold", CFX_FontMapper::kTimesBold},
+    {"TimesBoldItalic", CFX_FontMapper::kTimesBoldOblique},
+    {"TimesItalic", CFX_FontMapper::kTimesOblique},
+    {"TimesNewRoman", CFX_FontMapper::kTimes},
+    {"TimesNewRoman,Bold", CFX_FontMapper::kTimesBold},
+    {"TimesNewRoman,BoldItalic", CFX_FontMapper::kTimesBoldOblique},
+    {"TimesNewRoman,Italic", CFX_FontMapper::kTimesOblique},
+    {"TimesNewRoman-Bold", CFX_FontMapper::kTimesBold},
+    {"TimesNewRoman-BoldItalic", CFX_FontMapper::kTimesBoldOblique},
+    {"TimesNewRoman-Italic", CFX_FontMapper::kTimesOblique},
+    {"TimesNewRomanBold", CFX_FontMapper::kTimesBold},
+    {"TimesNewRomanBoldItalic", CFX_FontMapper::kTimesBoldOblique},
+    {"TimesNewRomanItalic", CFX_FontMapper::kTimesOblique},
+    {"TimesNewRomanPS", CFX_FontMapper::kTimes},
+    {"TimesNewRomanPS-Bold", CFX_FontMapper::kTimesBold},
+    {"TimesNewRomanPS-BoldItalic", CFX_FontMapper::kTimesBoldOblique},
+    {"TimesNewRomanPS-BoldItalicMT", CFX_FontMapper::kTimesBoldOblique},
+    {"TimesNewRomanPS-BoldMT", CFX_FontMapper::kTimesBold},
+    {"TimesNewRomanPS-Italic", CFX_FontMapper::kTimesOblique},
+    {"TimesNewRomanPS-ItalicMT", CFX_FontMapper::kTimesOblique},
+    {"TimesNewRomanPSMT", CFX_FontMapper::kTimes},
+    {"TimesNewRomanPSMT,Bold", CFX_FontMapper::kTimesBold},
+    {"TimesNewRomanPSMT,BoldItalic", CFX_FontMapper::kTimesBoldOblique},
+    {"TimesNewRomanPSMT,Italic", CFX_FontMapper::kTimesOblique},
+    {"ZapfDingbats", CFX_FontMapper::kDingbats},
 };
 
 struct AltFontFamily {
@@ -714,7 +716,8 @@
 }
 
 // static
-int CFX_FontMapper::GetStandardFontName(ByteString* name) {
+Optional<CFX_FontMapper::StandardFont> CFX_FontMapper::GetStandardFontName(
+    ByteString* name) {
   const auto* end = std::end(g_AltFontNames);
   const auto* found =
       std::lower_bound(std::begin(g_AltFontNames), end, name->c_str(),
@@ -722,8 +725,20 @@
                          return FXSYS_stricmp(element.m_pName, name) < 0;
                        });
   if (found == end || FXSYS_stricmp(found->m_pName, name->c_str()))
-    return -1;
+    return {};
 
-  *name = g_Base14FontNames[found->m_Index];
+  *name = g_Base14FontNames[static_cast<size_t>(found->m_Index)];
   return found->m_Index;
 }
+
+// static
+bool CFX_FontMapper::IsSymbolicFont(StandardFont font) {
+  return font == StandardFont::kSymbol || font == StandardFont::kDingbats;
+}
+
+// static
+bool CFX_FontMapper::IsFixedFont(StandardFont font) {
+  return font == StandardFont::kCourier || font == StandardFont::kCourierBold ||
+         font == StandardFont::kCourierBoldOblique ||
+         font == StandardFont::kCourierOblique;
+}
diff --git a/core/fxge/cfx_fontmapper.h b/core/fxge/cfx_fontmapper.h
index 532448a..450291f 100644
--- a/core/fxge/cfx_fontmapper.h
+++ b/core/fxge/cfx_fontmapper.h
@@ -13,6 +13,7 @@
 
 #include "core/fxcrt/fx_string.h"
 #include "core/fxge/cfx_face.h"
+#include "third_party/base/optional.h"
 
 class CFX_FontMgr;
 class CFX_SubstFont;
@@ -20,10 +21,29 @@
 
 class CFX_FontMapper {
  public:
+  enum StandardFont {
+    kCourier = 0,
+    kCourierBold,
+    kCourierBoldOblique,
+    kCourierOblique,
+    kHelvetica,
+    kHelveticaBold,
+    kHelveticaBoldOblique,
+    kHelveticaOblique,
+    kTimes,
+    kTimesBold,
+    kTimesBoldOblique,
+    kTimesOblique,
+    kSymbol,
+    kDingbats,
+  };
+
   explicit CFX_FontMapper(CFX_FontMgr* mgr);
   ~CFX_FontMapper();
 
-  static int GetStandardFontName(ByteString* name);
+  static Optional<StandardFont> GetStandardFontName(ByteString* name);
+  static bool IsSymbolicFont(StandardFont font);
+  static bool IsFixedFont(StandardFont font);
 
   void SetSystemFontInfo(std::unique_ptr<SystemFontInfoIface> pFontInfo);
   SystemFontInfoIface* GetSystemFontInfo() { return m_pFontInfo.get(); }