Tidy cfgas_fontmgr, remove custom sorting code.

xfa/fgas/font/cfgas_fontmgr.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/cfgas_fontmgr.h"
 
+#include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "core/fxcrt/fx_stream.h"
 #include "core/fxge/cfx_fontmapper.h"
 #include "core/fxge/cfx_fontmgr.h"
 #include "core/fxge/cfx_gemodule.h"
 #include "core/fxge/ifx_systemfontinfo.h"
 #include "third_party/base/ptr_util.h"
 #include "third_party/base/stl_util.h"
@@ skipping 546 matching lines @@
 
   auto pFontMgr = pdfium::MakeUnique<CFGAS_FontMgr>(pFontEnum);
   if (!pFontMgr->EnumFonts())
     return nullptr;
   return pFontMgr;
 }
 
 CFGAS_FontMgr::CFGAS_FontMgr(CFX_FontSourceEnum_File* pFontEnum)
     : m_pFontSource(pFontEnum) {}
 
-CFGAS_FontMgr::~CFGAS_FontMgr() {
-  for (int32_t i = 0; i < m_InstalledFonts.GetSize(); i++)
-    delete m_InstalledFonts[i];
-}
+CFGAS_FontMgr::~CFGAS_FontMgr() {}
 
 bool CFGAS_FontMgr::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);
   for (int32_t i = 0; i < pFontMapper->GetFaceSize(); ++i) {
     CFX_RetainPtr<IFX_SeekableReadStream> pFontStream =
         CreateFontStream(pFontMapper, pSystemFontInfo, i);
     if (!pFontStream)
       continue;
 
     CFX_WideString wsFaceName =
         CFX_WideString::FromLocal(pFontMapper->GetFaceName(i).c_str());
     RegisterFaces(pFontStream, &wsFaceName);
   }
-  return m_InstalledFonts.GetSize() != 0;
+  return !m_InstalledFonts.empty();
 }
 
 bool CFGAS_FontMgr::EnumFontsFromFiles() {
   CFX_GEModule::Get()->GetFontMgr()->InitFTLibrary();
   FX_POSITION pos = m_pFontSource->GetStartPosition();
   while (pos) {
     CFX_RetainPtr<IFX_FileAccess> pFontSource = m_pFontSource->GetNext(pos);
     CFX_RetainPtr<IFX_SeekableReadStream> pFontStream =
         pFontSource->CreateFileStream(FX_FILEMODE_ReadOnly);
     if (pFontStream)
       RegisterFaces(pFontStream, nullptr);
   }
-  return m_InstalledFonts.GetSize() != 0;
+  return !m_InstalledFonts.empty();
 }
 
 bool CFGAS_FontMgr::EnumFonts() {
   return EnumFontsFromFontMapper() || EnumFontsFromFiles();
 }
 
 CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::LoadFont(
     const FX_WCHAR* pszFontFamily,
     uint32_t dwFontStyles,
     uint16_t wCodePage) {
   return GetFontByCodePage(wCodePage, dwFontStyles, pszFontFamily);
 }
 
 CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::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_GetA(bsHash.AsStringC(), false);
   std::vector<CFX_RetainPtr<CFGAS_GEFont>>* pFontArray = &m_Hash2Fonts[dwHash];
   if (!pFontArray->empty())
     return (*pFontArray)[0];
 
