Get rid of NULLs in xfa/

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 "core/fxge/include/fx_ge.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/font/fgas_fontutils.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);
+    m_pEnumerator(m_FontFaces, nullptr, 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();
 }
 
 IFGAS_Font* CFGAS_StdFontMgrImp::GetDefFontByCodePage(
     uint16_t wCodePage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   uint32_t dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
-  IFGAS_Font* pFont = NULL;
+  IFGAS_Font* pFont = nullptr;
   if (m_CPFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
-    return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
-  }
-  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;
-    }
+    return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : nullptr;
   }
   ASSERT(pFD);
   pFont = IFGAS_Font::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 NULL;
+  return nullptr;
 }
 IFGAS_Font* CFGAS_StdFontMgrImp::GetDefFontByCharset(
     uint8_t nCharset,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles,
                               pszFontFamily);
 }
 
 IFGAS_Font* CFGAS_StdFontMgrImp::GetDefFontByUnicode(
@@ skipping 40 matching lines @@
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage),
                               dwFontStyles, pszFontFamily);
 }
 IFGAS_Font* CFGAS_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFontFamily,
                                           uint32_t dwFontStyles,
                                           uint16_t wCodePage) {
   uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, wCodePage);
-  IFGAS_Font* pFont = NULL;
+  IFGAS_Font* pFont = nullptr;
   if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
-    return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
+    return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : nullptr;
   }
-  FX_FONTDESCRIPTOR const* pFD = NULL;
-  if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {
-    if ((pFD = FindFont(pszFontFamily, dwFontStyles, FALSE, wCodePage)) ==
-        NULL) {
-      return NULL;
-    }
-  }
-  ASSERT(pFD);
-  if (wCodePage == 0xFFFF) {
+  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 = IFGAS_Font::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 NULL;
+  return nullptr;
 }
 IFGAS_Font* CFGAS_StdFontMgrImp::LoadFont(const uint8_t* pBuffer,
                                           int32_t iLength) {
   ASSERT(pBuffer && iLength > 0);
-  IFGAS_Font* pFont = NULL;
+  IFGAS_Font* pFont = nullptr;
   if (m_BufferFonts.Lookup((void*)pBuffer, (void*&)pFont)) {
     if (pFont) {
       return pFont->Retain();
     }
   }
   pFont = IFGAS_Font::LoadFont(pBuffer, iLength, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_BufferFonts.SetAt((void*)pBuffer, pFont);
     return pFont->Retain();
   }
-  return NULL;
+  return nullptr;
 }
 IFGAS_Font* CFGAS_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFileName) {
   ASSERT(pszFileName);
   uint32_t dwHash = FX_HashCode_GetW(pszFileName, false);
-  IFGAS_Font* pFont = NULL;
+  IFGAS_Font* pFont = nullptr;
   if (m_FileFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     if (pFont) {
       return pFont->Retain();
     }
   }
-  pFont = IFGAS_Font::LoadFont(pszFileName, NULL);
+  pFont = IFGAS_Font::LoadFont(pszFileName, nullptr);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_FileFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return pFont->Retain();
   }
-  return NULL;
+  return nullptr;
 }
 IFGAS_Font* CFGAS_StdFontMgrImp::LoadFont(IFX_Stream* pFontStream,
                                           const FX_WCHAR* pszFontAlias,
                                           uint32_t dwFontStyles,
                                           uint16_t wCodePage,
                                           FX_BOOL bSaveStream) {
   ASSERT(pFontStream && pFontStream->GetLength() > 0);
-  IFGAS_Font* pFont = NULL;
+  IFGAS_Font* 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 = IFGAS_Font::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 NULL;
+  return nullptr;
 }
 IFGAS_Font* CFGAS_StdFontMgrImp::LoadFont(IFGAS_Font* 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);
-  IFGAS_Font* pFont = NULL;
+  IFGAS_Font* 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;
   }
-  return NULL;
+  return nullptr;
 }
 
 void CFGAS_StdFontMgrImp::ClearFontCache() {
   for (int32_t i = 0; i < m_Fonts.GetSize(); i++)
     m_Fonts[i]->Reset();
 }
 
 void CFGAS_StdFontMgrImp::RemoveFont(CFX_MapPtrToPtr& fontMap,
                                      IFGAS_Font* pFont) {
   FX_POSITION pos = fontMap.GetStartPosition();
   void* pKey;
   void* pFind;
   while (pos) {
-    pFind = NULL;
+    pFind = nullptr;
     fontMap.GetNextAssoc(pos, pKey, pFind);
     if (pFind != (void*)pFont) {
       continue;
     }
     fontMap.RemoveKey(pKey);
     break;
   }
 }
 void CFGAS_StdFontMgrImp::RemoveFont(IFGAS_Font* pFont) {
   RemoveFont(m_CPFonts, pFont);
@@ skipping 23 matching lines @@
   params.pwsFamily = pszFontFamily;
   params.dwFontStyles = dwFontStyles;
   params.dwMatchFlags = dwMatchFlags;
   FX_FONTDESCRIPTOR const* pDesc = FX_DefFontMatcher(&params, m_FontFaces);
   if (pDesc) {
     return pDesc;
   }
   if (pszFontFamily && m_pEnumerator) {
     CFX_FontDescriptors namedFonts;
     m_pEnumerator(namedFonts, pszFontFamily, wUnicode);
-    params.pwsFamily = NULL;
+    params.pwsFamily = nullptr;
     pDesc = FX_DefFontMatcher(&params, namedFonts);
-    if (pDesc == NULL) {
-      return NULL;
-    }
+    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);
   }
