Remove FX_BOOL from core

core/fxge/ge/cfx_fontmapper.cpp

 // Copyright 2016 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 "core/fxge/cfx_fontmapper.h"
 
 #include <memory>
 #include <utility>
@@ skipping 240 matching lines @@
       if (bsStyle.Right(pStyle->len).Compare(pStyle->style) == 0)
         return i;
     } else {
       if (bsStyle.Left(pStyle->len).Compare(pStyle->style) == 0)
         return i;
     }
   }
   return -1;
 }
 
-FX_BOOL CheckSupportThirdPartFont(CFX_ByteString name, int& PitchFamily) {
+bool CheckSupportThirdPartFont(CFX_ByteString name, int& PitchFamily) {
   if (name == "MyriadPro") {
     PitchFamily &= ~FXFONT_FF_ROMAN;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 void UpdatePitchFamily(uint32_t flags, int& PitchFamily) {
   if (flags & FXFONT_SERIF)
     PitchFamily |= FXFONT_FF_ROMAN;
   if (flags & FXFONT_SCRIPT)
     PitchFamily |= FXFONT_FF_SCRIPT;
   if (flags & FXFONT_FIXED_PITCH)
     PitchFamily |= FXFONT_FF_FIXEDPITCH;
 }
 
 }  // namespace
 
 CFX_FontMapper::CFX_FontMapper(CFX_FontMgr* mgr)
-    : m_bListLoaded(FALSE), m_pFontMgr(mgr) {
+    : m_bListLoaded(false), m_pFontMgr(mgr) {
   m_MMFaces[0] = nullptr;
   m_MMFaces[1] = nullptr;
   FXSYS_memset(m_FoxitFaces, 0, sizeof(m_FoxitFaces));
 }
 
 CFX_FontMapper::~CFX_FontMapper() {
   for (size_t i = 0; i < FX_ArraySize(m_FoxitFaces); ++i) {
     if (m_FoxitFaces[i])
       FXFT_Done_Face(m_FoxitFaces[i]);
   }
@@ skipping 29 matching lines @@
 
 void CFX_FontMapper::AddInstalledFont(const CFX_ByteString& name, int charset) {
   if (!m_pFontInfo)
     return;
 
   m_FaceArray.push_back({name, static_cast<uint32_t>(charset)});
   if (name == m_LastFamily)
     return;
 
   const uint8_t* ptr = name.raw_str();
-  FX_BOOL bLocalized = FALSE;
+  bool bLocalized = false;
   for (int i = 0; i < name.GetLength(); i++) {
     if (ptr[i] > 0x80) {
-      bLocalized = TRUE;
+      bLocalized = true;
       break;
     }
   }
 
   if (bLocalized) {
     void* hFont = m_pFontInfo->GetFont(name.c_str());
     if (!hFont) {
       int iExact;
       hFont = m_pFontInfo->MapFont(0, 0, FXFONT_DEFAULT_CHARSET, 0,
                                    name.c_str(), iExact);
       if (!hFont)
         return;
     }
 
     CFX_ByteString new_name = GetPSNameFromTT(hFont);
     if (!new_name.IsEmpty())
       m_LocalizedTTFonts.push_back(std::make_pair(new_name, name));
     m_pFontInfo->DeleteFont(hFont);
   }
   m_InstalledTTFonts.push_back(name);
   m_LastFamily = name;
 }
 
 void CFX_FontMapper::LoadInstalledFonts() {
   if (!m_pFontInfo || m_bListLoaded)
     return;
 
   m_pFontInfo->EnumFontList(this);
-  m_bListLoaded = TRUE;
+  m_bListLoaded = true;
 }
 
 CFX_ByteString CFX_FontMapper::MatchInstalledFonts(
     const CFX_ByteString& norm_name) {
   LoadInstalledFonts();
   int i;
   for (i = pdfium::CollectionSize<int>(m_InstalledTTFonts) - 1; i >= 0; i--) {
     CFX_ByteString norm1 = TT_NormalizeName(m_InstalledTTFonts[i].c_str());
     if (norm1 == norm_name)
       return m_InstalledTTFonts[i];
@@ skipping 41 matching lines @@
   if (m_MMFaces[0])
     return m_MMFaces[0];
   const uint8_t* pFontData = nullptr;
   uint32_t size = 0;
   m_pFontMgr->GetBuiltinFont(15, &pFontData, &size);
   m_MMFaces[0] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
   return m_MMFaces[0];
 }
 
 FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name,
-                                        FX_BOOL bTrueType,
+                                        bool bTrueType,
                                         uint32_t flags,
                                         int weight,
                                         int italic_angle,
                                         int WindowCP,
                                         CFX_SubstFont* pSubstFont) {
   if (!(flags & FXFONT_USEEXTERNATTR)) {
     weight = FXFONT_FW_NORMAL;
     italic_angle = 0;
   }
   CFX_ByteString SubstName = name;
@@ skipping 271 matching lines @@
 }
 
 #ifdef PDF_ENABLE_XFA
 FXFT_Face CFX_FontMapper::FindSubstFontByUnicode(uint32_t dwUnicode,
                                                  uint32_t flags,
                                                  int weight,
                                                  int italic_angle) {
   if (!m_pFontInfo)
     return nullptr;
 
-  FX_BOOL bItalic = (flags & FXFONT_ITALIC) != 0;
+  bool bItalic = (flags & FXFONT_ITALIC) != 0;
   int PitchFamily = 0;
   UpdatePitchFamily(flags, PitchFamily);
   void* hFont =
       m_pFontInfo->MapFontByUnicode(dwUnicode, weight, bItalic, PitchFamily);
   if (!hFont)
     return nullptr;
 
   uint32_t ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, nullptr, 0);
   uint32_t font_size = m_pFontInfo->GetFontData(hFont, 0, nullptr, 0);
   if (font_size == 0 && ttc_size == 0) {
@@ skipping 10 matching lines @@
   }
   m_pFontInfo->DeleteFont(hFont);
   return face;
 }
 #endif  // PDF_ENABLE_XFA
 
 int CFX_FontMapper::GetFaceSize() const {
   return pdfium::CollectionSize<int>(m_FaceArray);
 }
 
-FX_BOOL CFX_FontMapper::IsBuiltinFace(const FXFT_Face face) const {
+bool CFX_FontMapper::IsBuiltinFace(const FXFT_Face face) const {
   for (size_t i = 0; i < MM_FACE_COUNT; ++i) {
     if (m_MMFaces[i] == face)
-      return TRUE;
+      return true;
   }
   for (size_t i = 0; i < FOXIT_FACE_COUNT; ++i) {
     if (m_FoxitFaces[i] == face)
-      return TRUE;
+      return true;
   }
-  return FALSE;
+  return false;
 }
 
 FXFT_Face CFX_FontMapper::GetCachedTTCFace(void* hFont,
                                            const uint32_t tableTTCF,
                                            uint32_t ttc_size,
                                            uint32_t font_size) {
   FXFT_Face face;
   uint8_t buffer[1024];
   m_pFontInfo->GetFontData(hFont, tableTTCF, buffer, FX_ArraySize(buffer));
   uint32_t* pBuffer = reinterpret_cast<uint32_t*>(buffer);
   uint32_t checksum = 0;
   for (int i = 0; i < 256; i++)
     checksum += pBuffer[i];
   uint8_t* pFontData;
   face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum, ttc_size - font_size,
                                       pFontData);
   if (!face) {
     pFontData = FX_Alloc(uint8_t, ttc_size);
     m_pFontInfo->GetFontData(hFont, tableTTCF, pFontData, ttc_size);
     face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData, ttc_size,
                                         ttc_size - font_size);
   }
   return face;
 }
 
 FXFT_Face CFX_FontMapper::GetCachedFace(void* hFont,
                                         CFX_ByteString SubstName,
                                         int weight,
-                                        FX_BOOL bItalic,
+                                        bool bItalic,
                                         uint32_t font_size) {
   FXFT_Face face;
   uint8_t* pFontData;
   face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
   if (!face) {
     pFontData = FX_Alloc(uint8_t, font_size);
     m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
     face =
         m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData,
                                   font_size, m_pFontInfo->GetFaceIndex(hFont));
   }
   return face;
 }
 
 int PDF_GetStandardFontName(CFX_ByteString* name) {
   AltFontName* found = static_cast<AltFontName*>(
       FXSYS_bsearch(name->c_str(), g_AltFontNames, FX_ArraySize(g_AltFontNames),
                     sizeof(AltFontName), CompareString));
   if (!found)
     return -1;
 
   *name = g_Base14FontNames[found->m_Index];
   return found->m_Index;
 }