refactor CPDF_Font and subclasses

core/src/fpdfapi/fpdf_font/fpdf_font.cpp

 // Copyright 2014 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/src/fpdfapi/fpdf_font/font_int.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_page.h"
 #include "core/include/fpdfapi/fpdf_pageobj.h"
 #include "core/include/fpdfapi/fpdf_resource.h"
 #include "core/include/fxcrt/fx_ext.h"
 #include "core/include/fxge/fx_freetype.h"
 #include "core/src/fpdfapi/fpdf_page/pageint.h"
 #include "third_party/base/stl_util.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
 #include "core/src/fxge/apple/apple_int.h"
 #endif
 
+namespace {
+
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
+struct GlyphNameMap {
+  const FX_CHAR* m_pStrAdobe;
+  const FX_CHAR* m_pStrUnicode;
+};
+
+const GlyphNameMap g_GlyphNameSubsts[] = {{"ff", "uniFB00"},
+                                          {"fi", "uniFB01"},
+                                          {"fl", "uniFB02"},
+                                          {"ffi", "uniFB03"},
+                                          {"ffl", "uniFB04"}};
+
+int compareString(const void* key, const void* element) {
+  return FXSYS_stricmp((const FX_CHAR*)key,
+                       ((GlyphNameMap*)element)->m_pStrAdobe);
+}
+
+const FX_CHAR* GlyphNameRemap(const FX_CHAR* pStrAdobe) {
+  GlyphNameMap* found = (GlyphNameMap*)FXSYS_bsearch(
+      pStrAdobe, g_GlyphNameSubsts,
+      sizeof(g_GlyphNameSubsts) / sizeof(GlyphNameMap), sizeof(GlyphNameMap),
+      compareString);
+  if (found)
+    return found->m_pStrUnicode;
+  return NULL;
+}
+#endif
+
+const uint8_t ChineseFontNames[][5] = {{0xCB, 0xCE, 0xCC, 0xE5, 0x00},
+                                       {0xBF, 0xAC, 0xCC, 0xE5, 0x00},
+                                       {0xBA, 0xDA, 0xCC, 0xE5, 0x00},
+                                       {0xB7, 0xC2, 0xCB, 0xCE, 0x00},
+                                       {0xD0, 0xC2, 0xCB, 0xCE, 0x00}};
+
+FX_BOOL GetPredefinedEncoding(int& basemap, const CFX_ByteString& value) {
+  if (value == "WinAnsiEncoding") {
+    basemap = PDFFONT_ENCODING_WINANSI;
+  } else if (value == "MacRomanEncoding") {
+    basemap = PDFFONT_ENCODING_MACROMAN;
+  } else if (value == "MacExpertEncoding") {
+    basemap = PDFFONT_ENCODING_MACEXPERT;
+  } else if (value == "PDFDocEncoding") {
+    basemap = PDFFONT_ENCODING_PDFDOC;
+  } else {
+    return FALSE;
+  }
+  return TRUE;
+}
+
+FX_BOOL FT_UseType1Charmap(FXFT_Face face) {
+  if (FXFT_Get_Face_CharmapCount(face) == 0) {
+    return FALSE;
+  }
+  if (FXFT_Get_Face_CharmapCount(face) == 1 &&
+      FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[0]) ==
+          FXFT_ENCODING_UNICODE) {
+    return FALSE;
+  }
+  if (FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[0]) ==
+      FXFT_ENCODING_UNICODE) {
+    FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[1]);
+  } else {
+    FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[0]);
+  }
+  return TRUE;
+}
+
+}  // namespace
+
 FX_BOOL FT_UseTTCharmap(FXFT_Face face, int platform_id, int encoding_id) {
   for (int i = 0; i < FXFT_Get_Face_CharmapCount(face); i++) {
     if (FXFT_Get_Charmap_PlatformID(FXFT_Get_Face_Charmaps(face)[i]) ==
             platform_id &&
         FXFT_Get_Charmap_EncodingID(FXFT_Get_Face_Charmaps(face)[i]) ==
             encoding_id) {
       FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[i]);
       return TRUE;
     }
   }
@@ skipping 42 matching lines @@
 void CPDF_FontGlobals::Set(CPDF_Document* pDoc, int index, CPDF_Font* pFont) {
   if (!pdfium::ContainsKey(m_StockMap, pDoc))
     m_StockMap[pDoc].reset(new CFX_StockFontArray);
   m_StockMap[pDoc]->SetFont(index, pFont);
 }
 
 void CPDF_FontGlobals::Clear(CPDF_Document* pDoc) {
   m_StockMap.erase(pDoc);
 }
 
