Remove FX_BOOL from xfa.

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/fx_stream.h"
 #include "core/fxge/cfx_fontmapper.h"
@@ skipping 19 matching lines @@
       m_UnicodeFonts(16),
       m_BufferFonts(4),
       m_StreamFonts(4),
       m_DeriveFonts(4) {
   if (m_pEnumerator) {
     m_pEnumerator(m_FontFaces, nullptr, 0xFEFF);
   }
 }
 
 CFGAS_StdFontMgrImp::~CFGAS_StdFontMgrImp() {
-  m_FontFaces.RemoveAll(FALSE);
+  m_FontFaces.RemoveAll(false);
   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_StdFontMgrImp::GetDefFontByCodePage(
     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);
+      FindFont(pszFontFamily, dwFontStyles, true, wCodePage);
   if (!pFD)
-    pFD = FindFont(nullptr, dwFontStyles, TRUE, wCodePage);
+    pFD = FindFont(nullptr, dwFontStyles, true, wCodePage);
   if (!pFD)
-    pFD = FindFont(nullptr, dwFontStyles, FALSE, wCodePage);
+    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);
@@ skipping 18 matching lines @@
   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,
+      FindFont(pszFontFamily, dwFontStyles, false, pRet->wCodePage,
                pRet->wBitField, wUnicode);
   if (!pFD && pszFontFamily) {
-    pFD = FindFont(nullptr, dwFontStyles, FALSE, pRet->wCodePage,
+    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);
@@ skipping 18 matching lines @@
 CFGAS_GEFont* CFGAS_StdFontMgrImp::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);
+      FindFont(pszFontFamily, dwFontStyles, true, wCodePage);
   if (!pFD)
