Remove IFX_AdditionalFontMgr and IFX_FontMgrDelegate.

xfa/fgas/font/fgas_stdfontmgr.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/fgas/font/fgas_stdfontmgr.h"
 
 #include "core/fxcrt/include/fx_stream.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/font/fgas_fontutils.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-IFX_FontMgr* IFX_FontMgr::Create(FX_LPEnumAllFonts pEnumerator,
-                                 FX_LPMatchFont pMatcher,
-                                 void* pUserData) {
-  return new CFX_StdFontMgrImp(pEnumerator, pMatcher, pUserData);
+IFX_FontMgr* IFX_FontMgr::Create(FX_LPEnumAllFonts pEnumerator) {
+  return new CFX_StdFontMgrImp(pEnumerator);
 }
-CFX_StdFontMgrImp::CFX_StdFontMgrImp(FX_LPEnumAllFonts pEnumerator,
-                                     FX_LPMatchFont pMatcher,
-                                     void* pUserData)
-    : m_pMatcher(pMatcher),
-      m_pEnumerator(pEnumerator),
+CFX_StdFontMgrImp::CFX_StdFontMgrImp(FX_LPEnumAllFonts pEnumerator)
+    : m_pEnumerator(pEnumerator),
       m_FontFaces(),
       m_Fonts(),
       m_CPFonts(8),
       m_FamilyFonts(16),
       m_UnicodeFonts(16),
       m_BufferFonts(4),
       m_FileFonts(4),
       m_StreamFonts(4),
-      m_DeriveFonts(4),
-      m_pUserData(pUserData) {
+      m_DeriveFonts(4) {
   if (m_pEnumerator != NULL) {
-    m_pEnumerator(m_FontFaces, m_pUserData, NULL, 0xFEFF);
+    m_pEnumerator(m_FontFaces, NULL, 0xFEFF);
   }
-  if (m_pMatcher == NULL) {
-    m_pMatcher = FX_DefFontMatcher;
-  }
-  FXSYS_assert(m_pMatcher != NULL);
 }
+
 CFX_StdFontMgrImp::~CFX_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--) {
     IFX_Font* pFont = (IFX_Font*)m_Fonts[i];
     if (pFont != NULL) {
       pFont->Release();
     }
   }
   m_Fonts.RemoveAll();
 }
 IFX_Font* CFX_StdFontMgrImp::GetDefFontByCodePage(
     uint16_t wCodePage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   uint32_t dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
   IFX_Font* pFont = NULL;
   if (m_CPFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
   }
-  FX_LPCFONTDESCRIPTOR pFD;
+  FX_FONTDESCRIPTOR const* pFD;
   if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {
     if ((pFD = FindFont(NULL, dwFontStyles, TRUE, wCodePage)) == NULL) {
       if ((pFD = FindFont(NULL, dwFontStyles, FALSE, wCodePage)) == NULL)
         return NULL;
     }
   }
   FXSYS_assert(pFD != NULL);
   pFont = IFX_Font::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
   if (pFont != NULL) {
     m_Fonts.Add(pFont);
@@ skipping 19 matching lines @@
   const FGAS_FONTUSB* pRet = FGAS_GetUnicodeBitField(wUnicode);
   if (pRet->wBitField == 999)
     return nullptr;
 
   uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, pRet->wBitField);
   IFX_Font* pFont = nullptr;
   if (m_UnicodeFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont))
     return pFont ? LoadFont(pFont, dwFontStyles, pRet->wCodePage) : nullptr;
 
-  FX_LPCFONTDESCRIPTOR pFD =
+  FX_FONTDESCRIPTOR const* pFD =
       FindFont(pszFontFamily, dwFontStyles, FALSE, pRet->wCodePage,
                pRet->wBitField, wUnicode);
   if (!pFD && pszFontFamily) {
     pFD = FindFont(nullptr, dwFontStyles, FALSE, pRet->wCodePage,
                    pRet->wBitField, wUnicode);
   }
   if (!pFD)
     return nullptr;
 
   uint16_t wCodePage = FX_GetCodePageFromCharset(pFD->uCharSet);
@@ skipping 20 matching lines @@
 }
 IFX_Font* CFX_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFontFamily,
                                       uint32_t dwFontStyles,
                                       uint16_t wCodePage) {
   uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, wCodePage);
   IFX_Font* pFont = NULL;
   if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
   }
