Properly ref-count CFGAS_GEFont with CFX_RetainPtr.

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/xfa_fontmgr.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 1722 matching lines @@
                        });
   if (pFontInfo < pEnd && pFontInfo->dwFontNameHash == dwCurFontNameHash)
     return pFontInfo;
   return nullptr;
 }
 
 }  // namespace
 
 CXFA_DefFontMgr::CXFA_DefFontMgr() {}
 
-CXFA_DefFontMgr::~CXFA_DefFontMgr() {
-  for (int32_t i = 0; i < m_CacheFonts.GetSize(); i++)
-    m_CacheFonts[i]->Release();
-}
+CXFA_DefFontMgr::~CXFA_DefFontMgr() {}
 
-CFGAS_GEFont* CXFA_DefFontMgr::GetFont(CXFA_FFDoc* hDoc,
-                                       const CFX_WideStringC& wsFontFamily,
-                                       uint32_t dwFontStyles,
-                                       uint16_t wCodePage) {
+CFX_RetainPtr<CFGAS_GEFont> CXFA_DefFontMgr::GetFont(
+    CXFA_FFDoc* hDoc,
+    const CFX_WideStringC& wsFontFamily,
+    uint32_t dwFontStyles,
+    uint16_t wCodePage) {
   CFX_WideString wsFontName(wsFontFamily);
   CFGAS_FontMgr* pFDEFontMgr = hDoc->GetApp()->GetFDEFontMgr();
-  CFGAS_GEFont* pFont =
+  CFX_RetainPtr<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 13 matching lines @@
         if (pFont)
           break;
 
         iLength--;
         pNameText++;
         pReplace = pNameText;
       }
     }
   }
   if (pFont)
-    m_CacheFonts.Add(pFont);
+    m_CacheFonts.push_back(pFont);
   return pFont;
 }
 
-CFGAS_GEFont* CXFA_DefFontMgr::GetDefaultFont(
+CFX_RetainPtr<CFGAS_GEFont> CXFA_DefFontMgr::GetDefaultFont(
     CXFA_FFDoc* hDoc,
     const CFX_WideStringC& wsFontFamily,
     uint32_t dwFontStyles,
     uint16_t wCodePage) {
   CFGAS_FontMgr* pFDEFontMgr = hDoc->GetApp()->GetFDEFontMgr();
-  CFGAS_GEFont* pFont =
+  CFX_RetainPtr<CFGAS_GEFont> pFont =
       pFDEFontMgr->LoadFont(L"Arial Narrow", dwFontStyles, wCodePage);
   if (!pFont) {
     pFont = pFDEFontMgr->LoadFont(static_cast<const FX_WCHAR*>(nullptr),
                                   dwFontStyles, wCodePage);
   }
-
-  ASSERT(pFont);
   if (pFont)
-    m_CacheFonts.Add(pFont);
+    m_CacheFonts.push_back(pFont);
   return pFont;
 }
 
 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();
-  }
-}
+CXFA_PDFFontMgr::~CXFA_PDFFontMgr() {}
 
