Remove FX_BOOL from core

core/fxge/apple/fx_quartz_device.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/fxcrt/fx_ext.h"
 
 #ifndef _SKIA_SUPPORT_
 #include "core/fxge/agg/fx_agg_driver.h"
@@ skipping 57 matching lines @@
 void CQuartz2D::setGraphicsTextMatrix(void* graphics, CFX_Matrix* matrix) {
   if (!graphics || !matrix) {
     return;
   }
   CGContextRef context = (CGContextRef)graphics;
   CGFloat ty = CGBitmapContextGetHeight(context) - matrix->f;
   CGContextSetTextMatrix(
       context, CGAffineTransformMake(matrix->a, matrix->b, matrix->c, matrix->d,
                                      matrix->e, ty));
 }
-FX_BOOL CQuartz2D::drawGraphicsString(void* graphics,
-                                      void* font,
-                                      FX_FLOAT fontSize,
-                                      uint16_t* glyphIndices,
-                                      CGPoint* glyphPositions,
-                                      int32_t charsCount,
-                                      FX_ARGB argb,
-                                      CFX_Matrix* matrix) {
+bool CQuartz2D::drawGraphicsString(void* graphics,
+                                   void* font,
+                                   FX_FLOAT fontSize,
+                                   uint16_t* glyphIndices,
+                                   CGPoint* glyphPositions,
+                                   int32_t charsCount,
+                                   FX_ARGB argb,
+                                   CFX_Matrix* matrix) {
   if (!graphics) {
-    return FALSE;
+    return false;
   }
   CGContextRef context = (CGContextRef)graphics;
   CGContextSetFont(context, (CGFontRef)font);
   CGContextSetFontSize(context, fontSize);
   if (matrix) {
     CGAffineTransform m = CGContextGetTextMatrix(context);
     m = CGAffineTransformConcat(
         m, CGAffineTransformMake(matrix->a, matrix->b, matrix->c, matrix->d,
                                  matrix->e, matrix->f));
     CGContextSetTextMatrix(context, m);
@@ skipping 10 matching lines @@
   }
 #else
   CGPoint* glyphPositionsCG = (CGPoint*)glyphPositions;
 #endif
   CGContextShowGlyphsAtPositions(context, (CGGlyph*)glyphIndices,
                                  glyphPositionsCG, charsCount);
 #if CGFLOAT_IS_DOUBLE
   delete[] glyphPositionsCG;
 #endif
   CGContextRestoreGState(context);
-  return TRUE;
+  return true;
 }
 void CQuartz2D::saveGraphicsState(void* graphics) {
   if (graphics) {
     CGContextSaveGState((CGContextRef)graphics);
   }
 }
 void CQuartz2D::restoreGraphicsState(void* graphics) {
   if (graphics) {
     CGContextRestoreGState((CGContextRef)graphics);
   }
@@ skipping 93 matching lines @@
 
 void CFX_QuartzDeviceDriver::RestoreState(bool isKeepSaved) {
   CGContextRestoreGState(m_context);
   if (isKeepSaved) {
     CGContextSaveGState(m_context);
   } else {
     m_saveCount--;
   }
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData* pathData,
-                                                 const CFX_Matrix* matrix,
-                                                 int fillMode) {
+bool CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData* pathData,
+                                              const CFX_Matrix* matrix,
+                                              int fillMode) {
   SaveState();
   CGAffineTransform m = CGAffineTransformIdentity;
   if (matrix) {
     m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(),
                               matrix->GetD(), matrix->GetE(), matrix->GetF());
   }
   m = CGAffineTransformConcat(m, m_foxitDevice2User);
   CGContextConcatCTM(m_context, m);
   setPathToContext(pathData);
   RestoreState(false);
   if ((fillMode & 3) == FXFILL_WINDING) {
     CGContextClip(m_context);
   } else {
     CGContextEOClip(m_context);
   }
-  return TRUE;
+  return true;
 }
 FX_FLOAT CFX_QuartzDeviceDriver::getLineWidth(
     const CFX_GraphStateData* graphState,
     CGAffineTransform ctm) {
   FX_FLOAT lineWidth = graphState->m_LineWidth;
   if (graphState->m_LineWidth <= 0.f) {
     CGSize size;
     size.width = 1;
     size.height = 1;
     CGSize temp = CGSizeApplyAffineTransform(size, ctm);
     CGFloat x = 1 / temp.width;
     CGFloat y = 1 / temp.height;
     lineWidth = x > y ? x : y;
   }
   return lineWidth;
 }
-FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathStroke(
+bool CFX_QuartzDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pathData,
     const CFX_Matrix* matrix,
     const CFX_GraphStateData* graphState) {
   SaveState();
   CGAffineTransform m = CGAffineTransformIdentity;
   if (matrix) {
     m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(),
                               matrix->GetD(), matrix->GetE(), matrix->GetF());
   }
   m = CGAffineTransformConcat(m, m_foxitDevice2User);
   CGContextConcatCTM(m_context, m);
   FX_FLOAT lineWidth = getLineWidth(graphState, m);
   setStrokeInfo(graphState, 0xFF000000, lineWidth);
   setPathToContext(pathData);
   CGContextReplacePathWithStrokedPath(m_context);
   RestoreState(false);
   CGContextClip(m_context);
-  return TRUE;
+  return true;
 }
 static CGBlendMode GetCGBlendMode(int blend_type) {
   CGBlendMode mode = kCGBlendModeNormal;
   switch (blend_type) {
     case FXDIB_BLEND_NORMAL:
       mode = kCGBlendModeNormal;
       break;
     case FXDIB_BLEND_MULTIPLY:
       mode = kCGBlendModeMultiply;
       break;
@@ skipping 39 matching lines @@
     case FXDIB_BLEND_LUMINOSITY:
       mode = kCGBlendModeLuminosity;
       break;
     default:
       mode = kCGBlendModeNormal;
       break;
   }
   return mode;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData* pathData,
-                                         const CFX_Matrix* matrix,
-                                         const CFX_GraphStateData* graphState,
-                                         uint32_t fillArgb,
-                                         uint32_t strokeArgb,
-                                         int fillMode,
-                                         int blend_type) {
+bool CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData* pathData,
+                                      const CFX_Matrix* matrix,
+                                      const CFX_GraphStateData* graphState,
+                                      uint32_t fillArgb,
+                                      uint32_t strokeArgb,
+                                      int fillMode,
+                                      int blend_type) {
   SaveState();
   CGBlendMode mode = GetCGBlendMode(blend_type);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, mode);
   }
   CGAffineTransform m = CGAffineTransformIdentity;
   if (matrix) {
     m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(),
                               matrix->GetD(), matrix->GetE(), matrix->GetF());
   }
