Remove dead code in CFGAS_FontMgrImp.

xfa/fgas/font/fgas_stdfontmgr.cpp

 // Copyright 2015 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/fgas/font/fgas_stdfontmgr.h"
 
 #include "core/fxcrt/include/fx_stream.h"
 #include "core/fxge/include/fx_ge.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/font/fgas_fontutils.h"
 #include "xfa/fgas/font/fgas_gefont.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 IFGAS_FontMgr* IFGAS_FontMgr::Create(FX_LPEnumAllFonts pEnumerator) {
   return new CFGAS_StdFontMgrImp(pEnumerator);
 }
 CFGAS_StdFontMgrImp::CFGAS_StdFontMgrImp(FX_LPEnumAllFonts pEnumerator)
     : m_pEnumerator(pEnumerator),
       m_FontFaces(),
       m_CPFonts(8),
       m_FamilyFonts(16),
       m_UnicodeFonts(16),
       m_BufferFonts(4),
-      m_FileFonts(4),
       m_StreamFonts(4),
       m_DeriveFonts(4) {
   if (m_pEnumerator) {
     m_pEnumerator(m_FontFaces, NULL, 0xFEFF);
   }
 }
 
 CFGAS_StdFontMgrImp::~CFGAS_StdFontMgrImp() {
   m_FontFaces.RemoveAll();
   m_CPFonts.RemoveAll();
   m_FamilyFonts.RemoveAll();
   m_UnicodeFonts.RemoveAll();
   m_BufferFonts.RemoveAll();
-  m_FileFonts.RemoveAll();
   m_StreamFonts.RemoveAll();
   m_DeriveFonts.RemoveAll();
   for (int32_t i = m_Fonts.GetUpperBound(); i >= 0; i--)
     m_Fonts[i]->Release();
 }
 
 CFGAS_GEFont* CFGAS_StdFontMgrImp::GetDefFontByCodePage(
     uint16_t wCodePage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
@@ skipping 116 matching lines @@
     }
   }
   pFont = CFGAS_GEFont::LoadFont(pBuffer, iLength, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_BufferFonts.SetAt((void*)pBuffer, pFont);
     return pFont->Retain();
   }
   return NULL;
 }
-CFGAS_GEFont* CFGAS_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFileName) {
-  ASSERT(pszFileName);
-  uint32_t dwHash = FX_HashCode_GetW(pszFileName, false);
-  CFGAS_GEFont* pFont = NULL;
-  if (m_FileFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
-    if (pFont) {
-      return pFont->Retain();
-    }
-  }
-  pFont = CFGAS_GEFont::LoadFont(pszFileName);
-  if (pFont) {
-    m_Fonts.Add(pFont);
-    m_FileFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    return pFont->Retain();
-  }
-  return NULL;
-}
+
 CFGAS_GEFont* CFGAS_StdFontMgrImp::LoadFont(IFX_Stream* pFontStream,
                                             const FX_WCHAR* pszFontAlias,
                                             uint32_t dwFontStyles,
                                             uint16_t wCodePage,
                                             FX_BOOL bSaveStream) {
   ASSERT(pFontStream && pFontStream->GetLength() > 0);
   CFGAS_GEFont* pFont = NULL;
   if (m_StreamFonts.Lookup((void*)pFontStream, (void*&)pFont)) {
     if (pFont) {
       if (pszFontAlias) {
@@ skipping 66 matching lines @@
     }
     fontMap.RemoveKey(pKey);
     break;
   }
 }
 void CFGAS_StdFontMgrImp::RemoveFont(CFGAS_GEFont* pFont) {
   RemoveFont(m_CPFonts, pFont);
   RemoveFont(m_FamilyFonts, pFont);
   RemoveFont(m_UnicodeFonts, pFont);
   RemoveFont(m_BufferFonts, pFont);
-  RemoveFont(m_FileFonts, pFont);
   RemoveFont(m_StreamFonts, pFont);
   RemoveFont(m_DeriveFonts, pFont);
   int32_t iFind = m_Fonts.Find(pFont);
   if (iFind > -1) {
     m_Fonts.RemoveAt(iFind, 1);
   }
 }
 FX_FONTDESCRIPTOR const* CFGAS_StdFontMgrImp::FindFont(
     const FX_WCHAR* pszFontFamily,
     uint32_t dwFontStyles,
@@ skipping 341 matching lines @@
     delete pDescs;
   }
   pos = m_Hash2Fonts.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_ArrayTemplate<CFGAS_GEFont*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
     delete pFonts;
   }
   m_Hash2Fonts.RemoveAll();
