Clean up CFGAS_FontMgr

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 "core/fxcrt/fx_stream.h"
 #include "core/fxge/cfx_fontmapper.h"
@@ skipping 104 matching lines @@
   m_CPFonts.RemoveAll();
   m_FamilyFonts.RemoveAll();
   m_UnicodeFonts.RemoveAll();
   m_BufferFonts.RemoveAll();
   m_StreamFonts.RemoveAll();
   m_DeriveFonts.RemoveAll();
   for (int32_t i = m_Fonts.GetUpperBound(); i >= 0; i--)
     m_Fonts[i]->Release();
 }
 
-CFGAS_GEFont* CFGAS_FontMgr::GetDefFontByCodePage(
-    uint16_t wCodePage,
-    uint32_t dwFontStyles,
-    const FX_WCHAR* pszFontFamily) {
+CFGAS_GEFont* CFGAS_FontMgr::GetFontByCodePage(uint16_t wCodePage,
+                                               uint32_t dwFontStyles,
+                                               const FX_WCHAR* pszFontFamily) {
   uint32_t dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
   CFGAS_GEFont* pFont = nullptr;
   if (m_CPFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont))
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : nullptr;
   FX_FONTDESCRIPTOR const* pFD =
       FindFont(pszFontFamily, dwFontStyles, true, wCodePage);
   if (!pFD)
     pFD = FindFont(nullptr, dwFontStyles, true, wCodePage);
   if (!pFD)
     pFD = FindFont(nullptr, dwFontStyles, false, wCodePage);
   if (!pFD)
     return nullptr;
 
   pFont =
       CFGAS_GEFont::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
-  if (pFont) {
-    m_Fonts.Add(pFont);
-    m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    dwHash = FGAS_GetFontFamilyHash(pFD->wsFontFace, dwFontStyles, wCodePage);
-    m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    return LoadFont(pFont, dwFontStyles, wCodePage);
-  }
-  return nullptr;
+  if (!pFont)
+    return nullptr;
+
+  m_Fonts.Add(pFont);
+  m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+  dwHash = FGAS_GetFontFamilyHash(pFD->wsFontFace, dwFontStyles, wCodePage);
+  m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+  return LoadFont(pFont, dwFontStyles, wCodePage);
 }
 
-CFGAS_GEFont* CFGAS_FontMgr::GetDefFontByUnicode(
-    FX_WCHAR wUnicode,
-    uint32_t dwFontStyles,
-    const FX_WCHAR* pszFontFamily) {
+CFGAS_GEFont* CFGAS_FontMgr::GetFontByUnicode(FX_WCHAR wUnicode,
+                                              uint32_t dwFontStyles,
+                                              const FX_WCHAR* pszFontFamily) {
   const FGAS_FONTUSB* pRet = FGAS_GetUnicodeBitField(wUnicode);
   if (pRet->wBitField == 999)
     return nullptr;
 
   uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, pRet->wBitField);
   CFGAS_GEFont* pFont = nullptr;
   if (m_UnicodeFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont))
     return pFont ? LoadFont(pFont, dwFontStyles, pRet->wCodePage) : nullptr;
 
   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);
   const FX_WCHAR* pFontFace = pFD->wsFontFace;
   pFont = CFGAS_GEFont::LoadFont(pFontFace, dwFontStyles, wCodePage, this);
-  if (pFont) {
-    m_Fonts.Add(pFont);
-    m_UnicodeFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
-    m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    dwHash = FGAS_GetFontFamilyHash(pFontFace, dwFontStyles, wCodePage);
-    m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    return LoadFont(pFont, dwFontStyles, wCodePage);
-  }
-  return nullptr;
+  if (!pFont)
+    return nullptr;
+
+  m_Fonts.Add(pFont);
+  m_UnicodeFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+  dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
+  m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+  dwHash = FGAS_GetFontFamilyHash(pFontFace, dwFontStyles, wCodePage);
+  m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+  return LoadFont(pFont, dwFontStyles, wCodePage);
 }
 
 CFGAS_GEFont* CFGAS_FontMgr::LoadFont(const FX_WCHAR* pszFontFamily,
                                       uint32_t dwFontStyles,
                                       uint16_t wCodePage) {
   uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, wCodePage);
   CFGAS_GEFont* pFont = nullptr;
   if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont))
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : nullptr;
   FX_FONTDESCRIPTOR const* pFD =
       FindFont(pszFontFamily, dwFontStyles, true, wCodePage);
   if (!pFD)
     pFD = FindFont(pszFontFamily, dwFontStyles, false, wCodePage);
   if (!pFD)
     return nullptr;
 
   if (wCodePage == 0xFFFF)
     wCodePage = FX_GetCodePageFromCharset(pFD->uCharSet);
   pFont =
       CFGAS_GEFont::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
