Remove FX_BOOL from core

core/fxge/agg/fx_agg_driver.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/agg/fx_agg_driver.h"
 
 #include <algorithm>
 
@@ skipping 52 matching lines @@
   if (src_alpha == 0)
     return;
 
   FX_RECT rect(left, top, left + width, top + height);
   rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
   width = rect.Width();
   int src_r = FXARGB_R(argb);
   int src_g = FXARGB_G(argb);
   int src_b = FXARGB_B(argb);
   int Bpp = pBitmap->GetBPP() / 8;
-  FX_BOOL bAlpha = pBitmap->HasAlpha();
+  bool bAlpha = pBitmap->HasAlpha();
   int dib_argb = FXARGB_TOBGRORDERDIB(argb);
   uint8_t* pBuffer = pBitmap->GetBuffer();
   if (src_alpha == 255) {
     for (int row = rect.top; row < rect.bottom; row++) {
       uint8_t* dest_scan =
           pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp;
       if (Bpp == 4) {
         uint32_t* scan = (uint32_t*)dest_scan;
         for (int col = 0; col < width; col++)
           *scan++ = dib_argb;
@@ skipping 98 matching lines @@
         uint8_t* src_scan =
             (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
         for (int col = 0; col < width; col++) {
           *dest_scan++ = src_scan[2];
           *dest_scan++ = src_scan[1];
           *dest_scan++ = src_scan[0];
           src_scan += 4;
         }
       }
     } else {
-      ASSERT(FALSE);
+      ASSERT(false);
     }
     return;
   }
 
   if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) {
     if (src_format == FXDIB_Rgb) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch);
         uint8_t* src_scan =
             (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
@@ skipping 14 matching lines @@
           FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
                                                src_scan[2]));
           src_scan += 4;
           dest_scan += 4;
         }
       }
     }
     return;
   }
 
-  ASSERT(FALSE);
+  ASSERT(false);
 }
 
 FX_ARGB DefaultCMYK2ARGB(FX_CMYK cmyk, uint8_t alpha) {
   uint8_t r, g, b;
   AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
                      FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r, g, b);
   return ArgbEncode(alpha, r, g, b);
 }
 
-FX_BOOL DibSetPixel(CFX_DIBitmap* pDevice,
-                    int x,
-                    int y,
-                    uint32_t color,
-                    int alpha_flag,
-                    void* pIccTransform) {
-  FX_BOOL bObjCMYK = !!FXGETFLAG_COLORTYPE(alpha_flag);
+bool DibSetPixel(CFX_DIBitmap* pDevice,
+                 int x,
+                 int y,
+                 uint32_t color,
+                 int alpha_flag,
+                 void* pIccTransform) {
+  bool bObjCMYK = !!FXGETFLAG_COLORTYPE(alpha_flag);
   int alpha = bObjCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
   if (pIccTransform) {
     CCodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color,
                                   (uint8_t*)&color, 1);
     color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
     if (!pDevice->IsCmykImage()) {
       color = (color & 0xffffff) | (alpha << 24);
     }
   } else {
     if (pDevice->IsCmykImage()) {
       if (!bObjCMYK)
-        return FALSE;
+        return false;
     } else {
       if (bObjCMYK)
         color = DefaultCMYK2ARGB(color, alpha);
     }
   }
   pDevice->SetPixel(x, y, color);
   if (pDevice->m_pAlphaMask) {
     pDevice->m_pAlphaMask->SetPixel(x, y, alpha << 24);
   }
-  return TRUE;
+  return true;
 }
 
 }  // namespace
 
 void CAgg_PathData::BuildPath(const CFX_PathData* pPathData,
                               const CFX_Matrix* pObject2Device) {
   int nPoints = pPathData->GetPointCount();
   FX_PATHPOINT* pPoints = pPathData->GetPoints();
   for (int i = 0; i < nPoints; i++) {
     FX_FLOAT x = pPoints[i].m_PointX, y = pPoints[i].m_PointY;
@@ skipping 69 matching lines @@
   unsigned m_left, m_top;
 };
 
 }  // namespace agg
 
 static void RasterizeStroke(agg::rasterizer_scanline_aa& rasterizer,
                             agg::path_storage& path_data,
                             const CFX_Matrix* pObject2Device,
                             const CFX_GraphStateData* pGraphState,
                             FX_FLOAT scale = 1.0f,
-                            FX_BOOL bStrokeAdjust = FALSE,
-                            FX_BOOL bTextMode = FALSE) {
+                            bool bStrokeAdjust = false,
+                            bool bTextMode = false) {
   agg::line_cap_e cap;
   switch (pGraphState->m_LineCap) {
     case CFX_GraphStateData::LineCapRound:
       cap = agg::round_cap;
       break;
     case CFX_GraphStateData::LineCapSquare:
       cap = agg::square_cap;
       break;
     default:
       cap = agg::butt_cap;
@@ skipping 48 matching lines @@
     agg::conv_stroke<agg::path_storage> stroke(path_data);
     stroke.line_join(join);
     stroke.line_cap(cap);
     stroke.miter_limit(pGraphState->m_MiterLimit);
     stroke.width(width);
     rasterizer.add_path_transformed(stroke, pObject2Device);
   }
 }
 
 CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap,
