Remove FX_BOOL from cpdf_font

core/fpdfapi/fpdf_font/cpdf_font.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/fpdfapi/fpdf_font/include/cpdf_font.h"
 
 #include <memory>
 #include <vector>
@@ skipping 32 matching lines @@
     *basemap = PDFFONT_ENCODING_MACEXPERT;
   else if (value == "PDFDocEncoding")
     *basemap = PDFFONT_ENCODING_PDFDOC;
 }
 
 }  // namespace
 
 CPDF_Font::CPDF_Font()
     : m_pFontFile(nullptr),
       m_pFontDict(nullptr),
-      m_bToUnicodeLoaded(FALSE),
+      m_bToUnicodeLoaded(false),
       m_Flags(0),
       m_StemV(0),
       m_Ascent(0),
       m_Descent(0),
       m_ItalicAngle(0) {}
 
 CPDF_Font::~CPDF_Font() {
   if (m_pFontFile) {
     m_pDocument->GetPageData()->ReleaseFontFileStreamAcc(
         m_pFontFile->GetStream()->AsStream());
@@ skipping 41 matching lines @@
 }
 
 const CPDF_CIDFont* CPDF_Font::AsCIDFont() const {
   return nullptr;
 }
 
 CPDF_CIDFont* CPDF_Font::AsCIDFont() {
   return nullptr;
 }
 
-FX_BOOL CPDF_Font::IsUnicodeCompatible() const {
-  return FALSE;
+bool CPDF_Font::IsUnicodeCompatible() const {
+  return false;
 }
 
 int CPDF_Font::CountChar(const FX_CHAR* pString, int size) const {
   return size;
 }
 
 int CPDF_Font::GetCharSize(uint32_t charcode) const {
   return 1;
 }
 
 int CPDF_Font::GlyphFromCharCodeExt(uint32_t charcode) {
   return GlyphFromCharCode(charcode, nullptr);
 }
 
-FX_BOOL CPDF_Font::IsVertWriting() const {
+bool CPDF_Font::IsVertWriting() const {
   const CPDF_CIDFont* pCIDFont = AsCIDFont();
   return pCIDFont ? pCIDFont->IsVertWriting() : m_Font.IsVertical();
 }
 
 int CPDF_Font::AppendChar(FX_CHAR* buf, uint32_t charcode) const {
   *buf = static_cast<FX_CHAR>(charcode);
   return 1;
 }
 
 void CPDF_Font::AppendChar(CFX_ByteString& str, uint32_t charcode) const {
@@ skipping 127 matching lines @@
   }
   if (m_Ascent == 0 && m_Descent == 0) {
     FX_RECT rect = GetCharBBox('A');
     m_Ascent = rect.bottom == rect.top ? m_FontBBox.top : rect.top;
     rect = GetCharBBox('g');
     m_Descent = rect.bottom == rect.top ? m_FontBBox.bottom : rect.bottom;
   }
 }
 
 void CPDF_Font::LoadUnicodeMap() const {
-  m_bToUnicodeLoaded = TRUE;
+  m_bToUnicodeLoaded = true;
   CPDF_Stream* pStream = m_pFontDict->GetStreamFor("ToUnicode");
   if (!pStream) {
     return;
   }
   m_pToUnicodeMap.reset(new CPDF_ToUnicodeMap);
   m_pToUnicodeMap->Load(pStream);
 }
 
 int CPDF_Font::GetStringWidth(const FX_CHAR* pString, int size) {
   int offset = 0;
@@ skipping 61 matching lines @@
   if (offset < 0 || nStrLen < 1) {
     return 0;
   }
   uint8_t ch = offset < nStrLen ? pString[offset++] : pString[nStrLen - 1];
   return static_cast<uint32_t>(ch);
 }
 
 void CPDF_Font::LoadPDFEncoding(CPDF_Object* pEncoding,
                                 int& iBaseEncoding,
                                 std::vector<CFX_ByteString>* pCharNames,
-                                FX_BOOL bEmbedded,
-                                FX_BOOL bTrueType) {
+                                bool bEmbedded,
+                                bool bTrueType) {
   if (!pEncoding) {
     if (m_BaseFont == "Symbol") {
       iBaseEncoding = bTrueType ? PDFFONT_ENCODING_MS_SYMBOL
                                 : PDFFONT_ENCODING_ADOBE_SYMBOL;
     } else if (!bEmbedded && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
       iBaseEncoding = PDFFONT_ENCODING_WINANSI;
     }
     return;
   }
   if (pEncoding->IsName()) {
@@ skipping 44 matching lines @@
     if (CPDF_Name* pName = pElement->AsName()) {
       if (cur_code < 256)
         (*pCharNames)[cur_code] = pName->GetString();
       cur_code++;
     } else {
       cur_code = pElement->GetInteger();
     }
   }
 }
 
-FX_BOOL CPDF_Font::IsStandardFont() const {
+bool CPDF_Font::IsStandardFont() const {
   if (!IsType1Font())
-    return FALSE;
+    return false;
   if (m_pFontFile)
-    return FALSE;
+    return false;
   if (AsType1Font()->GetBase14Font() < 0)
-    return FALSE;
-  return TRUE;
+    return false;
+  return true;
 }
 
 const FX_CHAR* CPDF_Font::GetAdobeCharName(
     int iBaseEncoding,
     const std::vector<CFX_ByteString>& charnames,
     int charcode) {
   if (charcode < 0 || charcode >= 256) {
     ASSERT(false);
     return nullptr;
   }
@@ skipping 21 matching lines @@
   if (fallbackFont < 0 ||
       fallbackFont >= pdfium::CollectionSize<int>(m_FontFallbacks)) {
     return -1;
   }
   int glyph =
       FXFT_Get_Char_Index(m_FontFallbacks[fallbackFont]->GetFace(), charcode);
   if (glyph == 0 || glyph == 0xffff)
     return -1;
   return glyph;
 }