-  pos = m_Hash2FileAccess.GetStartPosition();
-  while (pos) {
-    uint32_t dwHash;
-    IFX_FileAccess* pFileAccess;
-    m_Hash2FileAccess.GetNextAssoc(pos, dwHash, pFileAccess);
-    if (NULL != pFileAccess) {
-      pFileAccess->Release();
-    }
-  }
-  pos = m_FileAccess2IFXFont.GetStartPosition();
-  while (pos) {
-    uint32_t dwHash;
-    CFGAS_GEFont* pFont;
-    m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pFont);
-    if (NULL != pFont) {
-      pFont->Release();
-    }
-  }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     CFGAS_GEFont* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
   delete this;
 }
 CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByCodePage(
@@ skipping 47 matching lines @@
     sortedFonts = new CFX_FontDescriptorInfos;
     MatchFonts(*sortedFonts, wCodePage, dwFontStyles,
                CFX_WideString(pszFontFamily), 0);
     m_Hash2CandidateList.SetAt(dwHash, sortedFonts);
   }
   if (sortedFonts->GetSize() == 0)
     return nullptr;
 
   CFX_FontDescriptor* pDesc = sortedFonts->GetAt(0).pFont;
   CFGAS_GEFont* pFont =
-      pDesc->m_pFileAccess
-          ? LoadFont(pDesc->m_pFileAccess, pDesc->m_nFaceIndex, nullptr)
-          : LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
+      LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
   if (pFont)
     pFont->SetLogicalFontStyle(dwFontStyles);
 
   pFonts->Add(pFont);
   return pFont;
 }
 CFGAS_GEFont* CFGAS_FontMgrImp::GetFontByCharset(
     uint8_t nCharset,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
@@ skipping 33 matching lines @@
   if (!m_Hash2CandidateList.Lookup(dwHash, sortedFonts)) {
     sortedFonts = new CFX_FontDescriptorInfos;
     MatchFonts(*sortedFonts, wCodePage, dwFontStyles,
                CFX_WideString(pszFontFamily), wUnicode);
     m_Hash2CandidateList.SetAt(dwHash, sortedFonts);
   }
   for (int32_t i = 0; i < sortedFonts->GetSize(); ++i) {
     CFX_FontDescriptor* pDesc = sortedFonts->GetAt(i).pFont;
     if (!VerifyUnicode(pDesc, wUnicode))
       continue;
-    if (pDesc->m_pFileAccess)
-      pFont = LoadFont(pDesc->m_pFileAccess, pDesc->m_nFaceIndex, nullptr);
-    else
-      pFont = LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
+    pFont = LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
     if (!pFont)
       continue;
     pFont->SetLogicalFontStyle(dwFontStyles);
     pFonts->Add(pFont);
     return pFont;
   }
   if (!pszFontFamily)
     m_FailedUnicodes2NULL.SetAt(wUnicode, nullptr);
   return nullptr;
 }
 FX_BOOL CFGAS_FontMgrImp::VerifyUnicode(CFX_FontDescriptor* pDesc,
                                         FX_WCHAR wcUnicode) {
-  IFX_FileRead* pFileRead = nullptr;
-  if (pDesc->m_pFileAccess)
-    pFileRead = pDesc->m_pFileAccess->CreateFileStream(FX_FILEMODE_ReadOnly);
-  else
-    pFileRead = CreateFontStream(pDesc->m_wsFaceName.UTF8Encode());
+  IFX_FileRead* pFileRead = CreateFontStream(pDesc->m_wsFaceName.UTF8Encode());
   if (!pFileRead)
     return FALSE;
   FXFT_Face pFace = LoadFace(pFileRead, pDesc->m_nFaceIndex);
   FT_Error retCharmap = FXFT_Select_Charmap(pFace, FXFT_ENCODING_UNICODE);
   FT_Error retIndex = FXFT_Get_Char_Index(pFace, wcUnicode);
   pFileRead->Release();
   if (!pFace)
     return FALSE;
   if (FXFT_Get_Face_External_Stream(pFace))
     FXFT_Clear_Face_External_Stream(pFace);
@@ skipping 19 matching lines @@
 }
 
 CFGAS_GEFont* CFGAS_FontMgrImp::GetFontByLanguage(
     uint16_t wLanguage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage), dwFontStyles,
                            pszFontFamily);
 }
 