-CPDF_Font::CPDF_Font(int fonttype) : m_FontType(fonttype) {
-  m_FontBBox.left = m_FontBBox.right = m_FontBBox.top = m_FontBBox.bottom = 0;
-  m_StemV = m_Ascent = m_Descent = m_ItalicAngle = 0;
-  m_pFontFile = NULL;
-  m_Flags = 0;
-  m_pToUnicodeMap = NULL;
-  m_bToUnicodeLoaded = FALSE;
-}
+CPDF_Font::CPDF_Font()
+    : m_pFontFile(nullptr),
+      m_pFontDict(nullptr),
+      m_pToUnicodeMap(nullptr),
+      m_bToUnicodeLoaded(FALSE),
+      m_Flags(0),
+      m_StemV(0),
+      m_Ascent(0),
+      m_Descent(0),
+      m_ItalicAngle(0) {}
+
 CPDF_Font::~CPDF_Font() {
   delete m_pToUnicodeMap;
   m_pToUnicodeMap = NULL;
 
   if (m_pFontFile) {
     m_pDocument->GetPageData()->ReleaseFontFileStreamAcc(
         const_cast<CPDF_Stream*>(m_pFontFile->GetStream()->AsStream()));
   }
 }
+
 FX_BOOL CPDF_Font::IsVertWriting() const {
   FX_BOOL bVertWriting = FALSE;
-  CPDF_CIDFont* pCIDFont = GetCIDFont();
+  const CPDF_CIDFont* pCIDFont = AsCIDFont();
   if (pCIDFont) {
     bVertWriting = pCIDFont->IsVertWriting();
   } else {
     bVertWriting = m_Font.IsVertical();
   }
   return bVertWriting;
 }
-CFX_ByteString CPDF_Font::GetFontTypeName() const {
-  switch (m_FontType) {
-    case PDFFONT_TYPE1:
-      return "Type1";
-    case PDFFONT_TRUETYPE:
-      return "TrueType";
-    case PDFFONT_TYPE3:
-      return "Type3";
-    case PDFFONT_CIDFONT:
-      return "Type0";
-  }
-  return CFX_ByteString();
+
+int CPDF_Font::AppendChar(FX_CHAR* buf, FX_DWORD charcode) const {
+  *buf = (FX_CHAR)charcode;
+  return 1;
 }
+
 void CPDF_Font::AppendChar(CFX_ByteString& str, FX_DWORD charcode) const {
   char buf[4];
   int len = AppendChar(buf, charcode);
   if (len == 1) {
     str += buf[0];
   } else {
     str += CFX_ByteString(buf, len);
   }
 }
+
 CFX_WideString CPDF_Font::UnicodeFromCharCode(FX_DWORD charcode) const {
-  if (!m_bToUnicodeLoaded) {
+  if (!m_bToUnicodeLoaded)
     ((CPDF_Font*)this)->LoadUnicodeMap();
-  }
-  if (m_pToUnicodeMap) {
-    CFX_WideString wsRet = m_pToUnicodeMap->Lookup(charcode);
-    if (!wsRet.IsEmpty()) {
-      return wsRet;
-    }
-  }
-  FX_WCHAR unicode = _UnicodeFromCharCode(charcode);
-  if (unicode == 0) {
-    return CFX_WideString();
-  }
-  return unicode;
+
+  if (m_pToUnicodeMap)
+    return m_pToUnicodeMap->Lookup(charcode);
+  return CFX_WideString();
 }
+
 FX_DWORD CPDF_Font::CharCodeFromUnicode(FX_WCHAR unicode) const {
-  if (!m_bToUnicodeLoaded) {
+  if (!m_bToUnicodeLoaded)
     ((CPDF_Font*)this)->LoadUnicodeMap();
-  }
-  if (m_pToUnicodeMap) {
-    FX_DWORD charcode = m_pToUnicodeMap->ReverseLookup(unicode);
-    if (charcode) {
-      return charcode;
-    }
-  }
-  return _CharCodeFromUnicode(unicode);
+
+  if (m_pToUnicodeMap)
+    return m_pToUnicodeMap->ReverseLookup(unicode);
+  return 0;
 }
 
 void CPDF_Font::LoadFontDescriptor(CPDF_Dictionary* pFontDesc) {
   m_Flags = pFontDesc->GetIntegerBy("Flags", PDFFONT_NONSYMBOLIC);
   int ItalicAngle = 0;
   FX_BOOL bExistItalicAngle = FALSE;
   if (pFontDesc->KeyExist("ItalicAngle")) {
     ItalicAngle = pFontDesc->GetIntegerBy("ItalicAngle");
     bExistItalicAngle = TRUE;
   }
@@ skipping 56 matching lines @@
   }
 }
 
 short TT2PDF(int m, FXFT_Face face) {
   int upm = FXFT_Get_Face_UnitsPerEM(face);
   if (upm == 0) {
     return (short)m;
   }
   return (m * 1000 + upm / 2) / upm;
 }