-                                         FX_BOOL bRgbByteOrder,
+                                         bool bRgbByteOrder,
                                          CFX_DIBitmap* pOriDevice,
-                                         FX_BOOL bGroupKnockout)
+                                         bool bGroupKnockout)
     : m_pBitmap(pBitmap),
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       m_pPlatformGraphics(nullptr),
 #endif
       m_FillFlags(0),
       m_bRgbByteOrder(bRgbByteOrder),
       m_pOriDevice(pOriDevice),
       m_bGroupKnockout(bGroupKnockout) {
   InitPlatform();
 }
 
 CFX_AggDeviceDriver::~CFX_AggDeviceDriver() {
   DestroyPlatform();
 }
 
 uint8_t* CFX_AggDeviceDriver::GetBuffer() const {
   return m_pBitmap->GetBuffer();
 }
 
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
 void CFX_AggDeviceDriver::InitPlatform() {}
 
 void CFX_AggDeviceDriver::DestroyPlatform() {}
 
-FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int nChars,
-                                            const FXTEXT_CHARPOS* pCharPos,
-                                            CFX_Font* pFont,
-                                            const CFX_Matrix* pObject2Device,
-                                            FX_FLOAT font_size,
-                                            uint32_t color) {
-  return FALSE;
+bool CFX_AggDeviceDriver::DrawDeviceText(int nChars,
+                                         const FXTEXT_CHARPOS* pCharPos,
+                                         CFX_Font* pFont,
+                                         const CFX_Matrix* pObject2Device,
+                                         FX_FLOAT font_size,
+                                         uint32_t color) {
+  return false;
 }
 #endif  // _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
 
 int CFX_AggDeviceDriver::GetDeviceCaps(int caps_id) const {
   switch (caps_id) {
     case FXDC_DEVICE_CLASS:
       return FXDC_DISPLAY;
     case FXDC_PIXEL_WIDTH:
       return m_pBitmap->GetWidth();
     case FXDC_PIXEL_HEIGHT:
@@ skipping 61 matching lines @@
   agg::renderer_base<agg::pixfmt_gray8> base_buf(pixel_buf);
   agg::renderer_scanline_aa_offset<agg::renderer_base<agg::pixfmt_gray8> >
       final_render(base_buf, path_rect.left, path_rect.top);
   final_render.color(agg::gray8(255));
   agg::scanline_u8 scanline;
   agg::render_scanlines(rasterizer, scanline, final_render,
                         (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
   m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top, mask);
 }
 
-FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
-                                              const CFX_Matrix* pObject2Device,
-                                              int fill_mode) {
+bool CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
+                                           const CFX_Matrix* pObject2Device,
+                                           int fill_mode) {
   m_FillFlags = fill_mode;
   if (!m_pClipRgn) {
     m_pClipRgn = pdfium::MakeUnique<CFX_ClipRgn>(
         GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
   }
   if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) {
     CFX_FloatRect rectf;
     if (pPathData->IsRect(pObject2Device, &rectf)) {
       rectf.Intersect(
           CFX_FloatRect(0, 0, (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH),
                         (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
       FX_RECT rect = rectf.GetOuterRect();
       m_pClipRgn->IntersectRect(rect);
-      return TRUE;
+      return true;
     }
   }
   CAgg_PathData path_data;
   path_data.BuildPath(pPathData, pObject2Device);
   path_data.m_PathData.end_poly();
   agg::rasterizer_scanline_aa rasterizer;
   rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                       (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
   rasterizer.add_path(path_data.m_PathData);
   rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING
                               ? agg::fill_non_zero
                               : agg::fill_even_odd);
   SetClipMask(rasterizer);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke(
+bool CFX_AggDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pPathData,
     const CFX_Matrix* pObject2Device,
     const CFX_GraphStateData* pGraphState) {
   if (!m_pClipRgn) {
     m_pClipRgn = pdfium::MakeUnique<CFX_ClipRgn>(
         GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
   }
   CAgg_PathData path_data;
   path_data.BuildPath(pPathData, nullptr);
   agg::rasterizer_scanline_aa rasterizer;
   rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                       (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
   RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device,
                   pGraphState);
   rasterizer.filling_rule(agg::fill_non_zero);
   SetClipMask(rasterizer);
-  return TRUE;
+  return true;
 }
 
 class CFX_Renderer {
  private:
   int m_Alpha, m_Red, m_Green, m_Blue, m_Gray;
   uint32_t m_Color;
-  FX_BOOL m_bFullCover;
-  FX_BOOL m_bRgbByteOrder;
+  bool m_bFullCover;
+  bool m_bRgbByteOrder;
   CFX_DIBitmap* m_pOriDevice;
   FX_RECT m_ClipBox;
   const CFX_DIBitmap* m_pClipMask;
   CFX_DIBitmap* m_pDevice;
   const CFX_ClipRgn* m_pClipRgn;
   void (CFX_Renderer::*composite_span)(uint8_t*,
                                        int,
                                        int,
                                        int,
                                        uint8_t*,
                                        int,
                                        int,
                                        uint8_t*,
                                        uint8_t*);
 
  public:
   void prepare(unsigned) {}
 
   void CompositeSpan(uint8_t* dest_scan,
                      uint8_t* ori_scan,
                      int Bpp,
-                     FX_BOOL bDestAlpha,
+                     bool bDestAlpha,
                      int span_left,
                      int span_len,
                      uint8_t* cover_scan,
                      int clip_left,
                      int clip_right,
                      uint8_t* clip_scan) {
     ASSERT(!m_pDevice->IsCmykImage());
     int col_start = span_left < clip_left ? clip_left - span_left : 0;
     int col_end = (span_left + span_len) < clip_right
                       ? span_len
@@ skipping 610 matching lines @@
     CFX_DIBitmap* pAlphaMask = m_pDevice->m_pAlphaMask;
     if (pAlphaMask) {
       dest_scan_extra_alpha =
           pAlphaMask->GetBuffer() + pAlphaMask->GetPitch() * y;
     }
     uint8_t* ori_scan = nullptr;
     if (m_pOriDevice) {
       ori_scan = m_pOriDevice->GetBuffer() + m_pOriDevice->GetPitch() * y;
     }
     int Bpp = m_pDevice->GetBPP() / 8;
-    FX_BOOL bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask();
+    bool bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask();
     unsigned num_spans = sl.num_spans();
     typename Scanline::const_iterator span = sl.begin();
     while (1) {
       int x = span->x;
       ASSERT(span->len > 0);
       uint8_t* dest_pos = nullptr;
       uint8_t* dest_extra_alpha_pos = nullptr;
       uint8_t* ori_pos = nullptr;
       if (Bpp) {
         ori_pos = ori_scan ? ori_scan + x * Bpp : nullptr;
@@ skipping 18 matching lines @@
                                 m_ClipBox.left, m_ClipBox.right, clip_pos,
                                 dest_extra_alpha_pos);
       }
       if (--num_spans == 0) {
         break;
       }
       ++span;
     }
   }
 
-  FX_BOOL Init(CFX_DIBitmap* pDevice,
-               CFX_DIBitmap* pOriDevice,
-               const CFX_ClipRgn* pClipRgn,
-               uint32_t color,
-               FX_BOOL bFullCover,
-               FX_BOOL bRgbByteOrder,
-               int alpha_flag = 0,
-               void* pIccTransform = nullptr) {
+  bool Init(CFX_DIBitmap* pDevice,
+            CFX_DIBitmap* pOriDevice,
+            const CFX_ClipRgn* pClipRgn,
+            uint32_t color,
+            bool bFullCover,
+            bool bRgbByteOrder,
+            int alpha_flag = 0,
+            void* pIccTransform = nullptr) {
     m_pDevice = pDevice;
     m_pClipRgn = pClipRgn;
     composite_span = nullptr;
     m_bRgbByteOrder = bRgbByteOrder;
     m_pOriDevice = pOriDevice;
     if (m_pClipRgn) {
       m_ClipBox = m_pClipRgn->GetBox();
     } else {
       m_ClipBox.left = m_ClipBox.top = 0;
       m_ClipBox.right = m_pDevice->GetWidth();
       m_ClipBox.bottom = m_pDevice->GetHeight();
     }
     m_pClipMask = nullptr;
     if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) {
       m_pClipMask = m_pClipRgn->GetMask().GetObject();
     }
     m_bFullCover = bFullCover;
-    FX_BOOL bObjectCMYK = !!FXGETFLAG_COLORTYPE(alpha_flag);
-    FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
+    bool bObjectCMYK = !!FXGETFLAG_COLORTYPE(alpha_flag);
+    bool bDeviceCMYK = pDevice->IsCmykImage();
     m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
     CCodec_IccModule* pIccModule = nullptr;
     if (!CFX_GEModule::Get()->GetCodecModule() ||
         !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
       pIccTransform = nullptr;
     } else {
       pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (m_pDevice->GetBPP() == 8) {
       ASSERT(!m_bRgbByteOrder);
@@ skipping 13 matching lines @@
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
                                FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                r, g, b);
             m_Gray = FXRGB2GRAY(r, g, b);
           } else {
             m_Gray =
                 FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
           }
         }
       }
-      return TRUE;
+      return true;
     }
     if (bDeviceCMYK) {
       ASSERT(!m_bRgbByteOrder);
       composite_span = &CFX_Renderer::CompositeSpanCMYK;
       if (bObjectCMYK) {
         m_Color = FXCMYK_TODIB(color);
         if (pIccTransform) {
           pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color,
                                         (const uint8_t*)&m_Color, 1);
         }
       } else {
         if (!pIccTransform) {
-          return FALSE;
+          return false;
         }
         color = FXARGB_TODIB(color);
         pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color,
                                       (const uint8_t*)&color, 1);
       }
       m_Red = ((uint8_t*)&m_Color)[0];
       m_Green = ((uint8_t*)&m_Color)[1];
       m_Blue = ((uint8_t*)&m_Color)[2];
       m_Gray = ((uint8_t*)&m_Color)[3];
     } else {
@@ skipping 33 matching lines @@
           } else {
             m_Color = FXARGB_TODIB(color);
           }
           ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue);
         }
       }
     }
     if (m_pDevice->GetBPP() == 1) {
       composite_span = &CFX_Renderer::CompositeSpan1bpp;
     }