-CFGAS_GEFont* CFGAS_FontMgrImp::LoadFont(const uint8_t* pBuffer,
-                                         int32_t iLength,
-                                         int32_t iFaceIndex,
-                                         int32_t* pFaceCount) {
-  void* Hash[2] = {(void*)(uintptr_t)pBuffer, (void*)(uintptr_t)iLength};
-  uint32_t dwHash =
-      FX_HashCode_GetA(CFX_ByteStringC((uint8_t*)Hash, sizeof(Hash)), false);
-  IFX_FileAccess* pFontAccess = nullptr;
-  m_Hash2FileAccess.Lookup(dwHash, pFontAccess);
-  return pFontAccess ? LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE)
-                     : nullptr;
-}
-
-CFGAS_GEFont* CFGAS_FontMgrImp::LoadFont(const FX_WCHAR* pszFileName,
-                                         int32_t iFaceIndex,
-                                         int32_t* pFaceCount) {
-  CFX_ByteString bsHash;
-  bsHash += CFX_WideString(pszFileName).UTF8Encode();
-
-  uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false);
-  IFX_FileAccess* pFontAccess = nullptr;
-  if (!m_Hash2FileAccess.Lookup(dwHash, pFontAccess)) {
-    pFontAccess = FX_CreateDefaultFileAccess(pszFileName);
-    m_Hash2FileAccess.SetAt(dwHash, pFontAccess);
-  }
-
-  return pFontAccess ? LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE)
-                     : nullptr;
-}
-
-CFGAS_GEFont* CFGAS_FontMgrImp::LoadFont(IFX_Stream* pFontStream,
-                                         int32_t iFaceIndex,
-                                         int32_t* pFaceCount,
-                                         FX_BOOL bSaveStream) {
-  void* Hash[1] = {(void*)(uintptr_t)pFontStream};
-  uint32_t dwHash =
-      FX_HashCode_GetA(CFX_ByteStringC((uint8_t*)Hash, sizeof(Hash)), false);
-  IFX_FileAccess* pFontAccess = nullptr;
-  m_Hash2FileAccess.Lookup(dwHash, pFontAccess);
-
-  return pFontAccess ? LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE)
-                     : nullptr;
-}
-
-CFGAS_GEFont* CFGAS_FontMgrImp::LoadFont(IFX_FileAccess* pFontAccess,
-                                         int32_t iFaceIndex,
-                                         int32_t* pFaceCount,
-                                         FX_BOOL bWantCache) {
-  uint32_t dwHash = 0;
-  CFGAS_GEFont* pFont = nullptr;
-  if (bWantCache) {
-    CFX_ByteString bsHash;
-    bsHash.Format("%d, %d", (uintptr_t)pFontAccess, iFaceIndex);
-    dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false);
-    if (m_FileAccess2IFXFont.Lookup(dwHash, pFont)) {
-      if (pFont) {
-        if (pFaceCount)
-          *pFaceCount = pFont->GetDevFont()->GetFace()->num_faces;
-        return pFont->Retain();
-      }
-    }
-  }
-
-  CFX_Font* pInternalFont = new CFX_Font;
-  IFX_FileRead* pFontStream =
-      pFontAccess->CreateFileStream(FX_FILEMODE_ReadOnly);
-  if (!pFontStream) {
-    delete pInternalFont;
-    return nullptr;
-  }
-  if (!pInternalFont->LoadFile(pFontStream, iFaceIndex)) {
-    delete pInternalFont;
-    pFontStream->Release();
-    return nullptr;
-  }
-  pFont = CFGAS_GEFont::LoadFont(pInternalFont, this, TRUE);
-  if (!pFont) {
-    delete pInternalFont;
-    pFontStream->Release();
-    return nullptr;
-  }
-  if (bWantCache)
-    m_FileAccess2IFXFont.SetAt(dwHash, pFont);
-
-  m_IFXFont2FileRead.SetAt(pFont, pFontStream);
-  if (pFaceCount)
-    *pFaceCount = pFont->GetDevFont()->GetFace()->num_faces;
-
-  return pFont;
-}
-
 CFGAS_GEFont* CFGAS_FontMgrImp::LoadFont(const CFX_WideString& wsFaceName,
                                          int32_t iFaceIndex,
                                          int32_t* pFaceCount) {
   CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
   CFX_FontMapper* pFontMapper = pFontMgr->GetBuiltinMapper();
   if (!pFontMapper)
     return nullptr;
 
   IFX_SystemFontInfo* pSystemFontInfo = pFontMapper->GetSystemFontInfo();
   if (!pSystemFontInfo)
     return nullptr;
 
   IFX_FileRead* pFontStream = CreateFontStream(wsFaceName.UTF8Encode());
   if (!pFontStream)
     return nullptr;
 
   if (!LoadFace(pFontStream, 0)) {
     pFontStream->Release();
     return nullptr;
   }
 
   CFX_Font* pInternalFont = new CFX_Font();
   if (!pInternalFont->LoadFile(pFontStream, iFaceIndex)) {
     pFontStream->Release();
     return nullptr;
   }
 
-  CFGAS_GEFont* pFont = CFGAS_GEFont::LoadFont(pInternalFont, this, FALSE);
+  CFGAS_GEFont* pFont = CFGAS_GEFont::LoadFont(pInternalFont, this);
   if (!pFont) {
     pFontStream->Release();
     return nullptr;
   }
 
   m_IFXFont2FileRead.SetAt(pFont, pFontStream);
   if (pFaceCount)
     *pFaceCount = pFont->GetDevFont()->GetFace()->num_faces;
 
   return pFont;
@@ skipping 240 matching lines @@
   return nPenalty;
 }
 void CFGAS_FontMgrImp::ClearFontCache() {
   FX_POSITION pos = m_Hash2CandidateList.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_FontDescriptorInfos* pDescs;
     m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs);
     delete pDescs;
   }
