Remove FX_BOOL from core

core/fxge/ge/cfx_font.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 "core/fxge/fx_font.h"
 
 #include "core/fpdfapi/font/cpdf_font.h"
 #include "core/fxge/cfx_facecache.h"
 #include "core/fxge/cfx_fontcache.h"
 #include "core/fxge/cfx_fontmgr.h"
 #include "core/fxge/cfx_gemodule.h"
 #include "core/fxge/cfx_pathdata.h"
 #include "core/fxge/cfx_substfont.h"
 #include "core/fxge/fx_freetype.h"
 #include "core/fxge/ge/fx_text_int.h"
 #include "third_party/base/ptr_util.h"
 
 #define EM_ADJUST(em, a) (em == 0 ? (a) : (a)*1000 / em)
 
 namespace {
 
 typedef struct {
-  FX_BOOL m_bCount;
+  bool m_bCount;
   int m_PointCount;
   FX_PATHPOINT* m_pPoints;
   int m_CurX;
   int m_CurY;
   FX_FLOAT m_CoordUnit;
 } OUTLINE_PARAMS;
 
 #ifdef PDF_ENABLE_XFA
 
 unsigned long FTStreamRead(FXFT_Stream stream,
                            unsigned long offset,
                            unsigned char* buffer,
                            unsigned long count) {
   if (count == 0)
     return 0;
 
   IFX_SeekableReadStream* pFile =
       static_cast<IFX_SeekableReadStream*>(stream->descriptor.pointer);
   return pFile->ReadBlock(buffer, offset, count) ? count : 0;
 }
 
 void FTStreamClose(FXFT_Stream stream) {}
 
-FX_BOOL LoadFileImp(FXFT_Library library,
-                    FXFT_Face* Face,
-                    IFX_SeekableReadStream* pFile,
-                    int32_t faceIndex,
-                    std::unique_ptr<FXFT_StreamRec>* stream) {
+bool LoadFileImp(FXFT_Library library,
+                 FXFT_Face* Face,
+                 IFX_SeekableReadStream* pFile,
+                 int32_t faceIndex,
+                 std::unique_ptr<FXFT_StreamRec>* stream) {
   std::unique_ptr<FXFT_StreamRec> stream1(new FXFT_StreamRec());
   stream1->base = nullptr;
   stream1->size = static_cast<unsigned long>(pFile->GetSize());
   stream1->pos = 0;
   stream1->descriptor.pointer = pFile;
   stream1->close = FTStreamClose;
   stream1->read = FTStreamRead;
   FXFT_Open_Args args;
   args.flags = FT_OPEN_STREAM;
   args.stream = stream1.get();
   if (FXFT_Open_Face(library, &args, faceIndex, Face))
-    return FALSE;
+    return false;
   if (stream)
     *stream = std::move(stream1);
-  return TRUE;
+  return true;
 }
 #endif  // PDF_ENABLE_XFA
 
 FXFT_Face FT_LoadFont(const uint8_t* pData, int size) {
   return CFX_GEModule::Get()->GetFontMgr()->GetFixedFace(pData, size, 0);
 }
 
 void Outline_CheckEmptyContour(OUTLINE_PARAMS* param) {
   if (param->m_PointCount >= 2 &&
       param->m_pPoints[param->m_PointCount - 2].m_Flag == FXPT_MOVETO &&
@@ skipping 154 matching lines @@
       m_pGsubData(nullptr),
       m_dwSize(0),
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       m_pPlatformFont(nullptr),
 #endif
       m_bEmbedded(false),
       m_bVertical(false) {
 }
 
 #ifdef PDF_ENABLE_XFA
-FX_BOOL CFX_Font::LoadClone(const CFX_Font* pFont) {
+bool CFX_Font::LoadClone(const CFX_Font* pFont) {
   if (!pFont)
-    return FALSE;
+    return false;
 
   m_bShallowCopy = true;
   if (pFont->m_pSubstFont) {
     m_pSubstFont = pdfium::MakeUnique<CFX_SubstFont>();
     m_pSubstFont->m_Charset = pFont->m_pSubstFont->m_Charset;
     m_pSubstFont->m_SubstFlags = pFont->m_pSubstFont->m_SubstFlags;
     m_pSubstFont->m_Weight = pFont->m_pSubstFont->m_Weight;
     m_pSubstFont->m_Family = pFont->m_pSubstFont->m_Family;
     m_pSubstFont->m_ItalicAngle = pFont->m_pSubstFont->m_ItalicAngle;
   }
   if (pFont->m_OtfFontData.GetSize()) {
     m_OtfFontData.AttachData(pFont->m_OtfFontData.GetBuffer(),
                              pFont->m_OtfFontData.GetSize());
   }
   m_Face = pFont->m_Face;
   m_bEmbedded = pFont->m_bEmbedded;
   m_bVertical = pFont->m_bVertical;
   m_dwSize = pFont->m_dwSize;
   m_pFontData = pFont->m_pFontData;
   m_pGsubData = pFont->m_pGsubData;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
   m_pPlatformFont = pFont->m_pPlatformFont;
 #endif
   m_pOwnedStream = pFont->m_pOwnedStream;
   m_FaceCache = pFont->GetFaceCache();
-  return TRUE;
+  return true;
 }
 
 void CFX_Font::SetFace(FXFT_Face face) {
   ClearFaceCache();
   m_Face = face;
 }
 
 #endif  // PDF_ENABLE_XFA
 
 CFX_Font::~CFX_Font() {
@@ skipping 24 matching lines @@
   ClearFaceCache();
   if (m_bEmbedded) {
     FXFT_Done_Face(m_Face);
   } else {
     CFX_GEModule::Get()->GetFontMgr()->ReleaseFace(m_Face);
   }
   m_Face = nullptr;
 }
 
 void CFX_Font::LoadSubst(const CFX_ByteString& face_name,
-                         FX_BOOL bTrueType,
+                         bool bTrueType,
                          uint32_t flags,
                          int weight,
                          int italic_angle,
                          int CharsetCP,
                          bool bVertical) {
   m_bEmbedded = false;
   m_bVertical = bVertical;
   m_pSubstFont = pdfium::MakeUnique<CFX_SubstFont>();
   m_Face = CFX_GEModule::Get()->GetFontMgr()->FindSubstFont(
       face_name, bTrueType, flags, weight, italic_angle, CharsetCP,
       m_pSubstFont.get());
   if (m_Face) {
     m_pFontData = FXFT_Get_Face_Stream_Base(m_Face);
     m_dwSize = FXFT_Get_Face_Stream_Size(m_Face);
   }
 }
 
 #ifdef PDF_ENABLE_XFA
-FX_BOOL CFX_Font::LoadFile(IFX_SeekableReadStream* pFile,
-                           int nFaceIndex,
-                           int* pFaceCount) {
-  m_bEmbedded = FALSE;
+bool CFX_Font::LoadFile(IFX_SeekableReadStream* pFile,
+                        int nFaceIndex,
+                        int* pFaceCount) {
+  m_bEmbedded = false;
 
   CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
   pFontMgr->InitFTLibrary();
   FXFT_Library library = pFontMgr->GetFTLibrary();
 
   std::unique_ptr<FXFT_StreamRec> stream;
   if (!LoadFileImp(library, &m_Face, pFile, nFaceIndex, &stream))
-    return FALSE;
+    return false;
 
   if (pFaceCount)
     *pFaceCount = (int)m_Face->num_faces;
   m_pOwnedStream = stream.release();
   FXFT_Set_Pixel_Sizes(m_Face, 0, 64);
-  return TRUE;
+  return true;
 }
 #endif  // PDF_ENABLE_XFA
 
 int CFX_Font::GetGlyphWidth(uint32_t glyph_index) {
   if (!m_Face)
     return 0;
   if (m_pSubstFont && (m_pSubstFont->m_SubstFlags & FXFONT_SUBST_MM))
     AdjustMMParams(glyph_index, 0, 0);
   int err = FXFT_Load_Glyph(
       m_Face, glyph_index,
       FXFT_LOAD_NO_SCALE | FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH);
   if (err)
     return 0;
   int width = EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face),
                         FXFT_Get_Glyph_HoriAdvance(m_Face));
   return width;
 }
 
-FX_BOOL CFX_Font::LoadEmbedded(const uint8_t* data, uint32_t size) {
+bool CFX_Font::LoadEmbedded(const uint8_t* data, uint32_t size) {
   std::vector<uint8_t> temp(data, data + size);
   m_pFontDataAllocation.swap(temp);
   m_Face = FT_LoadFont(m_pFontDataAllocation.data(), size);
   m_pFontData = m_pFontDataAllocation.data();
   m_bEmbedded = true;
   m_dwSize = size;
   return !!m_Face;
 }
 
 bool CFX_Font::IsTTFont() const {
   if (!m_Face)
     return false;
   return FXFT_Is_Face_TT_OT(m_Face) == FXFT_FACE_FLAG_SFNT;
 }
 
 int CFX_Font::GetAscent() const {
   if (!m_Face)
     return 0;
   return EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face),
                    FXFT_Get_Face_Ascender(m_Face));
 }
 
 int CFX_Font::GetDescent() const {
   if (!m_Face)
     return 0;
   return EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face),
                    FXFT_Get_Face_Descender(m_Face));
 }
 
-FX_BOOL CFX_Font::GetGlyphBBox(uint32_t glyph_index, FX_RECT& bbox) {
+bool CFX_Font::GetGlyphBBox(uint32_t glyph_index, FX_RECT& bbox) {
   if (!m_Face)
-    return FALSE;
+    return false;
 
   if (FXFT_Is_Face_Tricky(m_Face)) {
     int error = FXFT_Set_Char_Size(m_Face, 0, 1000 * 64, 72, 72);
     if (error)
-      return FALSE;
+      return false;
     error = FXFT_Load_Glyph(m_Face, glyph_index,
                             FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH);
     if (error)
-      return FALSE;
+      return false;
     FXFT_BBox cbox;
     FT_Glyph glyph;
     error = FXFT_Get_Glyph(((FXFT_Face)m_Face)->glyph, &glyph);
     if (error)
-      return FALSE;
+      return false;
     FXFT_Glyph_Get_CBox(glyph, FXFT_GLYPH_BBOX_PIXELS, &cbox);
     int pixel_size_x = ((FXFT_Face)m_Face)->size->metrics.x_ppem,
         pixel_size_y = ((FXFT_Face)m_Face)->size->metrics.y_ppem;
     if (pixel_size_x == 0 || pixel_size_y == 0) {
       bbox.left = cbox.xMin;
       bbox.right = cbox.xMax;
       bbox.top = cbox.yMax;
       bbox.bottom = cbox.yMin;
     } else {
       bbox.left = cbox.xMin * 1000 / pixel_size_x;
       bbox.right = cbox.xMax * 1000 / pixel_size_x;
       bbox.top = cbox.yMax * 1000 / pixel_size_y;
       bbox.bottom = cbox.yMin * 1000 / pixel_size_y;
     }
     if (bbox.top > FXFT_Get_Face_Ascender(m_Face))
       bbox.top = FXFT_Get_Face_Ascender(m_Face);
     if (bbox.bottom < FXFT_Get_Face_Descender(m_Face))
       bbox.bottom = FXFT_Get_Face_Descender(m_Face);
     FT_Done_Glyph(glyph);
     return FXFT_Set_Pixel_Sizes(m_Face, 0, 64) == 0;
   }
   if (FXFT_Load_Glyph(
           m_Face, glyph_index,
           FXFT_LOAD_NO_SCALE | FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH)) {
-    return FALSE;
+    return false;
   }
   int em = FXFT_Get_Face_UnitsPerEM(m_Face);
   if (em == 0) {
     bbox.left = FXFT_Get_Glyph_HoriBearingX(m_Face);
     bbox.bottom = FXFT_Get_Glyph_HoriBearingY(m_Face);
     bbox.top = bbox.bottom - FXFT_Get_Glyph_Height(m_Face);
     bbox.right = bbox.left + FXFT_Get_Glyph_Width(m_Face);
   } else {
     bbox.left = FXFT_Get_Glyph_HoriBearingX(m_Face) * 1000 / em;
     bbox.top =
         (FXFT_Get_Glyph_HoriBearingY(m_Face) - FXFT_Get_Glyph_Height(m_Face)) *
         1000 / em;
     bbox.right =
         (FXFT_Get_Glyph_HoriBearingX(m_Face) + FXFT_Get_Glyph_Width(m_Face)) *
         1000 / em;
     bbox.bottom = (FXFT_Get_Glyph_HoriBearingY(m_Face)) * 1000 / em;
   }
-  return TRUE;
+  return true;
 }
 
 bool CFX_Font::IsItalic() const {
   if (!m_Face)
     return false;
 
   if (FXFT_Is_Face_Italic(m_Face) == FXFT_STYLE_FLAG_ITALIC)
     return true;
   CFX_ByteString str(FXFT_Get_Face_Style_Name(m_Face));
   str.MakeLower();
@@ skipping 39 matching lines @@
     facename = GetFamilyName();
     if (facename.IsEmpty())
       facename = "Untitled";
     if (!style.IsEmpty() && style != "Regular")
       facename += " " + style;
     return facename;
   }
   return m_pSubstFont->m_Family;
 }
 
-FX_BOOL CFX_Font::GetBBox(FX_RECT& bbox) {
+bool CFX_Font::GetBBox(FX_RECT& bbox) {
   if (!m_Face)
-    return FALSE;
+    return false;
   int em = FXFT_Get_Face_UnitsPerEM(m_Face);
   if (em == 0) {
     bbox.left = FXFT_Get_Face_xMin(m_Face);
     bbox.bottom = FXFT_Get_Face_yMax(m_Face);
     bbox.top = FXFT_Get_Face_yMin(m_Face);
     bbox.right = FXFT_Get_Face_xMax(m_Face);
   } else {
     bbox.left = FXFT_Get_Face_xMin(m_Face) * 1000 / em;
     bbox.top = FXFT_Get_Face_yMin(m_Face) * 1000 / em;
     bbox.right = FXFT_Get_Face_xMax(m_Face) * 1000 / em;
     bbox.bottom = FXFT_Get_Face_yMax(m_Face) * 1000 / em;
   }
-  return TRUE;
+  return true;
 }
 
 int CFX_Font::GetHeight() const {
   if (!m_Face)
     return 0;
 
   return EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face),
                    FXFT_Get_Face_Height(m_Face));
 }
 