@@ skipping 23 matching lines @@
   } else if (pathMode == 1) {
     CGContextFillPath(m_context);
   } else if (pathMode == 2) {
     CGContextEOFillPath(m_context);
   } else if (pathMode == 5) {
     CGContextDrawPath(m_context, kCGPathFillStroke);
   } else if (pathMode == 6) {
     CGContextDrawPath(m_context, kCGPathEOFillStroke);
   }
   RestoreState(false);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::FillRectWithBlend(const FX_RECT* rect,
-                                                  FX_ARGB fillArgb,
-                                                  int blend_type) {
+bool CFX_QuartzDeviceDriver::FillRectWithBlend(const FX_RECT* rect,
+                                               FX_ARGB fillArgb,
+                                               int blend_type) {
   CGBlendMode mode = GetCGBlendMode(blend_type);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, mode);
   }
   CGRect rect_fx =
       CGRectMake(rect->left, rect->top, rect->Width(), rect->Height());
   CGRect rect_usr = CGRectApplyAffineTransform(rect_fx, m_foxitDevice2User);
   int32_t a, r, g, b;
   ArgbDecode(fillArgb, a, r, g, b);
   CGContextSetRGBFillColor(m_context, r / 255.f, g / 255.f, b / 255.f,
                            a / 255.f);
   CGContextFillRect(m_context, rect_usr);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, kCGBlendModeNormal);
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
-                                                 FX_FLOAT y1,
-                                                 FX_FLOAT x2,
-                                                 FX_FLOAT y2,
-                                                 uint32_t argb,
-                                                 int blend_type) {
+bool CFX_QuartzDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
+                                              FX_FLOAT y1,
+                                              FX_FLOAT x2,
+                                              FX_FLOAT y2,
+                                              uint32_t argb,
+                                              int blend_type) {
   CGBlendMode mode = GetCGBlendMode(blend_type);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, mode);
   }
   CGPoint pt =
       CGPointApplyAffineTransform(CGPointMake(x1, y1), m_foxitDevice2User);
   x1 = pt.x;
   y1 = pt.y;
   pt = CGPointApplyAffineTransform(CGPointMake(x2, y2), m_foxitDevice2User);
   x2 = pt.x;
   y2 = pt.y;
   int32_t a, r, g, b;
   ArgbDecode(argb, a, r, g, b);
   CGContextSetRGBStrokeColor(m_context, r / 255.f, g / 255.f, b / 255.f,
                              a / 255.f);
   CGContextMoveToPoint(m_context, x1, y1);
   CGContextAddLineToPoint(m_context, x2, y2);
   CGContextStrokePath(m_context);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, kCGBlendModeNormal);
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::GetClipBox(FX_RECT* rect) {
+bool CFX_QuartzDeviceDriver::GetClipBox(FX_RECT* rect) {
   CGRect r = CGContextGetClipBoundingBox(m_context);
   r = CGRectApplyAffineTransform(r, m_user2FoxitDevice);
   rect->left = FXSYS_floor(r.origin.x);
   rect->top = FXSYS_floor(r.origin.y);
   rect->right = FXSYS_ceil(r.origin.x + r.size.width);
   rect->bottom = FXSYS_ceil(r.origin.y + r.size.height);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap* bitmap,
-                                          int32_t left,
-                                          int32_t top) {
+bool CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap* bitmap,
+                                       int32_t left,
+                                       int32_t top) {
   if (FXDC_PRINTER == m_deviceClass || bitmap->GetBPP() < 32 ||
       !(m_renderCaps | FXRC_GET_BITS)) {
-    return FALSE;
+    return false;
   }
 
   CGPoint pt = CGPointMake(left, top);
   pt = CGPointApplyAffineTransform(pt, m_foxitDevice2User);
   CGAffineTransform ctm = CGContextGetCTM(m_context);
   pt.x *= FXSYS_fabs(ctm.a);
   pt.y *= FXSYS_fabs(ctm.d);
   CGImageRef image = CGBitmapContextCreateImage(m_context);
   if (!image)
-    return FALSE;
+    return false;
 
   CGFloat width = (CGFloat)bitmap->GetWidth();
   CGFloat height = (CGFloat)bitmap->GetHeight();
   if (width + pt.x > m_width)
     width -= (width + pt.x - m_width);
   if (height + pt.y > m_height)
     height -= (height + pt.y - m_height);
 
   CGImageRef subImage = CGImageCreateWithImageInRect(
       image, CGRectMake(pt.x, pt.y, width, height));
   CGContextRef context = createContextWithBitmap(bitmap);
   CGRect rect = CGContextGetClipBoundingBox(context);
   CGContextClearRect(context, rect);
   CGContextDrawImage(context, rect, subImage);
   CGContextRelease(context);
   CGImageRelease(subImage);
   CGImageRelease(image);
   if (!bitmap->HasAlpha())
-    return TRUE;
+    return true;
 
   for (int row = 0; row < bitmap->GetHeight(); row++) {
     uint8_t* pScanline = (uint8_t*)bitmap->GetScanline(row);
     for (int col = 0; col < bitmap->GetWidth(); col++) {
       if (pScanline[3] > 0) {
         pScanline[0] = (pScanline[0] * 255.f / pScanline[3] + .5f);
         pScanline[1] = (pScanline[1] * 255.f / pScanline[3] + .5f);
         pScanline[2] = (pScanline[2] * 255.f / pScanline[3] + .5f);
       }
       pScanline += 4;
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
-                                          FX_ARGB argb,
-                                          const FX_RECT* srcRect,
-                                          int dest_left,
-                                          int dest_top,
-                                          int blendType) {
+bool CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
+                                       FX_ARGB argb,
+                                       const FX_RECT* srcRect,
+                                       int dest_left,
+                                       int dest_top,
+                                       int blendType) {
   SaveState();
   CGFloat src_left, src_top, src_width, src_height;
   if (srcRect) {
     src_left = srcRect->left;
     src_top = srcRect->top;
     src_width = srcRect->Width();
     src_height = srcRect->Height();
   } else {
     src_left = src_top = 0;
     src_width = pBitmap->GetWidth();
@@ skipping 17 matching lines @@
   CG_SetImageTransform(dest_left, dest_top, src_width, src_height, &rect_usr);
   CFX_DIBitmap* pBitmap1 = nullptr;
   if (pBitmap->IsAlphaMask()) {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
     if (!pBitmap1) {
       RestoreState(false);
-      return FALSE;
+      return false;
     }
     CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(
         nullptr, pBitmap1->GetBuffer(),
         pBitmap1->GetPitch() * pBitmap1->GetHeight(), nullptr);
     CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
     CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
     CGImageRef pImage = CGImageCreate(
         pBitmap1->GetWidth(), pBitmap1->GetHeight(), pBitmap1->GetBPP(),
         pBitmap1->GetBPP(), pBitmap1->GetPitch(), pColorSpace, bitmapInfo,
         pBitmapProvider, nullptr, true, kCGRenderingIntentDefault);
     CGContextClipToMask(m_context, rect_usr, pImage);
     CGContextSetRGBFillColor(m_context, FXARGB_R(argb) / 255.f,
                              FXARGB_G(argb) / 255.f, FXARGB_B(argb) / 255.f,
                              FXARGB_A(argb) / 255.f);
     CGContextFillRect(m_context, rect_usr);
     CGImageRelease(pImage);
     CGColorSpaceRelease(pColorSpace);
     CGDataProviderRelease(pBitmapProvider);
     if (pBitmap1 != pBitmap) {
       delete pBitmap1;
     }
     RestoreState(false);
-    return TRUE;
+    return true;
   }
   if (pBitmap->GetBPP() < 32) {
     pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
   } else {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
   }
   if (!pBitmap1) {
     RestoreState(false);
-    return FALSE;
+    return false;
   }
   if (pBitmap1->HasAlpha()) {
     if (pBitmap1 == pBitmap) {
       pBitmap1 = pBitmap->Clone();
       if (!pBitmap1) {
         RestoreState(false);
-        return FALSE;
+        return false;
       }
     }
     for (int row = 0; row < pBitmap1->GetHeight(); row++) {
       uint8_t* pScanline = (uint8_t*)pBitmap1->GetScanline(row);
       for (int col = 0; col < pBitmap1->GetWidth(); col++) {
         pScanline[0] = (uint8_t)(pScanline[0] * pScanline[3] / 255.f + .5f);
         pScanline[1] = (uint8_t)(pScanline[1] * pScanline[3] / 255.f + .5f);
         pScanline[2] = (uint8_t)(pScanline[2] * pScanline[3] / 255.f + .5f);
         pScanline += 4;
       }
@@ skipping 13 matching lines @@
     blend_mode = kCGBlendModeNormal;
   }
   CGContextSetBlendMode(m_context, (CGBlendMode)blend_mode);
   CGContextDrawImage(m_context, rect_usr, image);
   CGImageRelease(image);
   CGContextRelease(ctx);
   if (pBitmap1 != pBitmap) {
     delete pBitmap1;
   }
   RestoreState(false);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource* pBitmap,
-                                              FX_ARGB argb,
-                                              int dest_left,
-                                              int dest_top,
-                                              int dest_width,
-                                              int dest_height,
-                                              const FX_RECT* clipRect,
-                                              uint32_t flags,
-                                              int blend_type) {
+bool CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource* pBitmap,
+                                           FX_ARGB argb,
+                                           int dest_left,
+                                           int dest_top,
+                                           int dest_width,
+                                           int dest_height,
+                                           const FX_RECT* clipRect,
+                                           uint32_t flags,
+                                           int blend_type) {
   SaveState();
   if (clipRect) {
     CGContextBeginPath(m_context);
     CGRect rect_clip = CGRectMake(clipRect->left, clipRect->top,
                                   clipRect->Width(), clipRect->Height());
     rect_clip = CGRectApplyAffineTransform(rect_clip, m_foxitDevice2User);
     CGContextAddRect(m_context, rect_clip);
     CGContextClip(m_context);
   }
   CGRect rect = CGRectMake(dest_left, dest_top, dest_width, dest_height);
   rect = CGRectApplyAffineTransform(rect, m_foxitDevice2User);
   if (FXDIB_BICUBIC_INTERPOL == flags)
     CGContextSetInterpolationQuality(m_context, kCGInterpolationHigh);
   else if (FXDIB_DOWNSAMPLE == flags)
     CGContextSetInterpolationQuality(m_context, kCGInterpolationNone);
   else
     CGContextSetInterpolationQuality(m_context, kCGInterpolationMedium);
 
   CG_SetImageTransform(dest_left, dest_top, dest_width, dest_height, nullptr);
   CFX_DIBitmap* pBitmap1 = nullptr;
   if (pBitmap->IsAlphaMask()) {
     if (pBitmap->GetBuffer())
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     else
       pBitmap1 = pBitmap->Clone();
     if (!pBitmap1) {
       RestoreState(false);
-      return FALSE;
+      return false;
     }
     CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(
         nullptr, pBitmap1->GetBuffer(),
         pBitmap1->GetPitch() * pBitmap1->GetHeight(), nullptr);
     CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
     CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
     CGImageRef pImage = CGImageCreate(
         pBitmap1->GetWidth(), pBitmap1->GetHeight(), pBitmap1->GetBPP(),
         pBitmap1->GetBPP(), pBitmap1->GetPitch(), pColorSpace, bitmapInfo,
         pBitmapProvider, nullptr, true, kCGRenderingIntentDefault);
     CGContextClipToMask(m_context, rect, pImage);
     CGContextSetRGBFillColor(m_context, FXARGB_R(argb) / 255.f,
                              FXARGB_G(argb) / 255.f, FXARGB_B(argb) / 255.f,
                              FXARGB_A(argb) / 255.f);
     CGContextFillRect(m_context, rect);
     CGImageRelease(pImage);
     CGColorSpaceRelease(pColorSpace);
     CGDataProviderRelease(pBitmapProvider);
     if (pBitmap1 != pBitmap)
       delete pBitmap1;
 
     RestoreState(false);
-    return TRUE;
+    return true;
   }
   if (pBitmap->GetBPP() < 32) {
     pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
   } else {
     if (pBitmap->GetBuffer())
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     else
       pBitmap1 = pBitmap->Clone();
   }
   if (!pBitmap1) {
     RestoreState(false);
-    return FALSE;
+    return false;
   }
   if (pBitmap1->HasAlpha()) {
     if (pBitmap1 == pBitmap) {
       pBitmap1 = pBitmap->Clone();
       if (!pBitmap1) {
         RestoreState(false);
-        return FALSE;
+        return false;
       }
     }
     for (int row = 0; row < pBitmap1->GetHeight(); row++) {
       uint8_t* pScanline = (uint8_t*)pBitmap1->GetScanline(row);
       for (int col = 0; col < pBitmap1->GetWidth(); col++) {
         pScanline[0] = (uint8_t)(pScanline[0] * pScanline[3] / 255.f + .5f);
         pScanline[1] = (uint8_t)(pScanline[1] * pScanline[3] / 255.f + .5f);
         pScanline[2] = (uint8_t)(pScanline[2] * pScanline[3] / 255.f + .5f);
         pScanline += 4;
       }
     }
   }
   CGContextRef ctx = createContextWithBitmap(pBitmap1);
   CGImageRef image = CGBitmapContextCreateImage(ctx);
   CGContextDrawImage(m_context, rect, image);
   CGImageRelease(image);
   CGContextRelease(ctx);
   if (pBitmap1 != pBitmap)
     delete pBitmap1;
 
   RestoreState(false);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::StartDIBits(const CFX_DIBSource* pBitmap,
-                                            int bitmap_alpha,
-                                            uint32_t color,
-                                            const CFX_Matrix* pMatrix,
-                                            uint32_t flags,
-                                            void*& handle,
-                                            int blend_type) {
-  return FALSE;
+bool CFX_QuartzDeviceDriver::StartDIBits(const CFX_DIBSource* pBitmap,
+                                         int bitmap_alpha,
+                                         uint32_t color,
+                                         const CFX_Matrix* pMatrix,
+                                         uint32_t flags,
+                                         void*& handle,
+                                         int blend_type) {
+  return false;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::CG_DrawGlyphRun(
-    int nChars,
-    const FXTEXT_CHARPOS* pCharPos,
-    CFX_Font* pFont,
-    const CFX_Matrix* pGlyphMatrix,
-    const CFX_Matrix* pObject2Device,
-    FX_FLOAT font_size,
-    uint32_t argb) {
+bool CFX_QuartzDeviceDriver::CG_DrawGlyphRun(int nChars,
+                                             const FXTEXT_CHARPOS* pCharPos,
+                                             CFX_Font* pFont,
+                                             const CFX_Matrix* pGlyphMatrix,
+                                             const CFX_Matrix* pObject2Device,
+                                             FX_FLOAT font_size,
+                                             uint32_t argb) {
   if (nChars == 0)
-    return TRUE;
+    return true;
 
   CQuartz2D& quartz2d =
       static_cast<CApplePlatform*>(CFX_GEModule::Get()->GetPlatformData())
           ->m_quartz2d;
   if (!pFont->GetPlatformFont()) {
     if (pFont->GetPsName() == "DFHeiStd-W5")
-      return FALSE;
+      return false;
 
     pFont->SetPlatformFont(
         quartz2d.CreateFont(pFont->GetFontData(), pFont->GetSize()));
     if (!pFont->GetPlatformFont()) {
-      return FALSE;
+      return false;
     }
   }
   CFX_FixedBufGrow<uint16_t, 32> glyph_indices(nChars);
   CFX_FixedBufGrow<CGPoint, 32> glyph_positions(nChars);
   for (int i = 0; i < nChars; i++) {
     glyph_indices[i] = pCharPos[i].m_ExtGID;
     glyph_positions[i].x = pCharPos[i].m_OriginX;
     glyph_positions[i].y = pCharPos[i].m_OriginY;
   }
   CFX_Matrix text_matrix;
@@ skipping 21 matching lines @@
         pGlyphMatrix->e, pGlyphMatrix->f);
     if (m_foxitDevice2User.d < 0)
       glyph_matrix = CGAffineTransformInvert(glyph_matrix);
 
     CGContextConcatCTM(m_context, glyph_matrix);
     CGContextTranslateCTM(m_context, -origin.x, -origin.y);
   }
   CGContextShowGlyphsAtPositions(m_context, (CGGlyph*)glyph_indices,
                                  glyph_positions, nChars);
   RestoreState(false);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int nChars,
-                                               const FXTEXT_CHARPOS* pCharPos,
-                                               CFX_Font* pFont,
-                                               const CFX_Matrix* pObject2Device,
-                                               FX_FLOAT font_size,
-                                               uint32_t color) {
+bool CFX_QuartzDeviceDriver::DrawDeviceText(int nChars,
+                                            const FXTEXT_CHARPOS* pCharPos,
+                                            CFX_Font* pFont,
+                                            const CFX_Matrix* pObject2Device,
+                                            FX_FLOAT font_size,
+                                            uint32_t color) {
   if (!pFont || !m_context)
-    return FALSE;
+    return false;
 
-  FX_BOOL bBold = pFont->IsBold();
+  bool bBold = pFont->IsBold();
   if (!bBold && pFont->GetSubstFont() &&
       pFont->GetSubstFont()->m_Weight >= 500 &&
       pFont->GetSubstFont()->m_Weight <= 600) {
-    return FALSE;
+    return false;
   }
   SaveState();
   CGContextSetTextDrawingMode(m_context, kCGTextFillClip);
-  FX_BOOL ret = FALSE;
+  bool ret = false;
   int32_t i = 0;
   while (i < nChars) {
     if (pCharPos[i].m_bGlyphAdjust || font_size < 0) {
       if (i > 0) {
         ret = CG_DrawGlyphRun(i, pCharPos, pFont, nullptr, pObject2Device,
                               font_size, color);
         if (!ret) {
           RestoreState(false);
           return ret;
         }
@@ skipping 155 matching lines @@
 
   for (int i = 0; i < m_saveCount; ++i) {
     CGContextRestoreGState(m_context);
   }
   m_saveCount = 0;
   if (m_context) {
     CGContextRelease(m_context);
   }
 }
 CFX_QuartzDevice::CFX_QuartzDevice() {
-  m_bOwnedBitmap = FALSE;
+  m_bOwnedBitmap = false;
   m_pContext = nullptr;
 }
 CFX_QuartzDevice::~CFX_QuartzDevice() {
   if (m_pContext) {
     CGContextRelease(m_pContext);
   }
   if (m_bOwnedBitmap) {
     delete GetBitmap();
   }
 }
 CGContextRef CFX_QuartzDevice::GetContext() {
   return m_pContext;
 }
-FX_BOOL CFX_QuartzDevice::Attach(CGContextRef context, int32_t nDeviceClass) {
+bool CFX_QuartzDevice::Attach(CGContextRef context, int32_t nDeviceClass) {
   if (m_pContext) {
     CGContextRelease(m_pContext);
   }
   m_pContext = context;
   CGContextRetain(m_pContext);
   SetDeviceDriver(
       pdfium::MakeUnique<CFX_QuartzDeviceDriver>(m_pContext, nDeviceClass));
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDevice::Attach(CFX_DIBitmap* pBitmap) {
+bool CFX_QuartzDevice::Attach(CFX_DIBitmap* pBitmap) {
   SetBitmap(pBitmap);
   m_pContext = createContextWithBitmap(pBitmap);
   if (!m_pContext)
-    return FALSE;
+    return false;
 
   SetDeviceDriver(
       pdfium::MakeUnique<CFX_QuartzDeviceDriver>(m_pContext, FXDC_DISPLAY));
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_QuartzDevice::Create(int32_t width,
-                                 int32_t height,
-                                 FXDIB_Format format) {
+bool CFX_QuartzDevice::Create(int32_t width,
+                              int32_t height,
+                              FXDIB_Format format) {
   if ((uint8_t)format < 32) {
-    return FALSE;
+    return false;
   }
   std::unique_ptr<CFX_DIBitmap> pBitmap(new CFX_DIBitmap);
   if (!pBitmap->Create(width, height, format))
-    return FALSE;
-  m_bOwnedBitmap = TRUE;
+    return false;
+  m_bOwnedBitmap = true;
   return Attach(pBitmap.release());
 }
 #endif  // _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_