+
 void CPDF_Font::CheckFontMetrics() {
   if (m_FontBBox.top == 0 && m_FontBBox.bottom == 0 && m_FontBBox.left == 0 &&
       m_FontBBox.right == 0) {
     FXFT_Face face = m_Font.GetFace();
     if (face) {
       m_FontBBox.left = TT2PDF(FXFT_Get_Face_xMin(face), face);
       m_FontBBox.bottom = TT2PDF(FXFT_Get_Face_yMin(face), face);
       m_FontBBox.right = TT2PDF(FXFT_Get_Face_xMax(face), face);
       m_FontBBox.top = TT2PDF(FXFT_Get_Face_yMax(face), face);
       m_Ascent = TT2PDF(FXFT_Get_Face_Ascender(face), face);
@@ skipping 35 matching lines @@
       m_Ascent = rect.top;
     }
     GetCharBBox('g', rect);
     if (rect.bottom == rect.top) {
       m_Descent = m_FontBBox.bottom;
     } else {
       m_Descent = rect.bottom;
     }
   }
 }
+
 void CPDF_Font::LoadUnicodeMap() {
   m_bToUnicodeLoaded = TRUE;
   CPDF_Stream* pStream = m_pFontDict->GetStreamBy("ToUnicode");
   if (!pStream) {
     return;
   }
   m_pToUnicodeMap = new CPDF_ToUnicodeMap;
   m_pToUnicodeMap->Load(pStream);
 }
+
 int CPDF_Font::GetStringWidth(const FX_CHAR* pString, int size) {
   int offset = 0;
   int width = 0;
   while (offset < size) {
     FX_DWORD charcode = GetNextChar(pString, size, offset);
     width += GetCharWidthF(charcode);
   }
   return width;
 }
-int CPDF_Font::GetCharTypeWidth(FX_DWORD charcode) {
-  if (!m_Font.GetFace())
-    return 0;
-
-  int glyph_index = GlyphFromCharCode(charcode);
-  if (glyph_index == 0xffff) {
-    return 0;
-  }
-  return m_Font.GetGlyphWidth(glyph_index);
-}
 
 CPDF_Font* CPDF_Font::GetStockFont(CPDF_Document* pDoc,
                                    const CFX_ByteStringC& name) {
   CFX_ByteString fontname(name);
   int font_id = PDF_GetStandardFontName(&fontname);
   if (font_id < 0) {
     return nullptr;
   }
   CPDF_FontGlobals* pFontGlobals =
       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
   CPDF_Font* pFont = pFontGlobals->Find(pDoc, font_id);
   if (pFont) {
     return pFont;
   }
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
   pDict->SetAtName("Type", "Font");
   pDict->SetAtName("Subtype", "Type1");
   pDict->SetAtName("BaseFont", fontname);
   pDict->SetAtName("Encoding", "WinAnsiEncoding");
   pFont = CPDF_Font::CreateFontF(NULL, pDict);
   pFontGlobals->Set(pDoc, font_id, pFont);
   return pFont;
 }
-const uint8_t ChineseFontNames[][5] = {{0xCB, 0xCE, 0xCC, 0xE5, 0x00},
-                                       {0xBF, 0xAC, 0xCC, 0xE5, 0x00},
-                                       {0xBA, 0xDA, 0xCC, 0xE5, 0x00},
-                                       {0xB7, 0xC2, 0xCB, 0xCE, 0x00},
-                                       {0xD0, 0xC2, 0xCB, 0xCE, 0x00}};
+
 CPDF_Font* CPDF_Font::CreateFontF(CPDF_Document* pDoc,
                                   CPDF_Dictionary* pFontDict) {
   CFX_ByteString type = pFontDict->GetStringBy("Subtype");
   CPDF_Font* pFont;
   if (type == "TrueType") {
     {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_ ||   \
     _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       CFX_ByteString basefont = pFontDict->GetStringBy("BaseFont");
       CFX_ByteString tag = basefont.Left(4);
       int i;
       int count = sizeof(ChineseFontNames) / sizeof(ChineseFontNames[0]);
       for (i = 0; i < count; ++i) {
         if (tag == CFX_ByteString((const FX_CHAR*)ChineseFontNames[i])) {
           break;
         }
       }
       if (i < count) {
         CPDF_Dictionary* pFontDesc = pFontDict->GetDictBy("FontDescriptor");
         if (!pFontDesc || !pFontDesc->KeyExist("FontFile2")) {
           pFont = new CPDF_CIDFont;
           pFont->m_pFontDict = pFontDict;
           pFont->m_pDocument = pDoc;
+          pFont->m_BaseFont = pFontDict->GetStringBy("BaseFont");
           if (!pFont->Load()) {
             delete pFont;
             return NULL;
           }
           return pFont;
         }
       }
 #endif
     }
     pFont = new CPDF_TrueTypeFont;
   } else if (type == "Type3") {
     pFont = new CPDF_Type3Font;
   } else if (type == "Type0") {
     pFont = new CPDF_CIDFont;
   } else {
     pFont = new CPDF_Type1Font;
   }
   pFont->m_pFontDict = pFontDict;
   pFont->m_pDocument = pDoc;
+  pFont->m_BaseFont = pFontDict->GetStringBy("BaseFont");
   if (!pFont->Load()) {
     delete pFont;
     return NULL;
   }
   return pFont;
 }