-CFGAS_GEFont* CXFA_PDFFontMgr::FindFont(const CFX_ByteString& strPsName,
-                                        bool bBold,
-                                        bool bItalic,
-                                        CPDF_Font** pDstPDFFont,
-                                        bool bStrictMatch) {
+CFX_RetainPtr<CFGAS_GEFont> CXFA_PDFFontMgr::FindFont(
+    const CFX_ByteString& strPsName,
+    bool bBold,
+    bool bItalic,
+    CPDF_Font** pDstPDFFont,
+    bool bStrictMatch) {
   CPDF_Document* pDoc = m_pDoc->GetPDFDoc();
-  if (!pDoc) {
+  if (!pDoc)
     return nullptr;
-  }
+
   CPDF_Dictionary* pFontSetDict =
       pDoc->GetRoot()->GetDictFor("AcroForm")->GetDictFor("DR");
-  if (!pFontSetDict) {
+  if (!pFontSetDict)
     return nullptr;
-  }
+
   pFontSetDict = pFontSetDict->GetDictFor("Font");
-  if (!pFontSetDict) {
+  if (!pFontSetDict)
     return nullptr;
-  }
+
   CFX_ByteString name = strPsName;
   name.Remove(' ');
   CFGAS_FontMgr* pFDEFontMgr = m_pDoc->GetApp()->GetFDEFontMgr();
   for (const auto& it : *pFontSetDict) {
     const CFX_ByteString& key = it.first;
     CPDF_Object* pObj = it.second.get();
     if (!PsNameMatchDRFontName(name.AsStringC(), bBold, bItalic, key,
                                bStrictMatch)) {
       continue;
     }
     CPDF_Dictionary* pFontDict = ToDictionary(pObj->GetDirect());
     if (!pFontDict || pFontDict->GetStringFor("Type") != "Font") {
       return nullptr;
     }
     CPDF_Font* pPDFFont = pDoc->LoadFont(pFontDict);
     if (!pPDFFont) {
       return nullptr;
     }
     if (!pPDFFont->IsEmbedded()) {
       *pDstPDFFont = pPDFFont;
       return nullptr;
     }
     return CFGAS_GEFont::LoadFont(&pPDFFont->m_Font, pFDEFontMgr);
   }
   return nullptr;
 }
 
-CFGAS_GEFont* CXFA_PDFFontMgr::GetFont(const CFX_WideStringC& wsFontFamily,
-                                       uint32_t dwFontStyles,
-                                       CPDF_Font** pPDFFont,
-                                       bool bStrictMatch) {
+CFX_RetainPtr<CFGAS_GEFont> CXFA_PDFFontMgr::GetFont(
+    const CFX_WideStringC& wsFontFamily,
+    uint32_t dwFontStyles,
+    CPDF_Font** pPDFFont,
+    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));
   bool bBold = (dwFontStyles & FX_FONTSTYLE_Bold) == FX_FONTSTYLE_Bold;
   bool bItalic = (dwFontStyles & FX_FONTSTYLE_Italic) == FX_FONTSTYLE_Italic;
   CFX_ByteString strFontName = PsNameToFontName(bsPsName, bBold, bItalic);
-  CFGAS_GEFont* pFont =
+  CFX_RetainPtr<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,
     bool bBold,
     bool bItalic) {
@@ skipping 77 matching lines @@
         } break;
         default:
           break;
       }
       return bMatch;
     }
   }
   return true;
 }
 
-bool CXFA_PDFFontMgr::GetCharWidth(const CFGAS_GEFont* pFont,
+bool CXFA_PDFFontMgr::GetCharWidth(const CFX_RetainPtr<CFGAS_GEFont>& pFont,
                                    FX_WCHAR wUnicode,
                                    bool bCharCode,
                                    int32_t* pWidth) {
   if (wUnicode != 0x20 || bCharCode)
     return false;
 
   auto it = m_FDE2PDFFont.find(pFont);
   if (it == m_FDE2PDFFont.end())
     return false;
 
   CPDF_Font* pPDFFont = it->second;
   *pWidth = pPDFFont->GetCharWidthF(pPDFFont->CharCodeFromUnicode(wUnicode));
   return true;
 }
 
-void CXFA_PDFFontMgr::SetFont(const CFGAS_GEFont* pFont, CPDF_Font* pPDFFont) {
+void CXFA_PDFFontMgr::SetFont(const CFX_RetainPtr<CFGAS_GEFont>& pFont,
+                              CPDF_Font* pPDFFont) {
   m_FDE2PDFFont[pFont] = pPDFFont;
 }
 
 CXFA_FontMgr::CXFA_FontMgr() {}
 
 CXFA_FontMgr::~CXFA_FontMgr() {}
 
-CFGAS_GEFont* CXFA_FontMgr::GetFont(CXFA_FFDoc* hDoc,
-                                    const CFX_WideStringC& wsFontFamily,
-                                    uint32_t dwFontStyles,
-                                    uint16_t wCodePage) {
+CFX_RetainPtr<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);
   auto it = m_PDFFontMgrMap.find(hDoc);
   CXFA_PDFFontMgr* pMgr =
       it != m_PDFFontMgrMap.end() ? it->second.get() : nullptr;
   CPDF_Font* pPDFFont = nullptr;
-  CFGAS_GEFont* pFont = nullptr;
+  CFX_RetainPtr<CFGAS_GEFont> pFont;
   if (pMgr) {
     pFont =
         pMgr->GetFont(wsEnglishName.AsStringC(), dwFontStyles, &pPDFFont, true);
     if (pFont)
       return pFont;
   }
   if (!pFont && m_pDefFontMgr)
     pFont = m_pDefFontMgr->GetFont(hDoc, wsFontFamily, dwFontStyles, wCodePage);
 
   if (!pFont && pMgr) {
@@ skipping 22 matching lines @@
     m_PDFFontMgrMap[hDoc] = pdfium::MakeUnique<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);
 }