-  FX_LPCFONTDESCRIPTOR pFD = NULL;
+  FX_FONTDESCRIPTOR const* pFD = NULL;
   if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {
     if ((pFD = FindFont(pszFontFamily, dwFontStyles, FALSE, wCodePage)) ==
         NULL) {
       return NULL;
     }
   }
   FXSYS_assert(pFD != NULL);
   if (wCodePage == 0xFFFF) {
     wCodePage = FX_GetCodePageFromCharset(pFD->uCharSet);
   }
@@ skipping 129 matching lines @@
   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_LPCFONTDESCRIPTOR CFX_StdFontMgrImp::FindFont(const FX_WCHAR* pszFontFamily,
-                                                 uint32_t dwFontStyles,
-                                                 uint32_t dwMatchFlags,
-                                                 uint16_t wCodePage,
-                                                 uint32_t dwUSB,
-                                                 FX_WCHAR wUnicode) {
-  if (m_pMatcher == NULL) {
-    return NULL;
-  }
+FX_FONTDESCRIPTOR const* CFX_StdFontMgrImp::FindFont(
+    const FX_WCHAR* pszFontFamily,
+    uint32_t dwFontStyles,
+    uint32_t dwMatchFlags,
+    uint16_t wCodePage,
+    uint32_t dwUSB,
+    FX_WCHAR wUnicode) {
   FX_FONTMATCHPARAMS params;
   FXSYS_memset(&params, 0, sizeof(params));
   params.dwUSB = dwUSB;
   params.wUnicode = wUnicode;
   params.wCodePage = wCodePage;
   params.pwsFamily = pszFontFamily;
   params.dwFontStyles = dwFontStyles;
   params.dwMatchFlags = dwMatchFlags;
-  FX_LPCFONTDESCRIPTOR pDesc = m_pMatcher(&params, m_FontFaces, m_pUserData);
+  FX_FONTDESCRIPTOR const* pDesc = FX_DefFontMatcher(&params, m_FontFaces);
   if (pDesc) {
     return pDesc;
   }
   if (pszFontFamily && m_pEnumerator) {
     CFX_FontDescriptors namedFonts;
-    m_pEnumerator(namedFonts, m_pUserData, pszFontFamily, wUnicode);
+    m_pEnumerator(namedFonts, pszFontFamily, wUnicode);
     params.pwsFamily = NULL;
-    pDesc = m_pMatcher(&params, namedFonts, m_pUserData);
+    pDesc = FX_DefFontMatcher(&params, namedFonts);
     if (pDesc == NULL) {
       return NULL;
     }
     for (int32_t i = m_FontFaces.GetSize() - 1; i >= 0; i--) {
-      FX_LPCFONTDESCRIPTOR pMatch = m_FontFaces.GetPtrAt(i);
+      FX_FONTDESCRIPTOR const* pMatch = m_FontFaces.GetPtrAt(i);
       if (*pMatch == *pDesc) {
         return pMatch;
       }
     }
     int index = m_FontFaces.Add(*pDesc);
     return m_FontFaces.GetPtrAt(index);
   }
   return NULL;
 }
-FX_LPCFONTDESCRIPTOR FX_DefFontMatcher(FX_LPFONTMATCHPARAMS pParams,
-                                       const CFX_FontDescriptors& fonts,
-                                       void* pUserData) {
-  FX_LPCFONTDESCRIPTOR pBestFont = NULL;
+FX_FONTDESCRIPTOR const* FX_DefFontMatcher(FX_LPFONTMATCHPARAMS pParams,
+                                           const CFX_FontDescriptors& fonts) {
+  FX_FONTDESCRIPTOR const* pBestFont = NULL;
   int32_t iBestSimilar = 0;
   FX_BOOL bMatchStyle =
       (pParams->dwMatchFlags & FX_FONTMATCHPARA_MacthStyle) > 0;
   int32_t iCount = fonts.GetSize();
   for (int32_t i = 0; i < iCount; ++i) {
-    FX_LPCFONTDESCRIPTOR pFont = fonts.GetPtrAt(i);
+    FX_FONTDESCRIPTOR const* pFont = fonts.GetPtrAt(i);
     if ((pFont->dwFontStyles & FX_FONTSTYLE_BoldItalic) ==
         FX_FONTSTYLE_BoldItalic) {
       continue;
     }
     if (pParams->pwsFamily) {
       if (FXSYS_wcsicmp(pParams->pwsFamily, pFont->wsFontFace)) {
         continue;
       }
       if (pFont->uCharSet == FX_CHARSET_Symbol) {
         return pFont;
@@ skipping 28 matching lines @@
       }
     }
     int32_t iSimilarValue = FX_GetSimilarValue(pFont, pParams->dwFontStyles);
     if (iBestSimilar < iSimilarValue) {
       iBestSimilar = iSimilarValue;
       pBestFont = pFont;
     }
   }
   return iBestSimilar < 1 ? NULL : pBestFont;
 }
-int32_t FX_GetSimilarValue(FX_LPCFONTDESCRIPTOR pFont, uint32_t dwFontStyles) {
+int32_t FX_GetSimilarValue(FX_FONTDESCRIPTOR const* pFont,
+                           uint32_t dwFontStyles) {
   int32_t iValue = 0;
   if ((dwFontStyles & FX_FONTSTYLE_Symbolic) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_Symbolic)) {
     iValue += 64;
   }
   if ((dwFontStyles & FX_FONTSTYLE_FixedPitch) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_FixedPitch)) {
     iValue += 32;
   }
   if ((dwFontStyles & FX_FONTSTYLE_Serif) ==
@@ skipping 30 matching lines @@
                                            NEWTEXTMETRICEX* lpntme,
                                            DWORD dwFontType,
                                            LPARAM lParam) {
   if (dwFontType != TRUETYPE_FONTTYPE) {
     return 1;
   }
   const LOGFONTW& lf = ((LPENUMLOGFONTEXW)lpelfe)->elfLogFont;
   if (lf.lfFaceName[0] == L'@') {
     return 1;
   }
-  FX_LPFONTDESCRIPTOR pFont = FX_Alloc(FX_FONTDESCRIPTOR, 1);
+  FX_FONTDESCRIPTOR* pFont = FX_Alloc(FX_FONTDESCRIPTOR, 1);
   FXSYS_memset(pFont, 0, sizeof(FX_FONTDESCRIPTOR));
   pFont->uCharSet = lf.lfCharSet;
   pFont->dwFontStyles = FX_GetGdiFontStyles(lf);
   FXSYS_wcsncpy(pFont->wsFontFace, (const FX_WCHAR*)lf.lfFaceName, 31);
   pFont->wsFontFace[31] = 0;
   FXSYS_memcpy(&pFont->FontSignature, &lpntme->ntmFontSig,
                sizeof(lpntme->ntmFontSig));
   ((CFX_FontDescriptors*)lParam)->Add(*pFont);
   FX_Free(pFont);
   return 1;
 }
 static void FX_EnumGdiFonts(CFX_FontDescriptors& fonts,
-                            void* pUserData,
                             const FX_WCHAR* pwsFaceName,
                             FX_WCHAR wUnicode) {
   HDC hDC = ::GetDC(NULL);
   LOGFONTW lfFind;
   FXSYS_memset(&lfFind, 0, sizeof(lfFind));
   lfFind.lfCharSet = DEFAULT_CHARSET;
   if (pwsFaceName) {
     FXSYS_wcsncpy((FX_WCHAR*)lfFind.lfFaceName, pwsFaceName, 31);
     lfFind.lfFaceName[31] = 0;
   }
@@ skipping 73 matching lines @@
       pCurHandle = hpp.pFileHandle;
       continue;
     }
     bsName =
         m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->bsParentPath +
         bsFolderSpearator + bsName;
     break;
   }
   return bsName;
 }
