Replace IFGAS_Font with underlying concrete type

xfa/fxfa/app/xfa_fontmgr.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 "xfa/fxfa/include/xfa_fontmgr.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
+#include "xfa/fgas/font/fgas_gefont.h"
 #include "xfa/fxfa/include/xfa_ffapp.h"
 #include "xfa/fxfa/include/xfa_ffdoc.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 static const XFA_FONTINFO g_XFAFontsMap[] = {
     {0x01d5d33e, L"SimSun", L"Arial", 0, 936},
     {0x01e4f102, L"YouYuan", L"Arial", 1, 936},
     {0x030549dc, L"LiSu", L"Arial", 1, 936},
     {0x032edd44, L"Simhei", L"Arial", 1, 936},
     {0x03eac6fc, L"PoorRichard-Regular", L"Arial", 2, 1252},
@@ skipping 1710 matching lines @@
     }
   } while (iEnd >= iStart);
   return pFontInfo;
 }
 
 CXFA_DefFontMgr::~CXFA_DefFontMgr() {
   for (int32_t i = 0; i < m_CacheFonts.GetSize(); i++)
     m_CacheFonts[i]->Release();
 }
 
-IFGAS_Font* CXFA_DefFontMgr::GetFont(CXFA_FFDoc* hDoc,
-                                     const CFX_WideStringC& wsFontFamily,
-                                     uint32_t dwFontStyles,
-                                     uint16_t wCodePage) {
+CFGAS_GEFont* CXFA_DefFontMgr::GetFont(CXFA_FFDoc* hDoc,
+                                       const CFX_WideStringC& wsFontFamily,
+                                       uint32_t dwFontStyles,
+                                       uint16_t wCodePage) {
   CFX_WideString wsFontName(wsFontFamily);
   IFGAS_FontMgr* pFDEFontMgr = hDoc->GetApp()->GetFDEFontMgr();
-  IFGAS_Font* pFont =
+  CFGAS_GEFont* pFont =
       pFDEFontMgr->LoadFont(wsFontName.c_str(), dwFontStyles, wCodePage);
   if (!pFont) {
     const XFA_FONTINFO* pCurFont =
         XFA_GetFontINFOByFontName(wsFontName.AsStringC());
     if (pCurFont && pCurFont->pReplaceFont) {
       uint32_t dwStyle = 0;
       if (dwFontStyles & FX_FONTSTYLE_Bold) {
         dwStyle |= FX_FONTSTYLE_Bold;
       }
       if (dwFontStyles & FX_FONTSTYLE_Italic) {
@@ skipping 18 matching lines @@
         pReplace = pNameText;
       }
     }
   }
   if (pFont) {
     m_CacheFonts.Add(pFont);
   }
   return pFont;
 }
 
-IFGAS_Font* CXFA_DefFontMgr::GetDefaultFont(CXFA_FFDoc* hDoc,
-                                            const CFX_WideStringC& wsFontFamily,
-                                            uint32_t dwFontStyles,
-                                            uint16_t wCodePage) {
+CFGAS_GEFont* CXFA_DefFontMgr::GetDefaultFont(
+    CXFA_FFDoc* hDoc,
+    const CFX_WideStringC& wsFontFamily,
+    uint32_t dwFontStyles,
+    uint16_t wCodePage) {
   IFGAS_FontMgr* pFDEFontMgr = hDoc->GetApp()->GetFDEFontMgr();
-  IFGAS_Font* pFont =
+  CFGAS_GEFont* pFont =
       pFDEFontMgr->LoadFont(L"Arial Narrow", dwFontStyles, wCodePage);
   if (!pFont)
     pFont =
         pFDEFontMgr->LoadFont((const FX_WCHAR*)NULL, dwFontStyles, wCodePage);
   ASSERT(pFont);
   if (pFont) {
     m_CacheFonts.Add(pFont);
   }
   return pFont;
 }
@@ skipping 11 matching lines @@
 };
 CXFA_PDFFontMgr::CXFA_PDFFontMgr(CXFA_FFDoc* pDoc) {
   m_pDoc = pDoc;
 }
 CXFA_PDFFontMgr::~CXFA_PDFFontMgr() {
   for (const auto& pair : m_FontMap) {
     if (pair.second)
       pair.second->Release();
   }
 }
-IFGAS_Font* CXFA_PDFFontMgr::FindFont(CFX_ByteString strPsName,
-                                      FX_BOOL bBold,
-                                      FX_BOOL bItalic,
-                                      CPDF_Font** pDstPDFFont,
-                                      FX_BOOL bStrictMatch) {
+CFGAS_GEFont* CXFA_PDFFontMgr::FindFont(CFX_ByteString strPsName,
+                                        FX_BOOL bBold,
+                                        FX_BOOL bItalic,
+                                        CPDF_Font** pDstPDFFont,
+                                        FX_BOOL bStrictMatch) {
   CPDF_Document* pDoc = m_pDoc->GetPDFDoc();
   if (pDoc == NULL) {
     return NULL;
   }
   CPDF_Dictionary* pFontSetDict =
       pDoc->GetRoot()->GetDictBy("AcroForm")->GetDictBy("DR");
   if (!pFontSetDict) {
     return NULL;
   }
   pFontSetDict = (CPDF_Dictionary*)pFontSetDict->GetDictBy("Font");
@@ skipping 18 matching lines @@
       return NULL;
     }
     CPDF_Font* pPDFFont = pDoc->LoadFont(pFontDict);
     if (!pPDFFont) {
       return NULL;
     }
     if (!pPDFFont->IsEmbedded()) {
       *pDstPDFFont = pPDFFont;
       return NULL;
     }
-    return IFGAS_Font::LoadFont(&pPDFFont->m_Font, pFDEFontMgr);
+    return CFGAS_GEFont::LoadFont(&pPDFFont->m_Font, pFDEFontMgr, FALSE);
   }
   return NULL;
 }
 