-FX_BOOL CPDF_Font::Load() {
-  if (!m_pFontDict) {
-    return FALSE;
-  }
-  CFX_ByteString type = m_pFontDict->GetStringBy("Subtype");
-  m_BaseFont = m_pFontDict->GetStringBy("BaseFont");
-  if (type == "MMType1") {
-    type = "Type1";
-  }
-  return _Load();
-}
 
 CFX_WideString CPDF_ToUnicodeMap::Lookup(FX_DWORD charcode) {
   auto it = m_Map.find(charcode);
   if (it != m_Map.end()) {
     FX_DWORD value = it->second;
     FX_WCHAR unicode = (FX_WCHAR)(value & 0xffff);
     if (unicode != 0xffff) {
       return unicode;
     }
     const FX_WCHAR* buf = m_MultiCharBuf.GetBuffer();
     FX_DWORD buf_len = m_MultiCharBuf.GetLength();
     if (!buf || buf_len == 0) {
       return CFX_WideString();
     }
     FX_DWORD index = value >> 16;
     if (index >= buf_len) {
       return CFX_WideString();
     }
     FX_DWORD len = buf[index];
     if (index + len < index || index + len >= buf_len) {
       return CFX_WideString();
     }
     return CFX_WideString(buf + index + 1, len);
   }
   if (m_pBaseMap) {
     return m_pBaseMap->UnicodeFromCID((FX_WORD)charcode);
   }
   return CFX_WideString();
 }
+
 FX_DWORD CPDF_ToUnicodeMap::ReverseLookup(FX_WCHAR unicode) {
   for (const auto& pair : m_Map) {
     if (pair.second == unicode)
       return pair.first;
   }
   return 0;
 }
 
 // Static.
 FX_DWORD CPDF_ToUnicodeMap::StringToCode(const CFX_ByteStringC& str) {
   const FX_CHAR* buf = str.GetCStr();
   int len = str.GetLength();
   if (len == 0)
     return 0;
 
   int result = 0;
   if (buf[0] == '<') {
     for (int i = 1; i < len && std::isxdigit(buf[i]); ++i)
       result = result * 16 + FXSYS_toHexDigit(buf[i]);
     return result;
   }
 
   for (int i = 0; i < len && std::isdigit(buf[i]); ++i)
     result = result * 10 + FXSYS_toDecimalDigit(buf[i]);
 
   return result;
 }
+
 static CFX_WideString StringDataAdd(CFX_WideString str) {
   CFX_WideString ret;
   int len = str.GetLength();
   FX_WCHAR value = 1;
   for (int i = len - 1; i >= 0; --i) {
     FX_WCHAR ch = str[i] + value;
     if (ch < str[i]) {
       ret.Insert(0, 0);
     } else {
       ret.Insert(0, ch);
@@ skipping 24 matching lines @@
       if (byte_pos == 4) {
         result += ch;
         byte_pos = 0;
         ch = 0;
       }
     }
     return result;
   }
   return result;
 }
+
 void CPDF_ToUnicodeMap::Load(CPDF_Stream* pStream) {
   CIDSet cid_set = CIDSET_UNKNOWN;
   CPDF_StreamAcc stream;
   stream.LoadAllData(pStream, FALSE);
   CPDF_SimpleParser parser(stream.GetData(), stream.GetSize());
   while (1) {
     CFX_ByteStringC word = parser.GetWord();
     if (word.IsEmpty()) {
       break;
     }
@@ skipping 87 matching lines @@
   }
   if (cid_set) {
     m_pBaseMap = CPDF_ModuleMgr::Get()
                      ->GetPageModule()
                      ->GetFontGlobals()
                      ->m_CMapManager.GetCID2UnicodeMap(cid_set, FALSE);
   } else {
     m_pBaseMap = NULL;
   }
 }