-  CFX_FontDescriptorInfos* sortedFonts = m_Hash2CandidateList[dwHash].get();
-  if (!sortedFonts) {
-    auto pNewFonts = pdfium::MakeUnique<CFX_FontDescriptorInfos>();
-    sortedFonts = pNewFonts.get();
-    MatchFonts(*sortedFonts, wCodePage, dwFontStyles,
+  std::vector<CFX_FontDescriptorInfo>* sortedFontInfos =
+      m_Hash2CandidateList[dwHash].get();
+  if (!sortedFontInfos) {
+    auto pNewFonts = pdfium::MakeUnique<std::vector<CFX_FontDescriptorInfo>>();
+    sortedFontInfos = pNewFonts.get();
+    MatchFonts(sortedFontInfos, wCodePage, dwFontStyles,
                CFX_WideString(pszFontFamily), 0);
     m_Hash2CandidateList[dwHash] = std::move(pNewFonts);
   }
-  if (sortedFonts->GetSize() == 0)
+  if (sortedFontInfos->empty())
     return nullptr;
 
-  CFX_FontDescriptor* pDesc = sortedFonts->GetAt(0).pFont;
+  CFX_FontDescriptor* pDesc = (*sortedFontInfos)[0].pFont;
   CFX_RetainPtr<CFGAS_GEFont> pFont =
       LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
   if (!pFont)
     return nullptr;
 
   pFont->SetLogicalFontStyle(dwFontStyles);
   pFontArray->push_back(pFont);
   return pFont;
 }
 
@@ skipping 12 matching lines @@
     bsHash.Format("%d, %d, %d", wCodePage, wBitField, dwFontStyles);
   else
     bsHash.Format("%d, %d", wCodePage, dwFontStyles);
   bsHash += CFX_WideString(pszFontFamily).UTF8Encode();
   uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false);
   std::vector<CFX_RetainPtr<CFGAS_GEFont>>* pFonts = &m_Hash2Fonts[dwHash];
   for (size_t i = 0; i < pFonts->size(); ++i) {
     if (VerifyUnicode((*pFonts)[i], wUnicode))
       return (*pFonts)[i];
   }