-IFGAS_Font* CXFA_PDFFontMgr::GetFont(const CFX_WideStringC& wsFontFamily,
-                                     uint32_t dwFontStyles,
-                                     CPDF_Font** pPDFFont,
-                                     FX_BOOL bStrictMatch) {
+CFGAS_GEFont* CXFA_PDFFontMgr::GetFont(const CFX_WideStringC& wsFontFamily,
+                                       uint32_t dwFontStyles,
+                                       CPDF_Font** pPDFFont,
+                                       FX_BOOL bStrictMatch) {
   uint32_t dwHashCode = FX_HashCode_GetW(wsFontFamily, false);
   CFX_ByteString strKey;
   strKey.Format("%u%u", dwHashCode, dwFontStyles);
   auto it = m_FontMap.find(strKey);
   if (it != m_FontMap.end())
     return it->second;
   CFX_ByteString bsPsName =
       CFX_ByteString::FromUnicode(CFX_WideString(wsFontFamily));
   FX_BOOL bBold = (dwFontStyles & FX_FONTSTYLE_Bold) == FX_FONTSTYLE_Bold;
   FX_BOOL bItalic = (dwFontStyles & FX_FONTSTYLE_Italic) == FX_FONTSTYLE_Italic;
   CFX_ByteString strFontName = PsNameToFontName(bsPsName, bBold, bItalic);
-  IFGAS_Font* pFont =
+  CFGAS_GEFont* pFont =
       FindFont(strFontName, bBold, bItalic, pPDFFont, bStrictMatch);
   if (pFont)
     m_FontMap[strKey] = pFont;
   return pFont;
 }
 
 CFX_ByteString CXFA_PDFFontMgr::PsNameToFontName(
     const CFX_ByteString& strPsName,
     FX_BOOL bBold,
     FX_BOOL bItalic) {
@@ skipping 74 matching lines @@
           }
         } break;
         default:
           break;
       }
       return bMatch;
     }
   }
   return TRUE;
 }
-FX_BOOL CXFA_PDFFontMgr::GetCharWidth(IFGAS_Font* pFont,
+FX_BOOL CXFA_PDFFontMgr::GetCharWidth(CFGAS_GEFont* pFont,
                                       FX_WCHAR wUnicode,
                                       int32_t& iWidth,
                                       FX_BOOL bCharCode) {
   if (wUnicode != 0x20 || bCharCode)
     return FALSE;
 
   auto it = m_FDE2PDFFont.find(pFont);
   if (it == m_FDE2PDFFont.end())
     return FALSE;
 
   CPDF_Font* pPDFFont = it->second;
   iWidth = pPDFFont->GetCharWidthF(pPDFFont->CharCodeFromUnicode(wUnicode));
   return TRUE;
 }
 
 CXFA_FontMgr::CXFA_FontMgr() {}
 
 CXFA_FontMgr::~CXFA_FontMgr() {}
 
-IFGAS_Font* CXFA_FontMgr::GetFont(CXFA_FFDoc* hDoc,
-                                  const CFX_WideStringC& wsFontFamily,
-                                  uint32_t dwFontStyles,
-                                  uint16_t wCodePage) {
+CFGAS_GEFont* CXFA_FontMgr::GetFont(CXFA_FFDoc* hDoc,
+                                    const CFX_WideStringC& wsFontFamily,
+                                    uint32_t dwFontStyles,
+                                    uint16_t wCodePage) {
   uint32_t dwHash = FX_HashCode_GetW(wsFontFamily, false);
   CFX_ByteString bsKey;
   bsKey.Format("%u%u%u", dwHash, dwFontStyles, wCodePage);
   auto iter = m_FontMap.find(bsKey);
   if (iter != m_FontMap.end())
     return iter->second;
   CFX_WideString wsEnglishName;
   XFA_LocalFontNameToEnglishName(wsFontFamily, wsEnglishName);
   auto it = m_PDFFontMgrMap.find(hDoc);
   CXFA_PDFFontMgr* pMgr =
       it != m_PDFFontMgrMap.end() ? it->second.get() : nullptr;
   CPDF_Font* pPDFFont = nullptr;
-  IFGAS_Font* pFont = nullptr;
+  CFGAS_GEFont* pFont = nullptr;
   if (pMgr) {
     pFont = pMgr->GetFont(wsEnglishName.AsStringC(), dwFontStyles, &pPDFFont);
     if (pFont)
       return pFont;
   }
   if (!pFont && m_pDefFontMgr)
     pFont = m_pDefFontMgr->GetFont(hDoc, wsFontFamily, dwFontStyles, wCodePage);
 
   if (!pFont && pMgr) {
     pPDFFont = nullptr;
@@ skipping 21 matching lines @@
     m_PDFFontMgrMap[hDoc].reset(new CXFA_PDFFontMgr(hDoc));
 }
 
 void CXFA_FontMgr::ReleaseDocFonts(CXFA_FFDoc* hDoc) {
   m_PDFFontMgrMap.erase(hDoc);
 }
 
 void CXFA_FontMgr::SetDefFontMgr(std::unique_ptr<CXFA_DefFontMgr> pFontMgr) {
   m_pDefFontMgr = std::move(pFontMgr);
 }