-static FX_BOOL GetPredefinedEncoding(int& basemap,
-                                     const CFX_ByteString& value) {
-  if (value == "WinAnsiEncoding") {
-    basemap = PDFFONT_ENCODING_WINANSI;
-  } else if (value == "MacRomanEncoding") {
-    basemap = PDFFONT_ENCODING_MACROMAN;
-  } else if (value == "MacExpertEncoding") {
-    basemap = PDFFONT_ENCODING_MACEXPERT;
-  } else if (value == "PDFDocEncoding") {
-    basemap = PDFFONT_ENCODING_PDFDOC;
-  } else {
-    return FALSE;
+
+FX_DWORD CPDF_Font::GetNextChar(const FX_CHAR* pString,
+                                int nStrLen,
+                                int& offset) const {
+  if (offset < 0 || nStrLen < 1) {
+    return 0;
   }
-  return TRUE;
+  uint8_t ch = offset < nStrLen ? pString[offset++] : pString[nStrLen - 1];
+  return static_cast<FX_DWORD>(ch);
 }
+
 void CPDF_Font::LoadPDFEncoding(CPDF_Object* pEncoding,
                                 int& iBaseEncoding,
                                 CFX_ByteString*& pCharNames,
                                 FX_BOOL bEmbedded,
                                 FX_BOOL bTrueType) {
   if (!pEncoding) {
     if (m_BaseFont == "Symbol") {
       iBaseEncoding = bTrueType ? PDFFONT_ENCODING_MS_SYMBOL
                                 : PDFFONT_ENCODING_ADOBE_SYMBOL;
     } else if (!bEmbedded && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
@@ skipping 50 matching lines @@
       if (cur_code < 256)
         pCharNames[cur_code] = pName->GetString();
       cur_code++;
     } else {
       cur_code = pElement->GetInteger();
     }
   }
 }
 
 FX_BOOL CPDF_Font::IsStandardFont() const {
-  if (m_FontType != PDFFONT_TYPE1)
+  if (!IsType1Font())
     return FALSE;
   if (m_pFontFile)
     return FALSE;
-  if (((CPDF_Type1Font*)this)->GetBase14Font() < 0)
+  if (AsType1Font()->GetBase14Font() < 0)
     return FALSE;
   return TRUE;
 }
-CPDF_SimpleFont::CPDF_SimpleFont(int fonttype) : CPDF_Font(fonttype) {
+
+CPDF_SimpleFont::CPDF_SimpleFont() {
   FXSYS_memset(m_CharBBox, 0xff, sizeof m_CharBBox);
   FXSYS_memset(m_CharWidth, 0xff, sizeof m_CharWidth);
   FXSYS_memset(m_GlyphIndex, 0xff, sizeof m_GlyphIndex);
   FXSYS_memset(m_ExtGID, 0xff, sizeof m_ExtGID);
   m_pCharNames = NULL;
   m_BaseEncoding = PDFFONT_ENCODING_BUILTIN;
 }
+
 CPDF_SimpleFont::~CPDF_SimpleFont() {
   delete[] m_pCharNames;
 }
+
 int CPDF_SimpleFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph) {
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
   if (charcode > 0xff) {
     return -1;
   }
   int index = m_GlyphIndex[(uint8_t)charcode];
   if (index == 0xffff) {
     return -1;
   }
   return index;
 }
+
 void CPDF_SimpleFont::LoadCharMetrics(int charcode) {
   if (!m_Font.GetFace())
     return;
 
   if (charcode < 0 || charcode > 0xff) {
     return;
   }
   int glyph_index = m_GlyphIndex[charcode];
   if (glyph_index == 0xffff) {
     if (!m_pFontFile && charcode != 32) {
@@ skipping 23 matching lines @@
     if (m_CharWidth[charcode] == 0xffff) {
       m_CharWidth[charcode] = TT_Width;
     } else if (TT_Width && !IsEmbedded()) {
       m_CharBBox[charcode].Right =
           m_CharBBox[charcode].Right * m_CharWidth[charcode] / TT_Width;
       m_CharBBox[charcode].Left =
           m_CharBBox[charcode].Left * m_CharWidth[charcode] / TT_Width;
     }
   }
 }
+
 int CPDF_SimpleFont::GetCharWidthF(FX_DWORD charcode, int level) {
   if (charcode > 0xff) {
     charcode = 0;
   }
   if (m_CharWidth[charcode] == 0xffff) {
     LoadCharMetrics(charcode);
     if (m_CharWidth[charcode] == 0xffff) {
       m_CharWidth[charcode] = 0;
     }
   }
   return (int16_t)m_CharWidth[charcode];
 }
+
 void CPDF_SimpleFont::GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level) {
   if (charcode > 0xff) {
     charcode = 0;
   }
   if (m_CharBBox[charcode].Left == (int16_t)0xffff) {
     LoadCharMetrics(charcode);
   }
   rect.left = m_CharBBox[charcode].Left;
   rect.right = m_CharBBox[charcode].Right;
   rect.bottom = m_CharBBox[charcode].Bottom;
   rect.top = m_CharBBox[charcode].Top;
 }
+
 const FX_CHAR* GetAdobeCharName(int iBaseEncoding,
                                 const CFX_ByteString* pCharNames,
                                 int charcode) {
   ASSERT(charcode >= 0 && charcode < 256);
   if (charcode < 0 || charcode >= 256) {
     return NULL;
   }
   const FX_CHAR* name = NULL;
   if (pCharNames) {
     name = pCharNames[charcode];
   }
   if ((!name || name[0] == 0) && iBaseEncoding) {
     name = PDF_CharNameFromPredefinedCharSet(iBaseEncoding, charcode);
   }
   return name && name[0] ? name : nullptr;
 }
+
 FX_BOOL CPDF_SimpleFont::LoadCommon() {
   CPDF_Dictionary* pFontDesc = m_pFontDict->GetDictBy("FontDescriptor");
   if (pFontDesc) {
     LoadFontDescriptor(pFontDesc);
   }
   CPDF_Array* pWidthArray = m_pFontDict->GetArrayBy("Widths");
   int width_start = 0, width_end = -1;
   m_bUseFontWidth = TRUE;
   if (pWidthArray) {
     m_bUseFontWidth = FALSE;
@@ skipping 48 matching lines @@
         if (m_CharWidth[i - 32]) {
           m_CharWidth[i] = m_CharWidth[i - 32];
           m_CharBBox[i] = m_CharBBox[i - 32];
         }
       }
     }
   }
   CheckFontMetrics();
   return TRUE;
 }