-  if (pFont) {
-    m_Fonts.Add(pFont);
-    m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
-    m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    return LoadFont(pFont, dwFontStyles, wCodePage);
-  }
-  return nullptr;
-}
+  if (!pFont)
+    return nullptr;
 
-CFGAS_GEFont* CFGAS_FontMgr::LoadFont(const uint8_t* pBuffer, int32_t iLength) {
-  ASSERT(pBuffer && iLength > 0);
-  CFGAS_GEFont* pFont = nullptr;
-  if (m_BufferFonts.Lookup((void*)pBuffer, (void*&)pFont)) {
-    if (pFont)
-      return pFont->Retain();
-  }
-  pFont = CFGAS_GEFont::LoadFont(pBuffer, iLength, this);
-  if (pFont) {
-    m_Fonts.Add(pFont);
-    m_BufferFonts.SetAt((void*)pBuffer, pFont);
-    return pFont->Retain();
-  }
-  return nullptr;
-}
-
-CFGAS_GEFont* CFGAS_FontMgr::LoadFont(IFX_Stream* pFontStream,
-                                      const FX_WCHAR* pszFontAlias,
-                                      uint32_t dwFontStyles,
-                                      uint16_t wCodePage,
-                                      bool bSaveStream) {
-  ASSERT(pFontStream && pFontStream->GetLength() > 0);
-  CFGAS_GEFont* pFont = nullptr;
-  if (m_StreamFonts.Lookup((void*)pFontStream, (void*&)pFont)) {
-    if (pFont) {
-      if (pszFontAlias) {
-        uint32_t dwHash =
-            FGAS_GetFontFamilyHash(pszFontAlias, dwFontStyles, wCodePage);
-        m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-      }
-      return LoadFont(pFont, dwFontStyles, wCodePage);
-    }
-  }
-  pFont = CFGAS_GEFont::LoadFont(pFontStream, this, bSaveStream);
-  if (pFont) {
-    m_Fonts.Add(pFont);
-    m_StreamFonts.SetAt((void*)pFontStream, (void*)pFont);
-    if (pszFontAlias) {
-      uint32_t dwHash =
-          FGAS_GetFontFamilyHash(pszFontAlias, dwFontStyles, wCodePage);
-      m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    }
-    return LoadFont(pFont, dwFontStyles, wCodePage);
-  }
-  return nullptr;
+  m_Fonts.Add(pFont);
+  m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+  dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
+  m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+  return LoadFont(pFont, dwFontStyles, wCodePage);
 }
 
 CFGAS_GEFont* CFGAS_FontMgr::LoadFont(CFGAS_GEFont* pSrcFont,
                                       uint32_t dwFontStyles,
                                       uint16_t wCodePage) {
   ASSERT(pSrcFont);
   if (pSrcFont->GetFontStyles() == dwFontStyles)
     return pSrcFont->Retain();
   void* buffer[3] = {pSrcFont, (void*)(uintptr_t)dwFontStyles,
                      (void*)(uintptr_t)wCodePage};
   uint32_t dwHash = FX_HashCode_GetA(
       CFX_ByteStringC((uint8_t*)buffer, sizeof(buffer)), false);
   CFGAS_GEFont* pFont = nullptr;
   if (m_DeriveFonts.GetCount() > 0) {
     m_DeriveFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont);
     if (pFont)
       return pFont->Retain();
   }
   pFont = pSrcFont->Derive(dwFontStyles, wCodePage);