-  CFX_FontDescriptorInfos* sortedFonts = m_Hash2CandidateList[dwHash].get();
-  if (!sortedFonts) {
-    auto pNewFonts = pdfium::MakeUnique<CFX_FontDescriptorInfos>();
-    sortedFonts = pNewFonts.get();
-    MatchFonts(*sortedFonts, wCodePage, dwFontStyles,
+  std::vector<CFX_FontDescriptorInfo>* sortedFontInfos =
+      m_Hash2CandidateList[dwHash].get();
+  if (!sortedFontInfos) {
+    auto pNewFonts = pdfium::MakeUnique<std::vector<CFX_FontDescriptorInfo>>();
+    sortedFontInfos = pNewFonts.get();
+    MatchFonts(sortedFontInfos, wCodePage, dwFontStyles,
                CFX_WideString(pszFontFamily), wUnicode);
     m_Hash2CandidateList[dwHash] = std::move(pNewFonts);
   }
-  for (int32_t i = 0; i < sortedFonts->GetSize(); ++i) {
-    CFX_FontDescriptor* pDesc = sortedFonts->GetAt(i).pFont;
+  for (const auto& info : *sortedFontInfos) {
+    CFX_FontDescriptor* pDesc = info.pFont;
     if (!VerifyUnicode(pDesc, wUnicode))
       continue;
     CFX_RetainPtr<CFGAS_GEFont> pFont =
         LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
     if (!pFont)
       continue;
     pFont->SetLogicalFontStyle(dwFontStyles);
     pFonts->push_back(pFont);
     return pFont;
   }
@@ skipping 163 matching lines @@
     return nullptr;
 
   pSystemFontInfo->EnumFontList(pFontMapper);
   for (int32_t i = 0; i < pFontMapper->GetFaceSize(); ++i) {
     if (pFontMapper->GetFaceName(i) == bsFaceName)
       return CreateFontStream(pFontMapper, pSystemFontInfo, i);
   }
   return nullptr;
 }
 
-int32_t CFGAS_FontMgr::MatchFonts(CFX_FontDescriptorInfos& MatchedFonts,
-                                  uint16_t wCodePage,
-                                  uint32_t dwFontStyles,
-                                  const CFX_WideString& FontName,
-                                  FX_WCHAR wcUnicode) {
-  MatchedFonts.RemoveAll();
-  CFX_WideString wsNormalizedFontName = FontName;
-
-  CFX_FontDescriptor* pFont = nullptr;
-  int32_t nCount = m_InstalledFonts.GetSize();
-  for (int32_t i = 0; i < nCount; i++) {
-    pFont = m_InstalledFonts[i];
-    int32_t nPenalty = CalcPenalty(pFont, wCodePage, dwFontStyles,
-                                   wsNormalizedFontName, wcUnicode);
+void CFGAS_FontMgr::MatchFonts(
+    std::vector<CFX_FontDescriptorInfo>* pMatchedFonts,
+    uint16_t wCodePage,
+    uint32_t dwFontStyles,
+    const CFX_WideString& FontName,
+    FX_WCHAR wcUnicode) {
+  pMatchedFonts->clear();
+  for (const auto& pFont : m_InstalledFonts) {
+    int32_t nPenalty =
+        CalcPenalty(pFont.get(), wCodePage, dwFontStyles, FontName, wcUnicode);
     if (nPenalty >= 0xffff)
       continue;
-
-    FX_FontDescriptorInfo FontInfo;
-    FontInfo.pFont = pFont;
-    FontInfo.nPenalty = nPenalty;
-    MatchedFonts.Add(FontInfo);
-    if (MatchedFonts.GetSize() == 0xffff)
+    pMatchedFonts->push_back({pFont.get(), nPenalty});
+    if (pMatchedFonts->size() == 0xffff)
       break;
   }
-  if (MatchedFonts.GetSize() == 0)
-    return 0;
-
-  CFX_SSortTemplate<FX_FontDescriptorInfo> ssort;
-  ssort.ShellSort(MatchedFonts.GetData(), MatchedFonts.GetSize());
-  return MatchedFonts.GetSize();
+  std::sort(pMatchedFonts->begin(), pMatchedFonts->end());
 }
 
 int32_t CFGAS_FontMgr::CalcPenalty(CFX_FontDescriptor* pInstalled,
                                    uint16_t wCodePage,
                                    uint32_t dwFontStyles,
                                    const CFX_WideString& FontName,
                                    FX_WCHAR wcUnicode) {
   int32_t nPenalty = 30000;
   if (FontName.GetLength() != 0) {
     if (FontName != pInstalled->m_wsFaceName) {
@@ skipping 79 matching lines @@
     if (all_empty)
       m_Hash2Fonts.erase(old_iter);
   }
 }
 
 void CFGAS_FontMgr::RegisterFace(FXFT_Face pFace,
                                  const CFX_WideString* pFaceName) {
   if ((pFace->face_flags & FT_FACE_FLAG_SCALABLE) == 0)
     return;
 
-  std::unique_ptr<CFX_FontDescriptor> pFont(new CFX_FontDescriptor);
+  auto pFont = pdfium::MakeUnique<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);
 
   std::vector<uint16_t> charsets = GetCharsets(pFace);
   GetUSBCSB(pFace, pFont->m_dwUsb, pFont->m_dwCsb);
 
   FT_ULong dwTag;
   FT_ENC_TAG(dwTag, 'n', 'a', 'm', 'e');
 
   std::vector<uint8_t> table;
   unsigned long nLength = 0;
   unsigned int error = FXFT_Load_Sfnt_Table(pFace, dwTag, 0, nullptr, &nLength);
   if (error == 0 && nLength != 0) {
     table.resize(nLength);
     if (FXFT_Load_Sfnt_Table(pFace, dwTag, 0, table.data(), nullptr))
       table.clear();
   }
   GetNames(table.empty() ? nullptr : table.data(), pFont->m_wsFamilyNames);
   pFont->m_wsFamilyNames.push_back(
       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;
-  m_InstalledFonts.Add(pFont.release());
+  m_InstalledFonts.push_back(std::move(pFont));
 }
 
 void CFGAS_FontMgr::RegisterFaces(
     const CFX_RetainPtr<IFX_SeekableReadStream>& pFontStream,
     const CFX_WideString* pFaceName) {
   int32_t index = 0;
   int32_t num_faces = 0;
   do {
     FXFT_Face pFace = LoadFace(pFontStream, index++);
     if (!pFace)
@@ skipping 101 matching lines @@
 }
 
 int32_t CFGAS_FontMgr::IsPartName(const CFX_WideString& Name1,
                                   const CFX_WideString& Name2) {
   if (Name1.Find(Name2.c_str()) != -1)
     return 1;
   return 0;
 }
 
 #endif  // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_