-    pFD = FindFont(pszFontFamily, dwFontStyles, FALSE, wCodePage);
+    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);
@@ skipping 20 matching lines @@
     m_BufferFonts.SetAt((void*)pBuffer, pFont);
     return pFont->Retain();
   }
   return nullptr;
 }
 
 CFGAS_GEFont* CFGAS_StdFontMgrImp::LoadFont(IFX_Stream* pFontStream,
                                             const FX_WCHAR* pszFontAlias,
                                             uint32_t dwFontStyles,
                                             uint16_t wCodePage,
-                                            FX_BOOL bSaveStream) {
+                                            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);
@@ skipping 114 matching lines @@
     int index = m_FontFaces.Add(*pDesc);
     return m_FontFaces.GetPtrAt(index);
   }
   return nullptr;
 }
 
 FX_FONTDESCRIPTOR const* FX_DefFontMatcher(FX_LPFONTMATCHPARAMS pParams,
                                            const CFX_FontDescriptors& fonts) {
   FX_FONTDESCRIPTOR const* pBestFont = nullptr;
   int32_t iBestSimilar = 0;
-  FX_BOOL bMatchStyle =
-      (pParams->dwMatchFlags & FX_FONTMATCHPARA_MacthStyle) > 0;
+  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;
     }
     if (pParams->pwsFamily) {
       if (FXSYS_wcsicmp(pParams->pwsFamily, pFont->wsFontFace)) {
         continue;
@@ skipping 254 matching lines @@
   m_Hash2Fonts.RemoveAll();
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     CFGAS_GEFont* pFont;
     IFX_SeekableReadStream* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
 }
 
-FX_BOOL CFGAS_FontMgrImp::EnumFontsFromFontMapper() {
+bool CFGAS_FontMgrImp::EnumFontsFromFontMapper() {
   CFX_FontMapper* pFontMapper =
       CFX_GEModule::Get()->GetFontMgr()->GetBuiltinMapper();
   if (!pFontMapper)
-    return FALSE;
+    return false;
 
   IFX_SystemFontInfo* pSystemFontInfo = pFontMapper->GetSystemFontInfo();
   if (!pSystemFontInfo)
-    return FALSE;
+    return false;
 
   pSystemFontInfo->EnumFontList(pFontMapper);
   for (int32_t i = 0; i < pFontMapper->GetFaceSize(); ++i) {
     IFX_SeekableReadStream* pFontStream =
         CreateFontStream(pFontMapper, pSystemFontInfo, i);
     if (!pFontStream)
       continue;
 
     CFX_WideString wsFaceName =
         CFX_WideString::FromLocal(pFontMapper->GetFaceName(i).c_str());
     RegisterFaces(pFontStream, &wsFaceName);
     pFontStream->Release();
   }
   if (m_InstalledFonts.GetSize() == 0)
-    return FALSE;
+    return false;
 
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFGAS_FontMgrImp::EnumFontsFromFiles() {
+bool CFGAS_FontMgrImp::EnumFontsFromFiles() {
   CFX_GEModule::Get()->GetFontMgr()->InitFTLibrary();
   FX_POSITION pos = m_pFontSource->GetStartPosition();
   IFX_FileAccess* pFontSource = nullptr;
   IFX_SeekableReadStream* pFontStream = nullptr;
   while (pos) {
     pFontSource = m_pFontSource->GetNext(pos);
     pFontStream = pFontSource->CreateFileStream(FX_FILEMODE_ReadOnly);
     if (!pFontStream) {
       pFontSource->Release();
       continue;
     }
     RegisterFaces(pFontStream, nullptr);
     pFontStream->Release();
     pFontSource->Release();
   }
   if (m_InstalledFonts.GetSize() == 0)
-    return FALSE;
-  return TRUE;
+    return false;
+  return true;
 }
 
-FX_BOOL CFGAS_FontMgrImp::EnumFonts() {
+bool CFGAS_FontMgrImp::EnumFonts() {
   if (EnumFontsFromFontMapper())
-    return TRUE;
+    return true;
   return EnumFontsFromFiles();
 }
 
 CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByCodePage(
     uint16_t wCodePage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
 
@@ skipping 112 matching lines @@
       continue;
     pFont->SetLogicalFontStyle(dwFontStyles);
     pFonts->Add(pFont);
     return pFont;
   }
   if (!pszFontFamily)
     m_FailedUnicodes2Nullptr.SetAt(wUnicode, nullptr);
   return nullptr;
 }
 
-FX_BOOL CFGAS_FontMgrImp::VerifyUnicode(CFX_FontDescriptor* pDesc,
-                                        FX_WCHAR wcUnicode) {
+bool CFGAS_FontMgrImp::VerifyUnicode(CFX_FontDescriptor* pDesc,
+                                     FX_WCHAR wcUnicode) {
   IFX_SeekableReadStream* pFileRead =
       CreateFontStream(pDesc->m_wsFaceName.UTF8Encode());
   if (!pFileRead)
-    return FALSE;
+    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;
+    return false;
   if (FXFT_Get_Face_External_Stream(pFace))
     FXFT_Clear_Face_External_Stream(pFace);
   FXFT_Done_Face(pFace);
   return !retCharmap && retIndex;
 }
 
-FX_BOOL CFGAS_FontMgrImp::VerifyUnicode(CFGAS_GEFont* pFont,
-                                        FX_WCHAR wcUnicode) {
+bool CFGAS_FontMgrImp::VerifyUnicode(CFGAS_GEFont* pFont, FX_WCHAR wcUnicode) {
   if (!pFont)
-    return FALSE;
+    return false;
 
   FXFT_Face pFace = pFont->GetDevFont()->GetFace();
   FXFT_CharMap charmap = FXFT_Get_Face_Charmap(pFace);
   if (FXFT_Select_Charmap(pFace, FXFT_ENCODING_UNICODE) != 0)
-    return FALSE;
+    return false;
 
   if (FXFT_Get_Char_Index(pFace, wcUnicode) == 0) {
     FXFT_Set_Charmap(pFace, charmap);
-    return FALSE;
+    return false;
   }
-  return TRUE;
+  return true;
 }
 
 CFGAS_GEFont* CFGAS_FontMgrImp::GetFontByLanguage(
     uint16_t wLanguage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage), dwFontStyles,
                            pszFontFamily);
 }
 
@@ skipping 100 matching lines @@
   if (!hFont)
     return nullptr;
 
   uint32_t dwFileSize = pSystemFontInfo->GetFontData(hFont, 0, nullptr, 0);
   if (dwFileSize == 0)
     return nullptr;
 
   uint8_t* pBuffer = FX_Alloc(uint8_t, dwFileSize + 1);
   dwFileSize = pSystemFontInfo->GetFontData(hFont, 0, pBuffer, dwFileSize);
 
-  return FX_CreateMemoryStream(pBuffer, dwFileSize, TRUE);
+  return FX_CreateMemoryStream(pBuffer, dwFileSize, true);
 }
 
 IFX_SeekableReadStream* CFGAS_FontMgrImp::CreateFontStream(
     const CFX_ByteString& bsFaceName) {
   CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
   CFX_FontMapper* pFontMapper = pFontMgr->GetBuiltinMapper();
 
   if (!pFontMapper)
     return nullptr;
 
@@ skipping 429 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