-  pos = m_FileAccess2IFXFont.GetStartPosition();
-  while (pos) {
-    uint32_t dwHash;
-    CFGAS_GEFont* pFont;
-    m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pFont);
-    if (NULL != pFont) {
-      pFont->Release();
-    }
-  }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     CFGAS_GEFont* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
 }
 void CFGAS_FontMgrImp::RemoveFont(CFGAS_GEFont* pEFont) {
   if (NULL == pEFont) {
     return;
   }
   IFX_FileRead* pFileRead;
   if (m_IFXFont2FileRead.Lookup(pEFont, pFileRead)) {
     pFileRead->Release();
     m_IFXFont2FileRead.RemoveKey(pEFont);
   }
   FX_POSITION pos;
-  pos = m_FileAccess2IFXFont.GetStartPosition();
-  while (pos) {
-    uint32_t dwHash;
-    CFGAS_GEFont* pCFont;
-    m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pCFont);
-    if (pCFont == pEFont) {
-      m_FileAccess2IFXFont.RemoveKey(dwHash);
-      break;
-    }
-  }
   pos = m_Hash2Fonts.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_ArrayTemplate<CFGAS_GEFont*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
     if (NULL != pFonts) {
       for (int32_t i = 0; i < pFonts->GetSize(); i++) {
         if (pFonts->GetAt(i) == pEFont) {
           pFonts->SetAt(i, NULL);
         }
       }
     } else {
       m_Hash2Fonts.RemoveKey(dwHash);
     }
   }
 }
 
 void CFGAS_FontMgrImp::RegisterFace(FXFT_Face pFace,
                                     CFX_FontDescriptors& Fonts,
-                                    const CFX_WideString* pFaceName,
-                                    IFX_FileAccess* pFontAccess) {
+                                    const CFX_WideString* pFaceName) {
   if ((pFace->face_flags & FT_FACE_FLAG_SCALABLE) == 0)
     return;
 
   CFX_FontDescriptor* pFont = new CFX_FontDescriptor;
   pFont->m_dwFontStyles |= FXFT_Is_Face_Bold(pFace) ? FX_FONTSTYLE_Bold : 0;
   pFont->m_dwFontStyles |= FXFT_Is_Face_Italic(pFace) ? FX_FONTSTYLE_Italic : 0;
   pFont->m_dwFontStyles |= GetFlags(pFace);
 
   CFX_ArrayTemplate<uint16_t> Charsets;
   GetCharsets(pFace, Charsets);
@@ skipping 15 matching lines @@
   }
   GetNames(pTable, pFont->m_wsFamilyNames);
   if (pTable)
     FX_Free(pTable);
 
   pFont->m_wsFamilyNames.Add(CFX_ByteString(pFace->family_name).UTF8Decode());
   pFont->m_wsFaceName =
       pFaceName ? *pFaceName
                 : CFX_WideString::FromLocal(FXFT_Get_Postscript_Name(pFace));
   pFont->m_nFaceIndex = pFace->face_index;