@@ skipping 121 matching lines @@
     FXFT_Outline_Embolden(FXFT_Get_Glyph_Outline(m_Face), level);
   }
   FXFT_Outline_Funcs funcs;
   funcs.move_to = Outline_MoveTo;
   funcs.line_to = Outline_LineTo;
   funcs.conic_to = Outline_ConicTo;
   funcs.cubic_to = Outline_CubicTo;
   funcs.shift = 0;
   funcs.delta = 0;
   OUTLINE_PARAMS params;
-  params.m_bCount = TRUE;
+  params.m_bCount = true;
   params.m_PointCount = 0;
   FXFT_Outline_Decompose(FXFT_Get_Glyph_Outline(m_Face), &funcs, &params);
   if (params.m_PointCount == 0)
     return nullptr;
   CFX_PathData* pPath = new CFX_PathData;
   pPath->SetPointCount(params.m_PointCount);
-  params.m_bCount = FALSE;
+  params.m_bCount = false;
   params.m_PointCount = 0;
   params.m_pPoints = pPath->GetPoints();
   params.m_CurX = params.m_CurY = 0;
   params.m_CoordUnit = 64 * 64.0;
   FXFT_Outline_Decompose(FXFT_Get_Glyph_Outline(m_Face), &funcs, &params);
   Outline_CheckEmptyContour(&params);
   pPath->TrimPoints(params.m_PointCount);
   if (params.m_PointCount)
     pPath->GetPoints()[params.m_PointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
   return pPath;
 }
 
 const CFX_GlyphBitmap* CFX_Font::LoadGlyphBitmap(uint32_t glyph_index,
-                                                 FX_BOOL bFontStyle,
+                                                 bool bFontStyle,
                                                  const CFX_Matrix* pMatrix,
                                                  int dest_width,
                                                  int anti_alias,
                                                  int& text_flags) const {
   return GetFaceCache()->LoadGlyphBitmap(this, glyph_index, bFontStyle, pMatrix,
                                          dest_width, anti_alias, text_flags);
 }
 
 const CFX_PathData* CFX_Font::LoadGlyphPath(uint32_t glyph_index,
                                             int dest_width) const {
   return GetFaceCache()->LoadGlyphPath(this, glyph_index, dest_width);
 }
 
 #ifdef _SKIA_SUPPORT_
 CFX_TypeFace* CFX_Font::GetDeviceCache() const {
   return GetFaceCache()->GetDeviceCache(this);
 }
 #endif