-    return TRUE;
+    return true;
   }
 };
 
 int CFX_AggDeviceDriver::GetDriverType() const {
   return 1;
 }
 
-FX_BOOL CFX_AggDeviceDriver::RenderRasterizer(
+bool CFX_AggDeviceDriver::RenderRasterizer(
     agg::rasterizer_scanline_aa& rasterizer,
     uint32_t color,
-    FX_BOOL bFullCover,
-    FX_BOOL bGroupKnockout,
+    bool bFullCover,
+    bool bGroupKnockout,
     int alpha_flag,
     void* pIccTransform) {
   CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : nullptr;
   CFX_Renderer render;
   if (!render.Init(m_pBitmap, pt, m_pClipRgn.get(), color, bFullCover,
                    m_bRgbByteOrder, alpha_flag, pIccTransform)) {
-    return FALSE;
+    return false;
   }
   agg::scanline_u8 scanline;
   agg::render_scanlines(rasterizer, scanline, render,
                         (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
-                                      const CFX_Matrix* pObject2Device,
-                                      const CFX_GraphStateData* pGraphState,
-                                      uint32_t fill_color,
-                                      uint32_t stroke_color,
-                                      int fill_mode,
-                                      int blend_type) {
+bool CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
+                                   const CFX_Matrix* pObject2Device,
+                                   const CFX_GraphStateData* pGraphState,
+                                   uint32_t fill_color,
+                                   uint32_t stroke_color,
+                                   int fill_mode,
+                                   int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL)
-    return FALSE;
+    return false;
 
   if (!GetBuffer())
-    return TRUE;
+    return true;
 
   m_FillFlags = fill_mode;
   if ((fill_mode & 3) && fill_color) {
     CAgg_PathData path_data;
     path_data.BuildPath(pPathData, pObject2Device);
     agg::rasterizer_scanline_aa rasterizer;
     rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                         (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
     rasterizer.add_path(path_data.m_PathData);
     rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING
                                 ? agg::fill_non_zero
                                 : agg::fill_even_odd);
     if (!RenderRasterizer(rasterizer, fill_color,
-                          !!(fill_mode & FXFILL_FULLCOVER), FALSE, 0,
+                          !!(fill_mode & FXFILL_FULLCOVER), false, 0,
                           nullptr)) {
-      return FALSE;
+      return false;
     }
   }
   int stroke_alpha = FXARGB_A(stroke_color);
   if (!pGraphState || !stroke_alpha)
-    return TRUE;
+    return true;
 
   if (fill_mode & FX_ZEROAREA_FILL) {
     CAgg_PathData path_data;
     path_data.BuildPath(pPathData, pObject2Device);
     agg::rasterizer_scanline_aa rasterizer;
     rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                         (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
     RasterizeStroke(rasterizer, path_data.m_PathData, nullptr, pGraphState, 1,
-                    FALSE, !!(fill_mode & FX_STROKE_TEXT_MODE));
+                    false, !!(fill_mode & FX_STROKE_TEXT_MODE));
     return RenderRasterizer(rasterizer, stroke_color,
                             !!(fill_mode & FXFILL_FULLCOVER), m_bGroupKnockout,
                             0, nullptr);
   }
   CFX_Matrix matrix1;
   CFX_Matrix matrix2;
   if (pObject2Device) {
     matrix1.a =
         std::max(FXSYS_fabs(pObject2Device->a), FXSYS_fabs(pObject2Device->b));
     matrix1.d = matrix1.a;
     matrix2.Set(pObject2Device->a / matrix1.a, pObject2Device->b / matrix1.a,
                 pObject2Device->c / matrix1.d, pObject2Device->d / matrix1.d, 0,
                 0);
     CFX_Matrix mtRervese;
     mtRervese.SetReverse(matrix2);
     matrix1 = *pObject2Device;
     matrix1.Concat(mtRervese);
   }
   CAgg_PathData path_data;
   path_data.BuildPath(pPathData, &matrix1);
   agg::rasterizer_scanline_aa rasterizer;
   rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                       (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
   RasterizeStroke(rasterizer, path_data.m_PathData, &matrix2, pGraphState,
-                  matrix1.a, FALSE, !!(fill_mode & FX_STROKE_TEXT_MODE));
+                  matrix1.a, false, !!(fill_mode & FX_STROKE_TEXT_MODE));
   return RenderRasterizer(rasterizer, stroke_color,
                           !!(fill_mode & FXFILL_FULLCOVER), m_bGroupKnockout, 0,
                           nullptr);
 }
 
-FX_BOOL CFX_AggDeviceDriver::SetPixel(int x, int y, uint32_t color) {
+bool CFX_AggDeviceDriver::SetPixel(int x, int y, uint32_t color) {
   if (!m_pBitmap->GetBuffer())
-    return TRUE;
+    return true;
 
   if (!m_pClipRgn) {
     if (!m_bRgbByteOrder)
       return DibSetPixel(m_pBitmap, x, y, color, 0, nullptr);
     RgbByteOrderSetPixel(m_pBitmap, x, y, color);
-    return TRUE;
+    return true;
   }
   if (!m_pClipRgn->GetBox().Contains(x, y))
-    return TRUE;
+    return true;
 
   if (m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
     if (!m_bRgbByteOrder)
       return DibSetPixel(m_pBitmap, x, y, color, 0, nullptr);
     RgbByteOrderSetPixel(m_pBitmap, x, y, color);
-    return TRUE;
+    return true;
   }
   if (m_pClipRgn->GetType() != CFX_ClipRgn::MaskF)
-    return TRUE;
+    return true;
 
   const CFX_DIBitmap* pMask = m_pClipRgn->GetMask().GetObject();
   int new_alpha = FXARGB_A(color) * pMask->GetScanline(y)[x] / 255;
   color = (color & 0xffffff) | (new_alpha << 24);
   if (m_bRgbByteOrder) {
     RgbByteOrderSetPixel(m_pBitmap, x, y, color);
-    return TRUE;
+    return true;
   }
   return DibSetPixel(m_pBitmap, x, y, color, 0, nullptr);
 }
 
-FX_BOOL CFX_AggDeviceDriver::FillRectWithBlend(const FX_RECT* pRect,
-                                               uint32_t fill_color,
-                                               int blend_type) {
+bool CFX_AggDeviceDriver::FillRectWithBlend(const FX_RECT* pRect,
+                                            uint32_t fill_color,
+                                            int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL)
-    return FALSE;
+    return false;
 
   if (!m_pBitmap->GetBuffer())
-    return TRUE;
+    return true;
 
   FX_RECT clip_rect;
   GetClipBox(&clip_rect);
   FX_RECT draw_rect = clip_rect;
   if (pRect)
     draw_rect.Intersect(*pRect);
   if (draw_rect.IsEmpty())
-    return TRUE;
+    return true;
 
   if (!m_pClipRgn || m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
     if (m_bRgbByteOrder) {
       RgbByteOrderCompositeRect(m_pBitmap, draw_rect.left, draw_rect.top,
                                 draw_rect.Width(), draw_rect.Height(),
                                 fill_color);
     } else {
       m_pBitmap->CompositeRect(draw_rect.left, draw_rect.top, draw_rect.Width(),
                                draw_rect.Height(), fill_color, 0, nullptr);
     }
-    return TRUE;
+    return true;
   }
   m_pBitmap->CompositeMask(
       draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(),
       m_pClipRgn->GetMask().GetObject(), fill_color,
       draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top,
       FXDIB_BLEND_NORMAL, nullptr, m_bRgbByteOrder, 0, nullptr);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect) {
+bool CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect) {
   if (!m_pClipRgn) {
     pRect->left = pRect->top = 0;
     pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH);
     pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT);
-    return TRUE;
+    return true;
   }
   *pRect = m_pClipRgn->GetBox();
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap,
-                                       int left,
-                                       int top) {
+bool CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top) {
   if (!m_pBitmap || !m_pBitmap->GetBuffer())
-    return TRUE;
+    return true;
 
   FX_RECT rect(left, top, left + pBitmap->GetWidth(),
                top + pBitmap->GetHeight());
   CFX_DIBitmap* pBack = nullptr;
   if (m_pOriDevice) {
     pBack = m_pOriDevice->Clone(&rect);
     if (!pBack)
-      return TRUE;
+      return true;
 
     pBack->CompositeBitmap(0, 0, pBack->GetWidth(), pBack->GetHeight(),
                            m_pBitmap, 0, 0);
   } else {
     pBack = m_pBitmap->Clone(&rect);
     if (!pBack)
-      return TRUE;
+      return true;
   }
 
-  FX_BOOL bRet = TRUE;
+  bool bRet = true;
   left = std::min(left, 0);
   top = std::min(top, 0);
   if (m_bRgbByteOrder) {
     RgbByteOrderTransferBitmap(pBitmap, 0, 0, rect.Width(), rect.Height(),
                                pBack, left, top);
   } else {
     bRet = pBitmap->TransferBitmap(0, 0, rect.Width(), rect.Height(), pBack,
                                    left, top);
   }
   delete pBack;
   return bRet;
 }
 
 CFX_DIBitmap* CFX_AggDeviceDriver::GetBackDrop() {
   return m_pOriDevice;
 }
 
-FX_BOOL CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
-                                       uint32_t argb,
-                                       const FX_RECT* pSrcRect,
-                                       int left,
-                                       int top,
-                                       int blend_type) {
+bool CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
+                                    uint32_t argb,
+                                    const FX_RECT* pSrcRect,
+                                    int left,
+                                    int top,
+                                    int blend_type) {
   if (!m_pBitmap->GetBuffer())
-    return TRUE;
+    return true;
 
   if (pBitmap->IsAlphaMask()) {
     return m_pBitmap->CompositeMask(
         left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
         pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn.get(),
         m_bRgbByteOrder, 0, nullptr);
   }
   return m_pBitmap->CompositeBitmap(
       left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, pSrcRect->left,
       pSrcRect->top, blend_type, m_pClipRgn.get(), m_bRgbByteOrder, nullptr);
 }
 