-  return NULL;
+  return nullptr;
 }
 FX_FONTDESCRIPTOR const* FX_DefFontMatcher(FX_LPFONTMATCHPARAMS pParams,
                                            const CFX_FontDescriptors& fonts) {
-  FX_FONTDESCRIPTOR const* pBestFont = NULL;
+  FX_FONTDESCRIPTOR const* pBestFont = nullptr;
   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_FONTDESCRIPTOR const* pFont = fonts.GetPtrAt(i);
     if ((pFont->dwFontStyles & FX_FONTSTYLE_BoldItalic) ==
         FX_FONTSTYLE_BoldItalic) {
       continue;
     }
@@ skipping 30 matching lines @@
       if (FXSYS_wcsicmp(pParams->pwsFamily, pFont->wsFontFace) == 0) {
         return pFont;
       }
     }
     int32_t iSimilarValue = FX_GetSimilarValue(pFont, pParams->dwFontStyles);
     if (iBestSimilar < iSimilarValue) {
       iBestSimilar = iSimilarValue;
       pBestFont = pFont;
     }
   }
-  return iBestSimilar < 1 ? NULL : pBestFont;
+  return iBestSimilar < 1 ? nullptr : pBestFont;
 }
 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)) {
@@ skipping 48 matching lines @@
   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,
                             const FX_WCHAR* pwsFaceName,
                             FX_WCHAR wUnicode) {
-  HDC hDC = ::GetDC(NULL);
+  HDC hDC = ::GetDC(nullptr);
   LOGFONTW lfFind;
   FXSYS_memset(&lfFind, 0, sizeof(lfFind));
   lfFind.lfCharSet = DEFAULT_CHARSET;
   if (pwsFaceName) {
     FXSYS_wcsncpy(lfFind.lfFaceName, pwsFaceName, 31);
     lfFind.lfFaceName[31] = 0;
   }
   EnumFontFamiliesExW(hDC, (LPLOGFONTW)&lfFind,
                       (FONTENUMPROCW)FX_GdiFontEnumProc, (LPARAM)&fonts, 0);
-  ::ReleaseDC(NULL, hDC);
+  ::ReleaseDC(nullptr, hDC);
 }
 FX_LPEnumAllFonts FX_GetDefFontEnumerator() {
   return FX_EnumGdiFonts;
 }
 #else
 const FX_CHAR* g_FontFolders[] = {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_
     "/usr/share/fonts", "/usr/share/X11/fonts/Type1",
     "/usr/share/X11/fonts/TTF", "/usr/local/share/fonts",
 #elif _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
     "~/Library/Fonts", "/Library/Fonts", "/System/Library/Fonts",
 #elif _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_
     "/system/fonts",
 #endif
 };
 
 CFX_FontSourceEnum_File::CFX_FontSourceEnum_File() {
   for (size_t i = 0; i < FX_ArraySize(g_FontFolders); ++i)
     m_FolderPaths.Add(g_FontFolders[i]);
 }
 
 CFX_ByteString CFX_FontSourceEnum_File::GetNextFile() {
 Restart:
   void* pCurHandle =
       m_FolderQueue.GetSize() == 0
-          ? NULL
+          ? nullptr
           : m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->pFileHandle;
-  if (NULL == pCurHandle) {
-    if (m_FolderPaths.GetSize() < 1) {
+  if (!pCurHandle) {
+    if (m_FolderPaths.GetSize() < 1)
       return "";
-    }
+
     pCurHandle =
         FX_OpenFolder(m_FolderPaths[m_FolderPaths.GetSize() - 1].c_str());
     FX_HandleParentPath hpp;
     hpp.pFileHandle = pCurHandle;
     hpp.bsParentPath = m_FolderPaths[m_FolderPaths.GetSize() - 1];
     m_FolderQueue.Add(hpp);
   }
   CFX_ByteString bsName;
   FX_BOOL bFolder;
   CFX_ByteString bsFolderSpearator =
@@ skipping 16 matching lines @@
     }
     if (bsName == "." || bsName == "..") {
       continue;
     }
     if (bFolder) {
       FX_HandleParentPath hpp;
       hpp.bsParentPath =
           m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->bsParentPath +
           bsFolderSpearator + bsName;
       hpp.pFileHandle = FX_OpenFolder(hpp.bsParentPath.c_str());
-      if (hpp.pFileHandle == NULL) {
+      if (!hpp.pFileHandle)
         continue;
-      }
+
       m_FolderQueue.Add(hpp);
       pCurHandle = hpp.pFileHandle;
       continue;
     }
     bsName =
         m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->bsParentPath +
         bsFolderSpearator + bsName;
     break;
   }
   return bsName;
 }
 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) {
   IFX_FileAccess* pAccess = FX_CreateDefaultFileAccess(m_wsNext.AsStringC());
   m_wsNext = GetNextFile().UTF8Decode();
-  pos = 0 != m_wsNext.GetLength() ? pAccess : NULL;
+  pos = 0 != m_wsNext.GetLength() ? pAccess : nullptr;
   return (IFX_FileAccess*)pAccess;
 }
 
 IFGAS_FontMgr* IFGAS_FontMgr::Create(CFX_FontSourceEnum_File* pFontEnum) {
   if (!pFontEnum)
     return nullptr;
 
   std::unique_ptr<CFGAS_FontMgrImp> pFontMgr(new CFGAS_FontMgrImp(pFontEnum));
   if (!pFontMgr->EnumFonts())
     return nullptr;
@@ skipping 75 matching lines @@
     CFX_ArrayTemplate<IFGAS_Font*>* 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) {
+    if (pFileAccess)
       pFileAccess->Release();
-    }
   }
   pos = m_FileAccess2IFXFont.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     IFGAS_Font* pFont;
     m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pFont);