+
 void CPDF_SimpleFont::LoadSubstFont() {
   if (!m_bUseFontWidth && !(m_Flags & PDFFONT_FIXEDPITCH)) {
     int width = 0, i;
     for (i = 0; i < 256; i++) {
       if (m_CharWidth[i] == 0 || m_CharWidth[i] == 0xffff) {
         continue;
       }
       if (width == 0) {
         width = m_CharWidth[i];
       } else if (width != m_CharWidth[i]) {
         break;
       }
     }
     if (i == 256 && width) {
       m_Flags |= PDFFONT_FIXEDPITCH;
     }
   }
   int weight = m_StemV < 140 ? m_StemV * 5 : (m_StemV * 4 + 140);
-  m_Font.LoadSubst(m_BaseFont, IsFontType(PDFFONT_TRUETYPE), m_Flags, weight,
-                   m_ItalicAngle, 0);
+  m_Font.LoadSubst(m_BaseFont, IsTrueTypeFont(), m_Flags, weight, m_ItalicAngle,
+                   0);
   if (m_Font.GetSubstFont()->m_SubstFlags & FXFONT_SUBST_NONSYMBOL) {
   }
 }
+
 FX_BOOL CPDF_SimpleFont::IsUnicodeCompatible() const {
   return m_BaseEncoding != PDFFONT_ENCODING_BUILTIN &&
          m_BaseEncoding != PDFFONT_ENCODING_ADOBE_SYMBOL &&
          m_BaseEncoding != PDFFONT_ENCODING_ZAPFDINGBATS;
 }
-CPDF_Type1Font::CPDF_Type1Font() : CPDF_SimpleFont(PDFFONT_TYPE1) {
-  m_Base14Font = -1;
+
+CFX_WideString CPDF_SimpleFont::UnicodeFromCharCode(FX_DWORD charcode) const {
+  CFX_WideString unicode = CPDF_Font::UnicodeFromCharCode(charcode);
+  if (!unicode.IsEmpty())
+    return unicode;
+  FX_WCHAR ret = m_Encoding.UnicodeFromCharCode((uint8_t)charcode);
+  if (ret == 0)
+    return CFX_WideString();
+  return ret;
 }
-FX_BOOL CPDF_Type1Font::_Load() {
+
+FX_DWORD CPDF_SimpleFont::CharCodeFromUnicode(FX_WCHAR unicode) const {
+  FX_DWORD ret = CPDF_Font::CharCodeFromUnicode(unicode);
+  if (ret)
+    return ret;
+  return m_Encoding.CharCodeFromUnicode(unicode);
+}
+
+CPDF_Type1Font::CPDF_Type1Font() : m_Base14Font(-1) {}
+
+FX_BOOL CPDF_Type1Font::Load() {
   m_Base14Font = PDF_GetStandardFontName(&m_BaseFont);
   if (m_Base14Font >= 0) {
     CPDF_Dictionary* pFontDesc = m_pFontDict->GetDictBy("FontDescriptor");
     if (pFontDesc && pFontDesc->KeyExist("Flags")) {
       m_Flags = pFontDesc->GetIntegerBy("Flags");
     } else {
       m_Flags = m_Base14Font >= 12 ? PDFFONT_SYMBOLIC : PDFFONT_NONSYMBOLIC;
     }
     if (m_Base14Font < 4)
       for (int i = 0; i < 256; i++) {
         m_CharWidth[i] = 600;
       }
     if (m_Base14Font == 12) {
       m_BaseEncoding = PDFFONT_ENCODING_ADOBE_SYMBOL;
     } else if (m_Base14Font == 13) {
       m_BaseEncoding = PDFFONT_ENCODING_ZAPFDINGBATS;
     } else if (m_Flags & PDFFONT_NONSYMBOLIC) {
       m_BaseEncoding = PDFFONT_ENCODING_STANDARD;
     }
   }
   return LoadCommon();
 }
-static FX_BOOL FT_UseType1Charmap(FXFT_Face face) {
-  if (FXFT_Get_Face_CharmapCount(face) == 0) {
-    return FALSE;
-  }
-  if (FXFT_Get_Face_CharmapCount(face) == 1 &&
-      FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[0]) ==
-          FXFT_ENCODING_UNICODE) {
-    return FALSE;
-  }
-  if (FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[0]) ==
-      FXFT_ENCODING_UNICODE) {
-    FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[1]);
-  } else {
-    FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[0]);
-  }
-  return TRUE;
-}
+
 int CPDF_Type1Font::GlyphFromCharCodeExt(FX_DWORD charcode) {
   if (charcode > 0xff) {
     return -1;
   }
   int index = m_ExtGID[(uint8_t)charcode];
   if (index == 0xffff) {
     return -1;
   }
   return index;
 }