-FX_BOOL CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
-                                           uint32_t argb,
-                                           int dest_left,
-                                           int dest_top,
-                                           int dest_width,
-                                           int dest_height,
-                                           const FX_RECT* pClipRect,
-                                           uint32_t flags,
-                                           int blend_type) {
+bool CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
+                                        uint32_t argb,
+                                        int dest_left,
+                                        int dest_top,
+                                        int dest_width,
+                                        int dest_height,
+                                        const FX_RECT* pClipRect,
+                                        uint32_t flags,
+                                        int blend_type) {
   if (!m_pBitmap->GetBuffer())
-    return TRUE;
+    return true;
 
   if (dest_width == pSource->GetWidth() &&
       dest_height == pSource->GetHeight()) {
     FX_RECT rect(0, 0, dest_width, dest_height);
     return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type);
   }
   FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width,
                     dest_top + dest_height);
   dest_rect.Normalize();
   FX_RECT dest_clip = dest_rect;
   dest_clip.Intersect(*pClipRect);
   CFX_BitmapComposer composer;
-  composer.Compose(m_pBitmap, m_pClipRgn.get(), 255, argb, dest_clip, FALSE,
-                   FALSE, FALSE, m_bRgbByteOrder, 0, nullptr, blend_type);
+  composer.Compose(m_pBitmap, m_pClipRgn.get(), 255, argb, dest_clip, false,
+                   false, false, m_bRgbByteOrder, 0, nullptr, blend_type);
   dest_clip.Offset(-dest_rect.left, -dest_rect.top);
   CFX_ImageStretcher stretcher(&composer, pSource, dest_width, dest_height,
                                dest_clip, flags);
   if (stretcher.Start())
     stretcher.Continue(nullptr);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