-    if (NULL != pFont) {
+    if (pFont)
       pFont->Release();
-    }
   }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     IFGAS_Font* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
   delete this;
 }
@@ skipping 543 matching lines @@
     uint32_t dwHash;
     CFX_FontDescriptorInfos* pDescs;
     m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs);
     delete pDescs;
   }
   pos = m_FileAccess2IFXFont.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     IFGAS_Font* pFont;
     m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pFont);
-    if (NULL != pFont) {
+    if (pFont)
       pFont->Release();
-    }
   }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     IFGAS_Font* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
 }
 void CFGAS_FontMgrImp::RemoveFont(IFGAS_Font* pEFont) {
-  if (NULL == pEFont) {
+  if (!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;
     IFGAS_Font* 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<IFGAS_Font*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
-    if (NULL != pFonts) {
+    if (pFonts) {
       for (int32_t i = 0; i < pFonts->GetSize(); i++) {
         if (pFonts->GetAt(i) == pEFont) {
-          pFonts->SetAt(i, NULL);
+          pFonts->SetAt(i, nullptr);
         }
       }
     } else {
       m_Hash2Fonts.RemoveKey(dwHash);
     }
   }
 }
 
 void CFGAS_FontMgrImp::RegisterFace(FXFT_Face pFace,
                                     CFX_FontDescriptors& Fonts,
@@ skipping 75 matching lines @@
     }
   }
   return flag;
 }
 #define GetUInt8(p) ((uint8_t)((p)[0]))
 #define GetUInt16(p) ((uint16_t)((p)[0] << 8 | (p)[1]))
 #define GetUInt32(p) \
   ((uint32_t)((p)[0] << 24 | (p)[1] << 16 | (p)[2] << 8 | (p)[3]))
 void CFGAS_FontMgrImp::GetNames(const uint8_t* name_table,
                                 CFX_WideStringArray& Names) {
-  if (NULL == 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) {
       continue;
@@ skipping 83 matching lines @@
 #define CODEPAGERANGE_IMPLEMENT(n)                   \
   for (int32_t i = 0; i < 16; i++) {                 \
     if ((a##n & g_FX_Bit2Charset##n[i].wBit) != 0) { \
       Charsets.Add(g_FX_Bit2Charset##n[i].wCharset); \
     }                                                \
   }
 void CFGAS_FontMgrImp::GetCharsets(FXFT_Face pFace,
                                    CFX_ArrayTemplate<uint16_t>& Charsets) {
   Charsets.RemoveAll();
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
-  if (NULL != pOS2) {
+  if (pOS2) {
     uint16_t a1, a2, a3, a4;
     a1 = pOS2->ulCodePageRange1 & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(1);
     a2 = (pOS2->ulCodePageRange1 >> 16) & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(2);
     a3 = pOS2->ulCodePageRange2 & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(3);
     a4 = (pOS2->ulCodePageRange2 >> 16) & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(4);
   } else {
     Charsets.Add(FX_CHARSET_Default);
   }
 }
 #undef CODEPAGERANGE_IMPLEMENT
 void CFGAS_FontMgrImp::GetUSBCSB(FXFT_Face pFace,
                                  uint32_t* USB,
                                  uint32_t* CSB) {
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
-  if (NULL != pOS2) {
+  if (pOS2) {
     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;
   }
 }
 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