-  pFont->m_pFileAccess = pFontAccess ? pFontAccess->Retain() : nullptr;
 
   Fonts.Add(pFont);
 }
 
 void CFGAS_FontMgrImp::RegisterFaces(IFX_FileRead* pFontStream,
                                      const CFX_WideString* pFaceName) {
   int32_t index = 0;
   int32_t num_faces = 0;
   do {
     FXFT_Face pFace = LoadFace(pFontStream, index++);
     if (!pFace)
       continue;
     // All faces keep number of faces. It can be retrieved from any one face.
     if (num_faces == 0)
       num_faces = pFace->num_faces;
-    RegisterFace(pFace, m_InstalledFonts, pFaceName, nullptr);
+    RegisterFace(pFace, m_InstalledFonts, pFaceName);
     if (FXFT_Get_Face_External_Stream(pFace))
       FXFT_Clear_Face_External_Stream(pFace);
     FXFT_Done_Face(pFace);
   } while (index < num_faces);
 }
 uint32_t CFGAS_FontMgrImp::GetFlags(FXFT_Face pFace) {
   uint32_t flag = 0;
   if (FT_IS_FIXED_WIDTH(pFace)) {
     flag |= FX_FONTSTYLE_FixedPitch;
   }
@@ skipping 160 matching lines @@
   }
 }
 int32_t CFGAS_FontMgrImp::IsPartName(const CFX_WideString& Name1,
                                      const CFX_WideString& Name2) {
   if (Name1.Find(Name2.c_str()) != -1) {
     return 1;
   }
   return 0;
 }
 #endif