-                                         int bitmap_alpha,
-                                         uint32_t argb,
-                                         const CFX_Matrix* pMatrix,
-                                         uint32_t render_flags,
-                                         void*& handle,
-                                         int blend_type) {
+bool CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
+                                      int bitmap_alpha,
+                                      uint32_t argb,
+                                      const CFX_Matrix* pMatrix,
+                                      uint32_t render_flags,
+                                      void*& handle,
+                                      int blend_type) {
   if (!m_pBitmap->GetBuffer())
-    return TRUE;
+    return true;
 
   CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer;
   pRenderer->Start(m_pBitmap, m_pClipRgn.get(), pSource, bitmap_alpha, argb,
                    pMatrix, render_flags, m_bRgbByteOrder, 0, nullptr);
   handle = pRenderer;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
+bool CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
   if (!m_pBitmap->GetBuffer()) {
-    return TRUE;
+    return true;
   }
   return ((CFX_ImageRenderer*)pHandle)->Continue(pPause);
 }
 
 void CFX_AggDeviceDriver::CancelDIBits(void* pHandle) {
   if (!m_pBitmap->GetBuffer()) {
     return;
   }
   delete (CFX_ImageRenderer*)pHandle;
 }
 
 #ifndef _SKIA_SUPPORT_
 CFX_FxgeDevice::CFX_FxgeDevice() {
-  m_bOwnedBitmap = FALSE;
+  m_bOwnedBitmap = false;
 }
 
 bool CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap,
                             bool bRgbByteOrder,
                             CFX_DIBitmap* pOriDevice,
                             bool bGroupKnockout) {
   if (!pBitmap)
     return false;
 
   SetBitmap(pBitmap);
@@ skipping 17 matching lines @@
                                                           pOriDevice, false));
   return true;
 }
 
 CFX_FxgeDevice::~CFX_FxgeDevice() {
   if (m_bOwnedBitmap) {
     delete GetBitmap();
   }
 }
 #endif