-FX_POSITION CFX_FontSourceEnum_File::GetStartPosition(void* pUserData) {
+FX_POSITION CFX_FontSourceEnum_File::GetStartPosition() {
   m_wsNext = GetNextFile().UTF8Decode();
   if (0 == m_wsNext.GetLength()) {
     return (FX_POSITION)0;
   }
   return (FX_POSITION)-1;
 }
-IFX_FileAccess* CFX_FontSourceEnum_File::GetNext(FX_POSITION& pos,
-                                                 void* pUserData) {
+
+IFX_FileAccess* CFX_FontSourceEnum_File::GetNext(FX_POSITION& pos) {
   IFX_FileAccess* pAccess = FX_CreateDefaultFileAccess(m_wsNext.AsStringC());
   m_wsNext = GetNextFile().UTF8Decode();
   pos = 0 != m_wsNext.GetLength() ? pAccess : NULL;
   return (IFX_FileAccess*)pAccess;
 }
 IFX_FontSourceEnum* FX_CreateDefaultFontSourceEnum() {
   return (IFX_FontSourceEnum*)new CFX_FontSourceEnum_File;
 }
-IFX_FontMgr* IFX_FontMgr::Create(IFX_FontSourceEnum* pFontEnum,
-                                 IFX_FontMgrDelegate* pDelegate,
-                                 void* pUserData) {
+IFX_FontMgr* IFX_FontMgr::Create(IFX_FontSourceEnum* pFontEnum) {
   if (NULL == pFontEnum) {
     return NULL;
   }
-  CFX_FontMgrImp* pFontMgr =
-      new CFX_FontMgrImp(pFontEnum, pDelegate, pUserData);
+  CFX_FontMgrImp* pFontMgr = new CFX_FontMgrImp(pFontEnum);
   if (pFontMgr->EnumFonts()) {
     return pFontMgr;
   }
   delete pFontMgr;
   return NULL;
 }
-CFX_FontMgrImp::CFX_FontMgrImp(IFX_FontSourceEnum* pFontEnum,
-                               IFX_FontMgrDelegate* pDelegate,
-                               void* pUserData)
-    : m_pFontSource(pFontEnum),
-      m_pDelegate(pDelegate),
-      m_pUserData(pUserData) {}
+CFX_FontMgrImp::CFX_FontMgrImp(IFX_FontSourceEnum* pFontEnum)
+    : m_pFontSource(pFontEnum) {}
 
 FX_BOOL CFX_FontMgrImp::EnumFontsFromFontMapper() {
   CFX_FontMapper* pFontMapper =
       CFX_GEModule::Get()->GetFontMgr()->GetBuiltinMapper();
   if (!pFontMapper)
     return FALSE;
   IFX_SystemFontInfo* pSystemFontInfo = pFontMapper->GetSystemFontInfo();
   if (!pSystemFontInfo)
     return FALSE;
   pSystemFontInfo->EnumFontList(pFontMapper);
@@ skipping 82 matching lines @@
     IFX_Font* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
   delete this;
 }
 IFX_Font* CFX_FontMgrImp::GetDefFontByCodePage(uint16_t wCodePage,
                                                uint32_t dwFontStyles,
                                                const FX_WCHAR* pszFontFamily) {
-  return NULL == m_pDelegate ? NULL : m_pDelegate->GetDefFontByCodePage(
-                                          this, wCodePage, dwFontStyles,
-                                          pszFontFamily);
+  return nullptr;
 }
 IFX_Font* CFX_FontMgrImp::GetDefFontByCharset(uint8_t nCharset,
                                               uint32_t dwFontStyles,
                                               const FX_WCHAR* pszFontFamily) {
-  return NULL == m_pDelegate ? NULL
-                             : m_pDelegate->GetDefFontByCharset(
-                                   this, nCharset, dwFontStyles, pszFontFamily);
+  return nullptr;
 }
 IFX_Font* CFX_FontMgrImp::GetDefFontByUnicode(FX_WCHAR wUnicode,
                                               uint32_t dwFontStyles,
                                               const FX_WCHAR* pszFontFamily) {
-  return NULL == m_pDelegate ? NULL
-                             : m_pDelegate->GetDefFontByUnicode(
-                                   this, wUnicode, dwFontStyles, pszFontFamily);
+  return nullptr;
 }
 IFX_Font* CFX_FontMgrImp::GetDefFontByLanguage(uint16_t wLanguage,
                                                uint32_t dwFontStyles,
                                                const FX_WCHAR* pszFontFamily) {
-  return NULL == m_pDelegate ? NULL : m_pDelegate->GetDefFontByLanguage(
-                                          this, wLanguage, dwFontStyles,
-                                          pszFontFamily);
+  return nullptr;
 }
 IFX_Font* CFX_FontMgrImp::GetFontByCodePage(uint16_t wCodePage,
                                             uint32_t dwFontStyles,
                                             const FX_WCHAR* pszFontFamily) {
   CFX_ByteString bsHash;
   bsHash.Format("%d, %d", wCodePage, dwFontStyles);
   bsHash += CFX_WideString(pszFontFamily).UTF8Encode();
   uint32_t dwHash = FX_HashCode_String_GetA(bsHash, bsHash.GetLength());
   CFX_ArrayTemplate<IFX_Font*>* pFonts = NULL;
   IFX_Font* pFont = NULL;
@@ skipping 779 matching lines @@
   }
 }
 int32_t CFX_FontMgrImp::IsPartName(const CFX_WideString& Name1,
                                    const CFX_WideString& Name2) {
   if (Name1.Find((const FX_WCHAR*)Name2) != -1) {
     return 1;
   }
   return 0;
 }
 #endif