-#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
-struct _GlyphNameMap {
-  const FX_CHAR* m_pStrAdobe;
-  const FX_CHAR* m_pStrUnicode;
-};
-static const _GlyphNameMap g_GlyphNameSubsts[] = {{"ff", "uniFB00"},
-                                                  {"fi", "uniFB01"},
-                                                  {"fl", "uniFB02"},
-                                                  {"ffi", "uniFB03"},
-                                                  {"ffl", "uniFB04"}};
-extern "C" {
-static int compareString(const void* key, const void* element) {
-  return FXSYS_stricmp((const FX_CHAR*)key,
-                       ((_GlyphNameMap*)element)->m_pStrAdobe);
-}
-}
-static const FX_CHAR* _GlyphNameRemap(const FX_CHAR* pStrAdobe) {
-  _GlyphNameMap* found = (_GlyphNameMap*)FXSYS_bsearch(
-      pStrAdobe, g_GlyphNameSubsts,
-      sizeof g_GlyphNameSubsts / sizeof(_GlyphNameMap), sizeof(_GlyphNameMap),
-      compareString);
-  if (found) {
-    return found->m_pStrUnicode;
-  }
-  return NULL;
-}
-#endif
+
 void CPDF_Type1Font::LoadGlyphMap() {
   if (!m_Font.GetFace())
     return;
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
   FX_BOOL bCoreText = TRUE;
   CQuartz2D& quartz2d =
       ((CApplePlatform*)CFX_GEModule::Get()->GetPlatformData())->_quartz2d;
   if (!m_Font.GetPlatformFont()) {
     if (m_Font.GetPsName() == CFX_WideString::FromLocal("DFHeiStd-W5")) {
@@ skipping 149 matching lines @@
     if (0 == FXFT_Select_Charmap(m_Font.GetFace(), FXFT_ENCODING_UNICODE)) {
       bUnicode = TRUE;
     }
     for (int charcode = 0; charcode < 256; charcode++) {
       const FX_CHAR* name =
           GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
       if (!name) {
         continue;
       }
       m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
-      const FX_CHAR* pStrUnicode = _GlyphNameRemap(name);
+      const FX_CHAR* pStrUnicode = GlyphNameRemap(name);
       if (pStrUnicode &&
           0 == FXFT_Get_Name_Index(m_Font.GetFace(), (char*)name)) {
         name = pStrUnicode;
       }
       m_GlyphIndex[charcode] =
           FXFT_Get_Name_Index(m_Font.GetFace(), (char*)name);
       CFStringRef name_ct = CFStringCreateWithCStringNoCopy(
           kCFAllocatorDefault, name, kCFStringEncodingASCII, kCFAllocatorNull);
       m_ExtGID[charcode] = CGFontGetGlyphWithGlyphName(
           (CGFontRef)m_Font.GetPlatformFont(), name_ct);
@@ skipping 102 matching lines @@
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
   if (!bCoreText) {
     FXSYS_memcpy(m_ExtGID, m_GlyphIndex, 256);
   }
 #endif
 }
 
 CPDF_FontEncoding::CPDF_FontEncoding() {
   FXSYS_memset(m_Unicodes, 0, sizeof(m_Unicodes));
 }
+
 int CPDF_FontEncoding::CharCodeFromUnicode(FX_WCHAR unicode) const {
   for (int i = 0; i < 256; i++)
     if (m_Unicodes[i] == unicode) {
       return i;
     }
   return -1;
 }
+
 CPDF_FontEncoding::CPDF_FontEncoding(int PredefinedEncoding) {
   const FX_WORD* pSrc = PDF_UnicodesForPredefinedCharSet(PredefinedEncoding);
   if (!pSrc) {
     FXSYS_memset(m_Unicodes, 0, sizeof(m_Unicodes));
   } else
     for (int i = 0; i < 256; i++) {
       m_Unicodes[i] = pSrc[i];
     }
 }
+
 FX_BOOL CPDF_FontEncoding::IsIdentical(CPDF_FontEncoding* pAnother) const {
   return FXSYS_memcmp(m_Unicodes, pAnother->m_Unicodes, sizeof(m_Unicodes)) ==
          0;
 }
+
 CPDF_Object* CPDF_FontEncoding::Realize() {
   int predefined = 0;
   for (int cs = PDFFONT_ENCODING_WINANSI; cs < PDFFONT_ENCODING_ZAPFDINGBATS;
        cs++) {
     const FX_WORD* pSrc = PDF_UnicodesForPredefinedCharSet(cs);
     FX_BOOL match = TRUE;
     for (int i = 0; i < 256; ++i) {
       if (m_Unicodes[i] != pSrc[i]) {
         match = FALSE;
         break;
@@ skipping 25 matching lines @@
     }
     pDiff->Add(new CPDF_Number(i));
     pDiff->Add(new CPDF_Name(PDF_AdobeNameFromUnicode(m_Unicodes[i])));
   }
 
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
   pDict->SetAtName("BaseEncoding", "WinAnsiEncoding");
   pDict->SetAt("Differences", pDiff);
   return pDict;
 }
-CPDF_TrueTypeFont::CPDF_TrueTypeFont() : CPDF_SimpleFont(PDFFONT_TRUETYPE) {}
-FX_BOOL CPDF_TrueTypeFont::_Load() {
+
+CPDF_TrueTypeFont::CPDF_TrueTypeFont() {}
+
+FX_BOOL CPDF_TrueTypeFont::Load() {
   return LoadCommon();
 }
+
 void CPDF_TrueTypeFont::LoadGlyphMap() {
   if (!m_Font.GetFace())
     return;
 
   int baseEncoding = m_BaseEncoding;
   if (m_pFontFile && m_Font.GetFace()->num_charmaps > 0 &&
       (baseEncoding == PDFFONT_ENCODING_MACROMAN ||
        baseEncoding == PDFFONT_ENCODING_WINANSI) &&
       (m_Flags & PDFFONT_SYMBOLIC)) {
     FX_BOOL bSupportWin = FALSE;
@@ skipping 177 matching lines @@
     if (bGotOne) {
       return;
     }
   }
   for (int charcode = 0; charcode < 256; charcode++) {
     m_GlyphIndex[charcode] = charcode;
   }
 }
 
 CPDF_Type3Font::CPDF_Type3Font()
-    : CPDF_SimpleFont(PDFFONT_TYPE3),
-      m_pCharProcs(nullptr),
+    : m_pCharProcs(nullptr),
       m_pPageResources(nullptr),
       m_pFontResources(nullptr) {
   FXSYS_memset(m_CharWidthL, 0, sizeof(m_CharWidthL));
 }
 
 CPDF_Type3Font::~CPDF_Type3Font() {
   for (auto it : m_CacheMap)
     delete it.second;
 }
 
-FX_BOOL CPDF_Type3Font::_Load() {
+FX_BOOL CPDF_Type3Font::Load() {
   m_pFontResources = m_pFontDict->GetDictBy("Resources");
   CPDF_Array* pMatrix = m_pFontDict->GetArrayBy("FontMatrix");
   FX_FLOAT xscale = 1.0f, yscale = 1.0f;
   if (pMatrix) {
     m_FontMatrix = pMatrix->GetMatrix();
     xscale = m_FontMatrix.a;
     yscale = m_FontMatrix.d;
   }
   CPDF_Array* pBBox = m_pFontDict->GetArrayBy("FontBBox");
   if (pBBox) {
@@ skipping 25 matching lines @@
       for (int i = 0; i < 256; i++) {
         m_Encoding.m_Unicodes[i] = PDF_UnicodeFromAdobeName(m_pCharNames[i]);
         if (m_Encoding.m_Unicodes[i] == 0) {
           m_Encoding.m_Unicodes[i] = i;
         }
       }
     }
   }
   return TRUE;
 }
+
 void CPDF_Type3Font::CheckType3FontMetrics() {
   CheckFontMetrics();
 }
 
 CPDF_Type3Char* CPDF_Type3Font::LoadChar(FX_DWORD charcode, int level) {
   if (level >= _FPDF_MAX_TYPE3_FORM_LEVEL_)
     return nullptr;
 
   auto it = m_CacheMap.find(charcode);
   if (it != m_CacheMap.end())
@@ skipping 70 matching lines @@
   rect = pChar->m_BBox;
 }
 
 CPDF_Type3Char::CPDF_Type3Char(CPDF_Form* pForm)
     : m_pForm(pForm), m_pBitmap(nullptr), m_bColored(FALSE) {}
 
 CPDF_Type3Char::~CPDF_Type3Char() {
   delete m_pForm;
   delete m_pBitmap;
 }