-  if (pFont) {
-    m_DeriveFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
-    int32_t index = m_Fonts.Find(pFont);
-    if (index < 0) {
-      m_Fonts.Add(pFont);
-      pFont->Retain();
-    }
-    return pFont;
+  if (!pFont)
+    return nullptr;
+
+  m_DeriveFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+  int32_t index = m_Fonts.Find(pFont);
+  if (index < 0) {
+    m_Fonts.Add(pFont);
+    pFont->Retain();
   }
-  return nullptr;
-}
-
-void CFGAS_FontMgr::ClearFontCache() {
-  for (int32_t i = 0; i < m_Fonts.GetSize(); i++)
-    m_Fonts[i]->Reset();
+  return pFont;
 }
 
 void CFGAS_FontMgr::RemoveFont(CFX_MapPtrToPtr& fontMap, CFGAS_GEFont* pFont) {
   FX_POSITION pos = fontMap.GetStartPosition();
   void* pKey;
   void* pFind;
   while (pos) {
     pFind = nullptr;
     fontMap.GetNextAssoc(pos, pKey, pFind);
     if (pFind != (void*)pFont)
@@ skipping 25 matching lines @@
   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_FONTDESCRIPTOR const* pDesc = MatchDefaultFont(&params, m_FontFaces);
   if (pDesc)
     return pDesc;
-  if (pszFontFamily && m_pEnumerator) {
-    CFX_FontDescriptors namedFonts(100);
-    m_pEnumerator(namedFonts, pszFontFamily, wUnicode);
-    params.pwsFamily = nullptr;
-    pDesc = MatchDefaultFont(&params, namedFonts);
-    if (!pDesc)
-      return nullptr;
-    for (int32_t i = m_FontFaces.GetSize() - 1; i >= 0; 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);
+  if (!pszFontFamily || !m_pEnumerator)
+    return nullptr;
+
+  CFX_FontDescriptors namedFonts(100);
+  m_pEnumerator(namedFonts, pszFontFamily, wUnicode);
+  params.pwsFamily = nullptr;
+  pDesc = MatchDefaultFont(&params, namedFonts);
+  if (!pDesc)
+    return nullptr;
+  for (int32_t i = m_FontFaces.GetSize() - 1; i >= 0; i--) {
+    FX_FONTDESCRIPTOR const* pMatch = m_FontFaces.GetPtrAt(i);
+    if (*pMatch == *pDesc)
+      return pMatch;
   }
-  return nullptr;
+  int index = m_FontFaces.Add(*pDesc);
+  return m_FontFaces.GetPtrAt(index);
 }
 
 uint32_t FX_GetGdiFontStyles(const LOGFONTW& lf) {
   uint32_t dwStyles = 0;
   if ((lf.lfPitchAndFamily & 0x03) == FIXED_PITCH)
     dwStyles |= FX_FONTSTYLE_FixedPitch;
   uint8_t nFamilies = lf.lfPitchAndFamily & 0xF0;
   if (nFamilies == FF_ROMAN)
     dwStyles |= FX_FONTSTYLE_Serif;
   if (nFamilies == FF_SCRIPT)
@@ skipping 77 matching lines @@
     {48, 869}, {49, 866}, {50, 865}, {51, 864},  {52, 863}, {53, 862},
     {54, 861}, {55, 860}, {56, 857}, {57, 855},  {58, 852}, {59, 775},
     {60, 737}, {61, 708}, {62, 850}, {63, 437},
 };
 
 uint16_t FX_GetCodePageBit(uint16_t wCodePage) {
   for (size_t i = 0; i < FX_ArraySize(g_Bit2CodePage); ++i) {
     if (g_Bit2CodePage[i].wCodePage == wCodePage)
       return g_Bit2CodePage[i].wBit;
   }
-  return (uint16_t)-1;
+  return static_cast<uint16_t>(-1);
 }
 
 uint16_t FX_GetUnicodeBit(FX_WCHAR wcUnicode) {
   const FGAS_FONTUSB* x = FGAS_GetUnicodeBitField(wcUnicode);
   return x ? x->wBitField : 999;
 }
 
 inline uint8_t GetUInt8(const uint8_t* p) {
-  return (uint8_t)(p[0]);
+  return p[0];
 }
 
 inline uint16_t GetUInt16(const uint8_t* p) {
-  return (uint16_t)(p[0] << 8 | p[1]);
+  return static_cast<uint16_t>(p[0] << 8 | p[1]);
 }
 
 struct FX_BIT2CHARSET {
   uint16_t wBit;
   uint16_t wCharset;
 };
 
-const FX_BIT2CHARSET g_FX_Bit2Charset1[16] = {
-    {1 << 0, FX_CHARSET_ANSI},
-    {1 << 1, FX_CHARSET_MSWin_EasterEuropean},
-    {1 << 2, FX_CHARSET_MSWin_Cyrillic},
-    {1 << 3, FX_CHARSET_MSWin_Greek},
-    {1 << 4, FX_CHARSET_MSWin_Turkish},
-    {1 << 5, FX_CHARSET_MSWin_Hebrew},
-    {1 << 6, FX_CHARSET_MSWin_Arabic},
-    {1 << 7, FX_CHARSET_MSWin_Baltic},
-    {1 << 8, FX_CHARSET_MSWin_Vietnamese},
-    {1 << 9, FX_CHARSET_Default},
-    {1 << 10, FX_CHARSET_Default},
-    {1 << 11, FX_CHARSET_Default},
-    {1 << 12, FX_CHARSET_Default},
-    {1 << 13, FX_CHARSET_Default},
-    {1 << 14, FX_CHARSET_Default},
-    {1 << 15, FX_CHARSET_Default},
-};
-
-const FX_BIT2CHARSET g_FX_Bit2Charset2[16] = {
-    {1 << 0, FX_CHARSET_Thai},
-    {1 << 1, FX_CHARSET_ShiftJIS},
-    {1 << 2, FX_CHARSET_ChineseSimplified},
-    {1 << 3, FX_CHARSET_Korean},
-    {1 << 4, FX_CHARSET_ChineseTriditional},
-    {1 << 5, FX_CHARSET_Johab},
-    {1 << 6, FX_CHARSET_Default},
-    {1 << 7, FX_CHARSET_Default},
-    {1 << 8, FX_CHARSET_Default},
-    {1 << 9, FX_CHARSET_Default},
-    {1 << 10, FX_CHARSET_Default},
-    {1 << 11, FX_CHARSET_Default},
-    {1 << 12, FX_CHARSET_Default},
-    {1 << 13, FX_CHARSET_Default},
-    {1 << 14, FX_CHARSET_OEM},
-    {1 << 15, FX_CHARSET_Symbol},
-};
-
-const FX_BIT2CHARSET g_FX_Bit2Charset3[16] = {
-    {1 << 0, FX_CHARSET_Default},  {1 << 1, FX_CHARSET_Default},
-    {1 << 2, FX_CHARSET_Default},  {1 << 3, FX_CHARSET_Default},
-    {1 << 4, FX_CHARSET_Default},  {1 << 5, FX_CHARSET_Default},
-    {1 << 6, FX_CHARSET_Default},  {1 << 7, FX_CHARSET_Default},
-    {1 << 8, FX_CHARSET_Default},  {1 << 9, FX_CHARSET_Default},
-    {1 << 10, FX_CHARSET_Default}, {1 << 11, FX_CHARSET_Default},
-    {1 << 12, FX_CHARSET_Default}, {1 << 13, FX_CHARSET_Default},
-    {1 << 14, FX_CHARSET_Default}, {1 << 15, FX_CHARSET_Default},
-};
-
-const FX_BIT2CHARSET g_FX_Bit2Charset4[16] = {
-    {1 << 0, FX_CHARSET_Default},  {1 << 1, FX_CHARSET_Default},
-    {1 << 2, FX_CHARSET_Default},  {1 << 3, FX_CHARSET_Default},
-    {1 << 4, FX_CHARSET_Default},  {1 << 5, FX_CHARSET_Default},
-    {1 << 6, FX_CHARSET_Default},  {1 << 7, FX_CHARSET_Default},
-    {1 << 8, FX_CHARSET_Default},  {1 << 9, FX_CHARSET_Default},
-    {1 << 10, FX_CHARSET_Default}, {1 << 11, FX_CHARSET_Default},
-    {1 << 12, FX_CHARSET_Default}, {1 << 13, FX_CHARSET_Default},
-    {1 << 14, FX_CHARSET_Default}, {1 << 15, FX_CHARSET_US},
-};
+const FX_BIT2CHARSET g_FX_Bit2Charset[4][16] = {
+    {{1 << 0, FX_CHARSET_ANSI},
+     {1 << 1, FX_CHARSET_MSWin_EasterEuropean},
+     {1 << 2, FX_CHARSET_MSWin_Cyrillic},
+     {1 << 3, FX_CHARSET_MSWin_Greek},
+     {1 << 4, FX_CHARSET_MSWin_Turkish},
+     {1 << 5, FX_CHARSET_MSWin_Hebrew},
+     {1 << 6, FX_CHARSET_MSWin_Arabic},
+     {1 << 7, FX_CHARSET_MSWin_Baltic},
+     {1 << 8, FX_CHARSET_MSWin_Vietnamese},
+     {1 << 9, FX_CHARSET_Default},
+     {1 << 10, FX_CHARSET_Default},
+     {1 << 11, FX_CHARSET_Default},
+     {1 << 12, FX_CHARSET_Default},
+     {1 << 13, FX_CHARSET_Default},
+     {1 << 14, FX_CHARSET_Default},
+     {1 << 15, FX_CHARSET_Default}},
+    {{1 << 0, FX_CHARSET_Thai},
+     {1 << 1, FX_CHARSET_ShiftJIS},
+     {1 << 2, FX_CHARSET_ChineseSimplified},
+     {1 << 3, FX_CHARSET_Korean},
+     {1 << 4, FX_CHARSET_ChineseTriditional},
+     {1 << 5, FX_CHARSET_Johab},
+     {1 << 6, FX_CHARSET_Default},
+     {1 << 7, FX_CHARSET_Default},
+     {1 << 8, FX_CHARSET_Default},
+     {1 << 9, FX_CHARSET_Default},
+     {1 << 10, FX_CHARSET_Default},
+     {1 << 11, FX_CHARSET_Default},
+     {1 << 12, FX_CHARSET_Default},
+     {1 << 13, FX_CHARSET_Default},
+     {1 << 14, FX_CHARSET_OEM},
+     {1 << 15, FX_CHARSET_Symbol}},
+    {{1 << 0, FX_CHARSET_Default},
+     {1 << 1, FX_CHARSET_Default},
+     {1 << 2, FX_CHARSET_Default},
+     {1 << 3, FX_CHARSET_Default},
+     {1 << 4, FX_CHARSET_Default},
+     {1 << 5, FX_CHARSET_Default},
+     {1 << 6, FX_CHARSET_Default},
+     {1 << 7, FX_CHARSET_Default},
+     {1 << 8, FX_CHARSET_Default},
+     {1 << 9, FX_CHARSET_Default},
+     {1 << 10, FX_CHARSET_Default},
+     {1 << 11, FX_CHARSET_Default},
+     {1 << 12, FX_CHARSET_Default},
+     {1 << 13, FX_CHARSET_Default},
+     {1 << 14, FX_CHARSET_Default},
+     {1 << 15, FX_CHARSET_Default}},
+    {{1 << 0, FX_CHARSET_Default},
+     {1 << 1, FX_CHARSET_Default},
+     {1 << 2, FX_CHARSET_Default},
+     {1 << 3, FX_CHARSET_Default},
+     {1 << 4, FX_CHARSET_Default},
+     {1 << 5, FX_CHARSET_Default},
+     {1 << 6, FX_CHARSET_Default},
+     {1 << 7, FX_CHARSET_Default},
+     {1 << 8, FX_CHARSET_Default},
+     {1 << 9, FX_CHARSET_Default},
+     {1 << 10, FX_CHARSET_Default},
+     {1 << 11, FX_CHARSET_Default},
+     {1 << 12, FX_CHARSET_Default},
+     {1 << 13, FX_CHARSET_Default},
+     {1 << 14, FX_CHARSET_Default},
+     {1 << 15, FX_CHARSET_US}}};
 
 }  // namespace
 
 CFX_FontDescriptor::CFX_FontDescriptor()
     : m_nFaceIndex(0), m_dwFontStyles(0), m_dwUsb(), m_dwCsb() {}
 
 CFX_FontDescriptor::~CFX_FontDescriptor() {}
 
 CFX_FontSourceEnum_File::CFX_FontSourceEnum_File() {
   for (size_t i = 0; i < FX_ArraySize(g_FontFolders); ++i)
@@ skipping 220 matching lines @@
   if (wCodePage == 0xFFFF)
     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);
   CFX_ArrayTemplate<CFGAS_GEFont*>* pFonts = nullptr;
   if (m_Hash2Fonts.Lookup(dwHash, pFonts)) {
     if (!pFonts)
       return nullptr;
+
     for (int32_t i = 0; i < pFonts->GetSize(); ++i) {
       if (VerifyUnicode(pFonts->GetAt(i), wUnicode))
         return pFonts->GetAt(i)->Retain();
     }
   }
   if (!pFonts)
     pFonts = new CFX_ArrayTemplate<CFGAS_GEFont*>;
   m_Hash2Fonts.SetAt(dwHash, pFonts);
   CFX_FontDescriptorInfos* sortedFonts = nullptr;
   if (!m_Hash2CandidateList.Lookup(dwHash, sortedFonts)) {
@@ skipping 17 matching lines @@
     m_FailedUnicodes2Nullptr.SetAt(wUnicode, nullptr);
   return nullptr;
 }
 
 bool CFGAS_FontMgr::VerifyUnicode(CFX_FontDescriptor* pDesc,
                                   FX_WCHAR wcUnicode) {
   IFX_SeekableReadStream* 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);
   FXFT_Done_Face(pFace);
   return !retCharmap && retIndex;
 }
 
 bool CFGAS_FontMgr::VerifyUnicode(CFGAS_GEFont* pFont, FX_WCHAR wcUnicode) {
   if (!pFont)
     return false;
 
@@ skipping 75 matching lines @@
   pFontMgr->InitFTLibrary();
   FXFT_Library library = pFontMgr->GetFTLibrary();
   if (!library)
     return nullptr;
 
   FXFT_Stream ftStream = FX_Alloc(FXFT_StreamRec, 1);
   FXSYS_memset(ftStream, 0, sizeof(FXFT_StreamRec));
   ftStream->base = nullptr;
   ftStream->descriptor.pointer = pFontStream;
   ftStream->pos = 0;
-  ftStream->size = (unsigned long)pFontStream->GetSize();
+  ftStream->size = static_cast<unsigned long>(pFontStream->GetSize());
   ftStream->read = _ftStreamRead;
   ftStream->close = _ftStreamClose;
 
   FXFT_Open_Args ftArgs;
   FXSYS_memset(&ftArgs, 0, sizeof(FXFT_Open_Args));
   ftArgs.flags |= FT_OPEN_STREAM;
   ftArgs.stream = ftStream;
 
   FXFT_Face pFace = nullptr;
   if (FXFT_Open_Face(library, &ftArgs, iFaceIndex, &pFace)) {
@@ skipping 77 matching lines @@
   ssort.ShellSort(MatchedFonts.GetData(), MatchedFonts.GetSize());
   return MatchedFonts.GetSize();
 }
 
 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 (0 != FontName.GetLength()) {
+  if (FontName.GetLength() != 0) {
     if (FontName != pInstalled->m_wsFaceName) {
       int32_t i;
       for (i = 0; i < pInstalled->m_wsFamilyNames.GetSize(); i++) {
         if (pInstalled->m_wsFamilyNames[i] == FontName)
           break;
       }
       if (i == pInstalled->m_wsFamilyNames.GetSize())
         nPenalty += 0xFFFF;
       else
         nPenalty -= 28000;
     } else {
       nPenalty -= 30000;
     }
     if (30000 == nPenalty &&
         0 == IsPartName(pInstalled->m_wsFaceName, FontName)) {
       int32_t i;
       for (i = 0; i < pInstalled->m_wsFamilyNames.GetSize(); i++) {
-        if (0 != IsPartName(pInstalled->m_wsFamilyNames[i], FontName))
+        if (IsPartName(pInstalled->m_wsFamilyNames[i], FontName) != 0)
           break;
       }
       if (i == pInstalled->m_wsFamilyNames.GetSize())
         nPenalty += 0xFFFF;
       else
         nPenalty -= 26000;
     } else {
       nPenalty -= 27000;
     }
   }
   uint32_t dwStyleMask = pInstalled->m_dwFontStyles ^ dwFontStyles;
   if (dwStyleMask & FX_FONTSTYLE_Bold)
     nPenalty += 4500;
   if (dwStyleMask & FX_FONTSTYLE_FixedPitch)
     nPenalty += 10000;
   if (dwStyleMask & FX_FONTSTYLE_Italic)
     nPenalty += 10000;
   if (dwStyleMask & FX_FONTSTYLE_Serif)
     nPenalty += 500;
   if (dwStyleMask & FX_FONTSTYLE_Symbolic)
     nPenalty += 0xFFFF;
   if (nPenalty >= 0xFFFF)
     return 0xFFFF;
-  uint16_t wBit =
-      ((0 == wCodePage || 0xFFFF == wCodePage) ? (uint16_t)-1
-                                               : FX_GetCodePageBit(wCodePage));
-  if (wBit != (uint16_t)-1) {
+
+  uint16_t wBit = (wCodePage == 0 || wCodePage == 0xFFFF)
+                      ? static_cast<uint16_t>(-1)
+                      : FX_GetCodePageBit(wCodePage);
+  if (wBit != static_cast<uint16_t>(-1)) {
     ASSERT(wBit < 64);
-    if (0 == (pInstalled->m_dwCsb[wBit / 32] & (1 << (wBit % 32))))
+    if ((pInstalled->m_dwCsb[wBit / 32] & (1 << (wBit % 32))) == 0)
       nPenalty += 0xFFFF;
     else
       nPenalty -= 60000;
   }
-  wBit =
-      ((0 == wcUnicode || 0xFFFE == wcUnicode) ? (uint16_t)999
-                                               : FX_GetUnicodeBit(wcUnicode));
-  if (wBit != (uint16_t)999) {
+  wBit = (wcUnicode == 0 || wcUnicode == 0xFFFE) ? static_cast<uint16_t>(999)
+                                                 : FX_GetUnicodeBit(wcUnicode);
+  if (wBit != static_cast<uint16_t>(999)) {
     ASSERT(wBit < 128);
-    if (0 == (pInstalled->m_dwUsb[wBit / 32] & (1 << (wBit % 32))))
+    if ((pInstalled->m_dwUsb[wBit / 32] & (1 << (wBit % 32))) == 0)
       nPenalty += 0xFFFF;
     else
       nPenalty -= 60000;
   }
   return nPenalty;
 }
 
-void CFGAS_FontMgr::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_IFXFont2FileRead.GetStartPosition();
-  while (pos) {
-    CFGAS_GEFont* pFont;
-    IFX_SeekableReadStream* pFileRead;
-    m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
-    pFileRead->Release();
-  }
-}
-
 void CFGAS_FontMgr::RemoveFont(CFGAS_GEFont* pEFont) {
   if (!pEFont)
     return;
 
   IFX_SeekableReadStream* pFileRead;
   if (m_IFXFont2FileRead.Lookup(pEFont, pFileRead)) {
     pFileRead->Release();
     m_IFXFont2FileRead.RemoveKey(pEFont);
   }
   FX_POSITION pos;
@@ skipping 66 matching lines @@
   } while (index < num_faces);
 }
 
 uint32_t CFGAS_FontMgr::GetFlags(FXFT_Face pFace) {
   uint32_t flag = 0;
   if (FT_IS_FIXED_WIDTH(pFace))
     flag |= FX_FONTSTYLE_FixedPitch;
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
   if (!pOS2)
     return flag;
+
   if (pOS2->ulCodePageRange1 & (1 << 31))
     flag |= FX_FONTSTYLE_Symbolic;
   if (pOS2->panose[0] == 2) {
     uint8_t uSerif = pOS2->panose[1];
     if ((uSerif > 1 && uSerif < 10) || uSerif > 13)
       flag |= FX_FONTSTYLE_Serif;
   }
   return flag;
 }
 
 void CFGAS_FontMgr::GetNames(const uint8_t* name_table,
                              CFX_WideStringArray& Names) {
-  if (!name_table) {
+  if (!name_table)
     return;
-  }
+
   uint8_t* lpTable = (uint8_t*)name_table;
   CFX_WideString wsFamily;
   uint8_t* sp = lpTable + 2;
   uint8_t* lpNameRecord = lpTable + 6;
   uint16_t nNameCount = GetUInt16(sp);
   uint8_t* lpStr = lpTable + GetUInt16(sp + 2);
   for (uint16_t j = 0; j < nNameCount; j++) {
     uint16_t nNameID = GetUInt16(lpNameRecord + j * 12 + 6);
-    if (nNameID != 1) {
+    if (nNameID != 1)
       continue;
-    }
+
     uint16_t nPlatformID = GetUInt16(lpNameRecord + j * 12 + 0);
     uint16_t nNameLength = GetUInt16(lpNameRecord + j * 12 + 8);
     uint16_t nNameOffset = GetUInt16(lpNameRecord + j * 12 + 10);
     wsFamily.clear();
     if (nPlatformID != 1) {
       for (uint16_t k = 0; k < nNameLength / 2; k++) {
         FX_WCHAR wcTemp = GetUInt16(lpStr + nNameOffset + k * 2);
         wsFamily += wcTemp;
       }
       Names.Add(wsFamily);
-    } else {
-      for (uint16_t k = 0; k < nNameLength; k++) {
-        FX_WCHAR wcTemp = GetUInt8(lpStr + nNameOffset + k);
-        wsFamily += wcTemp;
-      }
-      Names.Add(wsFamily);
+      continue;
     }
+    for (uint16_t k = 0; k < nNameLength; k++) {
+      FX_WCHAR wcTemp = GetUInt8(lpStr + nNameOffset + k);
+      wsFamily += wcTemp;
+    }
+    Names.Add(wsFamily);
   }
 }
 
-// TODO(npm): Get rid of this #define
-#define CODEPAGERANGE_IMPLEMENT(n)                         \
-  for (int32_t i = 0; i < 16; i++) {                       \
-    if ((a##n & g_FX_Bit2Charset##n[i].wBit) != 0)         \
-      charsets.push_back(g_FX_Bit2Charset##n[i].wCharset); \
-  }
-
 std::vector<uint16_t> CFGAS_FontMgr::GetCharsets(FXFT_Face pFace) const {
   std::vector<uint16_t> charsets;
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
-  if (pOS2) {
-    uint16_t a1 = pOS2->ulCodePageRange1 & 0xffff;
-    CODEPAGERANGE_IMPLEMENT(1);
-    uint16_t a2 = (pOS2->ulCodePageRange1 >> 16) & 0xffff;
-    CODEPAGERANGE_IMPLEMENT(2);
-    uint16_t a3 = pOS2->ulCodePageRange2 & 0xffff;
-    CODEPAGERANGE_IMPLEMENT(3);
-    uint16_t a4 = (pOS2->ulCodePageRange2 >> 16) & 0xffff;
-    CODEPAGERANGE_IMPLEMENT(4);
-  } else {
+  if (!pOS2) {
     charsets.push_back(FX_CHARSET_Default);
+    return charsets;
+  }
+  uint16_t a[4];

[Tom Sepez, 2016/11/18 19:46:23]

nit: I'd unroll the loop at 1180 to maybe avoid having an array here. Your call.

[Tom Sepez, 2016/11/18 19:55:43]

nit: maybe brace-initialization of this array.

[npm, 2016/11/18 20:49:44]

I like loops

[npm, 2016/11/18 20:49:44]

Done.

+  a[0] = pOS2->ulCodePageRange1 & 0xffff;
+  a[1] = (pOS2->ulCodePageRange1 >> 16) & 0xffff;
+  a[2] = pOS2->ulCodePageRange2 & 0xffff;
+  a[3] = (pOS2->ulCodePageRange2 >> 16) & 0xffff;
+  for (int n = 0; n < 4; n++) {
+    for (int32_t i = 0; i < 16; i++) {
+      if ((a[n] & g_FX_Bit2Charset[n][i].wBit) != 0)
+        charsets.push_back(g_FX_Bit2Charset[n][i].wCharset);
+    }
   }
   return charsets;
 }
 
-#undef CODEPAGERANGE_IMPLEMENT
-
 void CFGAS_FontMgr::GetUSBCSB(FXFT_Face pFace, uint32_t* USB, uint32_t* CSB) {
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
   if (pOS2) {

[Tom Sepez, 2016/11/18 19:46:23]

nit: can we make this !pOS2 and flip the blocks around (e.g. early return on
error rather than early return on success idiom).

[npm, 2016/11/18 20:49:44]

Done.

     USB[0] = pOS2->ulUnicodeRange1;
     USB[1] = pOS2->ulUnicodeRange2;
     USB[2] = pOS2->ulUnicodeRange3;
     USB[3] = pOS2->ulUnicodeRange4;
     CSB[0] = pOS2->ulCodePageRange1;
     CSB[1] = pOS2->ulCodePageRange2;
-  } else {
-    USB[0] = 0;
-    USB[1] = 0;
-    USB[2] = 0;
-    USB[3] = 0;
-    CSB[0] = 0;
-    CSB[1] = 0;
+    return;
   }
+  USB[0] = 0;
+  USB[1] = 0;
+  USB[2] = 0;
+  USB[3] = 0;
+  CSB[0] = 0;
+  CSB[1] = 0;
 }
 
 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_