Remove FX_BOOL from core

core/fpdfapi/render/fpdf_render_image.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/fpdfapi/render/render_int.h"
 
 #include <memory>
 #include <utility>
@@ skipping 16 matching lines @@
 #include "core/fpdfdoc/cpdf_occontext.h"
 #include "core/fxcodec/fx_codec.h"
 #include "core/fxcrt/fx_safe_types.h"
 #include "core/fxge/cfx_fxgedevice.h"
 #include "core/fxge/cfx_pathdata.h"
 
 #ifdef _SKIA_SUPPORT_
 #include "core/fxge/skia/fx_skia_device.h"
 #endif
 
-FX_BOOL CPDF_RenderStatus::ProcessImage(CPDF_ImageObject* pImageObj,
-                                        const CFX_Matrix* pObj2Device) {
+bool CPDF_RenderStatus::ProcessImage(CPDF_ImageObject* pImageObj,
+                                     const CFX_Matrix* pObj2Device) {
   CPDF_ImageRenderer render;
   if (render.Start(this, pImageObj, pObj2Device, m_bStdCS, m_curBlend)) {
     render.Continue(nullptr);
   }
   return render.m_Result;
 }
 void CPDF_RenderStatus::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
                                           int left,
                                           int top,
                                           FX_ARGB mask_argb,
@@ skipping 44 matching lines @@
     if (bIsolated || !bGroup) {
       if (pDIBitmap->IsAlphaMask()) {
         return;
       }
       m_pDevice->SetDIBitsWithBlend(pDIBitmap, left, top, blend_mode);
     } else {
       FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
                    top + pDIBitmap->GetHeight());
       rect.Intersect(m_pDevice->GetClipBox());
       CFX_DIBitmap* pClone = nullptr;
-      FX_BOOL bClone = FALSE;
+      bool bClone = false;
       if (m_pDevice->GetBackDrop() && m_pDevice->GetBitmap()) {
-        bClone = TRUE;
+        bClone = true;
         pClone = m_pDevice->GetBackDrop()->Clone(&rect);
         CFX_DIBitmap* pForeBitmap = m_pDevice->GetBitmap();
         pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                                 pForeBitmap, rect.left, rect.top);
         left = left >= 0 ? 0 : left;
         top = top >= 0 ? 0 : top;
         if (!pDIBitmap->IsAlphaMask())
           pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                                   pDIBitmap, left, top, blend_mode);
         else
@@ skipping 48 matching lines @@
 
 CPDF_TransferFunc::CPDF_TransferFunc(CPDF_Document* pDoc) : m_pPDFDoc(pDoc) {}
 
 FX_COLORREF CPDF_TransferFunc::TranslateColor(FX_COLORREF rgb) const {
   return FXSYS_RGB(m_Samples[FXSYS_GetRValue(rgb)],
                    m_Samples[256 + FXSYS_GetGValue(rgb)],
                    m_Samples[512 + FXSYS_GetBValue(rgb)]);
 }
 
 CFX_DIBSource* CPDF_TransferFunc::TranslateImage(const CFX_DIBSource* pSrc,
-                                                 FX_BOOL bAutoDropSrc) {
+                                                 bool bAutoDropSrc) {
   CPDF_DIBTransferFunc* pDest = new CPDF_DIBTransferFunc(this);
   pDest->LoadSrc(pSrc, bAutoDropSrc);
   return pDest;
 }
 
 CPDF_DIBTransferFunc::~CPDF_DIBTransferFunc() {}
 
 FXDIB_Format CPDF_DIBTransferFunc::GetDestFormat() {
   if (m_pSrc->IsAlphaMask()) {
     return FXDIB_8bppMask;
@@ skipping 12 matching lines @@
 CPDF_DIBTransferFunc::CPDF_DIBTransferFunc(
     const CPDF_TransferFunc* pTransferFunc) {
   m_RampR = pTransferFunc->m_Samples;
   m_RampG = &pTransferFunc->m_Samples[256];
   m_RampB = &pTransferFunc->m_Samples[512];
 }
 
 void CPDF_DIBTransferFunc::TranslateScanline(
     const uint8_t* src_buf,
     std::vector<uint8_t>* dest_buf) const {
-  FX_BOOL bSkip = FALSE;
+  bool bSkip = false;
   switch (m_pSrc->GetFormat()) {
     case FXDIB_1bppRgb: {
       int r0 = m_RampR[0];
       int g0 = m_RampG[0];
       int b0 = m_RampB[0];
       int r1 = m_RampR[255];
       int g1 = m_RampG[255];
       int b1 = m_RampB[255];
       int index = 0;
       for (int i = 0; i < m_Width; i++) {
@@ skipping 59 matching lines @@
         (*dest_buf)[index++] = m_RampB[*(src_buf++)];
         (*dest_buf)[index++] = m_RampG[*(src_buf++)];
         (*dest_buf)[index++] = m_RampR[*(src_buf++)];
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
         index++;
 #endif
       }
       break;
     }
     case FXDIB_Rgb32:
-      bSkip = TRUE;
+      bSkip = true;
     case FXDIB_Argb: {
       int index = 0;
       for (int i = 0; i < m_Width; i++) {
         (*dest_buf)[index++] = m_RampB[*(src_buf++)];
         (*dest_buf)[index++] = m_RampG[*(src_buf++)];
         (*dest_buf)[index++] = m_RampR[*(src_buf++)];
         if (!bSkip) {
           (*dest_buf)[index++] = *src_buf;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
         } else {
@@ skipping 43 matching lines @@
       }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
     }
 #endif
   }
 }
 
 CPDF_ImageRenderer::CPDF_ImageRenderer() {
   m_pRenderStatus = nullptr;
   m_pImageObject = nullptr;
-  m_Result = TRUE;
+  m_Result = true;
   m_Status = 0;
   m_DeviceHandle = nullptr;
-  m_bStdCS = FALSE;
-  m_bPatternColor = FALSE;
+  m_bStdCS = false;
+  m_bPatternColor = false;
   m_BlendType = FXDIB_BLEND_NORMAL;
   m_pPattern = nullptr;
   m_pObj2Device = nullptr;
 }
 
 CPDF_ImageRenderer::~CPDF_ImageRenderer() {
   if (m_DeviceHandle) {
     m_pRenderStatus->m_pDevice->CancelDIBits(m_DeviceHandle);
   }
 }
 
-FX_BOOL CPDF_ImageRenderer::StartLoadDIBSource() {
+bool CPDF_ImageRenderer::StartLoadDIBSource() {
   CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
   FX_RECT image_rect = image_rect_f.GetOuterRect();
   if (!image_rect.Valid())
-    return FALSE;
+    return false;
 
   int dest_width = image_rect.Width();
   int dest_height = image_rect.Height();
   if (m_ImageMatrix.a < 0) {
     dest_width = -dest_width;
   }
   if (m_ImageMatrix.d > 0) {
     dest_height = -dest_height;
   }
   if (m_Loader.Start(m_pImageObject,
                      m_pRenderStatus->m_pContext->GetPageCache(), &m_LoadHandle,
                      m_bStdCS, m_pRenderStatus->m_GroupFamily,
                      m_pRenderStatus->m_bLoadMask, m_pRenderStatus, dest_width,
                      dest_height)) {
     if (m_LoadHandle) {
       m_Status = 4;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_ImageRenderer::StartRenderDIBSource() {
+bool CPDF_ImageRenderer::StartRenderDIBSource() {
   if (!m_Loader.m_pBitmap)
-    return FALSE;
+    return false;
 
   m_BitmapAlpha =
       FXSYS_round(255 * m_pImageObject->m_GeneralState.GetFillAlpha());
   m_pDIBSource = m_Loader.m_pBitmap;
   if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_ALPHA &&
       !m_Loader.m_pMask) {
     return StartBitmapAlpha();
   }
   if (m_pImageObject->m_GeneralState.GetTR()) {
     if (!m_pImageObject->m_GeneralState.GetTransferFunc()) {
       m_pImageObject->m_GeneralState.SetTransferFunc(
           m_pRenderStatus->GetTransferFunc(
               m_pImageObject->m_GeneralState.GetTR()));
     }
     if (m_pImageObject->m_GeneralState.GetTransferFunc() &&
         !m_pImageObject->m_GeneralState.GetTransferFunc()->m_bIdentity) {
       m_pDIBSource = m_Loader.m_pBitmap =
           m_pImageObject->m_GeneralState.GetTransferFunc()->TranslateImage(
               m_Loader.m_pBitmap, !m_Loader.m_bCached);
       if (m_Loader.m_bCached && m_Loader.m_pMask) {
         m_Loader.m_pMask = m_Loader.m_pMask->Clone();
       }
-      m_Loader.m_bCached = FALSE;
+      m_Loader.m_bCached = false;
     }
   }
   m_FillArgb = 0;
-  m_bPatternColor = FALSE;
+  m_bPatternColor = false;
   m_pPattern = nullptr;
   if (m_pDIBSource->IsAlphaMask()) {
     const CPDF_Color* pColor = m_pImageObject->m_ColorState.GetFillColor();
     if (pColor && pColor->IsPattern()) {
       m_pPattern = pColor->GetPattern();
       if (m_pPattern) {
-        m_bPatternColor = TRUE;
+        m_bPatternColor = true;
       }
     }
     m_FillArgb = m_pRenderStatus->GetFillArgb(m_pImageObject);
   } else if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_GRAY) {
     m_pClone.reset(m_pDIBSource->Clone());
     m_pClone->ConvertColorScale(m_pRenderStatus->m_Options.m_BackColor,
                                 m_pRenderStatus->m_Options.m_ForeColor);
     m_pDIBSource = m_pClone.get();
   }
   m_Flags = 0;
@@ skipping 59 matching lines @@
       if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION ||
           format == PDFCS_DEVICEN) {
         m_BlendType = FXDIB_BLEND_DARKEN;
       }
       pDocument->GetPageData()->ReleaseColorSpace(pCSObj);
     }
   }
   return StartDIBSource();
 }
 
-FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
-                                  CPDF_PageObject* pObj,
-                                  const CFX_Matrix* pObj2Device,
-                                  FX_BOOL bStdCS,
-                                  int blendType) {
+bool CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
+                               CPDF_PageObject* pObj,
+                               const CFX_Matrix* pObj2Device,
+                               bool bStdCS,
+                               int blendType) {
   m_pRenderStatus = pStatus;
   m_bStdCS = bStdCS;
   m_pImageObject = pObj->AsImage();
   m_BlendType = blendType;
   m_pObj2Device = pObj2Device;
   CPDF_Dictionary* pOC = m_pImageObject->GetImage()->GetOC();
   if (pOC && m_pRenderStatus->m_Options.m_pOCContext &&
       !m_pRenderStatus->m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
-    return FALSE;
+    return false;
   }
   m_ImageMatrix = m_pImageObject->m_Matrix;
   m_ImageMatrix.Concat(*pObj2Device);
   if (StartLoadDIBSource()) {
-    return TRUE;
+    return true;
   }
   return StartRenderDIBSource();
 }
 
-FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
-                                  const CFX_DIBSource* pDIBSource,
-                                  FX_ARGB bitmap_argb,
-                                  int bitmap_alpha,
-                                  const CFX_Matrix* pImage2Device,
-                                  uint32_t flags,
-                                  FX_BOOL bStdCS,
-                                  int blendType) {
+bool CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
+                               const CFX_DIBSource* pDIBSource,
+                               FX_ARGB bitmap_argb,
+                               int bitmap_alpha,
+                               const CFX_Matrix* pImage2Device,
+                               uint32_t flags,
+                               bool bStdCS,
+                               int blendType) {
   m_pRenderStatus = pStatus;
   m_pDIBSource = pDIBSource;
   m_FillArgb = bitmap_argb;
   m_BitmapAlpha = bitmap_alpha;
   m_ImageMatrix = *pImage2Device;
   m_Flags = flags;
   m_bStdCS = bStdCS;
   m_BlendType = blendType;
   return StartDIBSource();
 }
 
-FX_BOOL CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device) {
+bool CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device) {
   if (m_pRenderStatus->m_bPrint &&
       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
-    m_Result = FALSE;
-    return FALSE;
+    m_Result = false;
+    return false;
   }
   FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOuterRect();
   rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
   if (rect.IsEmpty()) {
-    return FALSE;
+    return false;
   }
   CFX_Matrix new_matrix = m_ImageMatrix;
   new_matrix.TranslateI(-rect.left, -rect.top);
   int width = rect.Width();
   int height = rect.Height();
   CFX_FxgeDevice bitmap_device1;
   if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Rgb32, nullptr))
-    return TRUE;
+    return true;
 
   bitmap_device1.GetBitmap()->Clear(0xffffff);
   {
     CPDF_RenderStatus bitmap_render;
     bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1,
                              nullptr, nullptr, nullptr, nullptr,
                              &m_pRenderStatus->m_Options, 0,
-                             m_pRenderStatus->m_bDropObjects, nullptr, TRUE);
+                             m_pRenderStatus->m_bDropObjects, nullptr, true);
     CFX_Matrix patternDevice = *pObj2Device;
     patternDevice.Translate((FX_FLOAT)-rect.left, (FX_FLOAT)-rect.top);
     if (CPDF_TilingPattern* pTilingPattern = m_pPattern->AsTilingPattern()) {
       bitmap_render.DrawTilingPattern(pTilingPattern, m_pImageObject,
-                                      &patternDevice, FALSE);
+                                      &patternDevice, false);
     } else if (CPDF_ShadingPattern* pShadingPattern =
                    m_pPattern->AsShadingPattern()) {
       bitmap_render.DrawShadingPattern(pShadingPattern, m_pImageObject,
-                                       &patternDevice, FALSE);
+                                       &patternDevice, false);
     }
   }
   {
     CFX_FxgeDevice bitmap_device2;
     if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb,
                                nullptr)) {
-      return TRUE;
+      return true;
     }
     bitmap_device2.GetBitmap()->Clear(0);
     CPDF_RenderStatus bitmap_render;
     bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2,
                              nullptr, nullptr, nullptr, nullptr, nullptr, 0,
-                             m_pRenderStatus->m_bDropObjects, nullptr, TRUE);
+                             m_pRenderStatus->m_bDropObjects, nullptr, true);
     CPDF_ImageRenderer image_render;
     if (image_render.Start(&bitmap_render, m_pDIBSource, 0xffffffff, 255,
-                           &new_matrix, m_Flags, TRUE)) {
+                           &new_matrix, m_Flags, true)) {
       image_render.Continue(nullptr);
     }
     if (m_Loader.m_MatteColor != 0xffffffff) {
       int matte_r = FXARGB_R(m_Loader.m_MatteColor);
       int matte_g = FXARGB_G(m_Loader.m_MatteColor);
       int matte_b = FXARGB_B(m_Loader.m_MatteColor);
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan =
             (uint8_t*)bitmap_device1.GetBitmap()->GetScanline(row);
         const uint8_t* mask_scan = bitmap_device2.GetBitmap()->GetScanline(row);
@@ skipping 27 matching lines @@
           }
         }
       }
     }
     bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
     bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
     bitmap_device1.GetBitmap()->MultiplyAlpha(255);
   }
   m_pRenderStatus->m_pDevice->SetDIBitsWithBlend(
       bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_ImageRenderer::DrawMaskedImage() {
+bool CPDF_ImageRenderer::DrawMaskedImage() {
   if (m_pRenderStatus->m_bPrint &&
       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
-    m_Result = FALSE;
-    return FALSE;
+    m_Result = false;
+    return false;
   }
   FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOuterRect();
   rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
   if (rect.IsEmpty()) {
-    return FALSE;
+    return false;
   }
   CFX_Matrix new_matrix = m_ImageMatrix;
   new_matrix.TranslateI(-rect.left, -rect.top);
   int width = rect.Width();
   int height = rect.Height();
   CFX_FxgeDevice bitmap_device1;
   if (!bitmap_device1.Create(width, height, FXDIB_Rgb32, nullptr))
-    return TRUE;
+    return true;
 
 #if defined _SKIA_SUPPORT_
   bitmap_device1.Clear(0xffffff);
 #else
   bitmap_device1.GetBitmap()->Clear(0xffffff);
 #endif
   {
     CPDF_RenderStatus bitmap_render;
     bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1,
                              nullptr, nullptr, nullptr, nullptr, nullptr, 0,
-                             m_pRenderStatus->m_bDropObjects, nullptr, TRUE);
+                             m_pRenderStatus->m_bDropObjects, nullptr, true);
     CPDF_ImageRenderer image_render;
     if (image_render.Start(&bitmap_render, m_pDIBSource, 0, 255, &new_matrix,
-                           m_Flags, TRUE)) {
+                           m_Flags, true)) {
       image_render.Continue(nullptr);
     }
   }
   {
     CFX_FxgeDevice bitmap_device2;
     if (!bitmap_device2.Create(width, height, FXDIB_8bppRgb, nullptr))
-      return TRUE;
+      return true;
 
 #if defined _SKIA_SUPPORT_
     bitmap_device2.Clear(0);
 #else
     bitmap_device2.GetBitmap()->Clear(0);
 #endif
     CPDF_RenderStatus bitmap_render;
     bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2,
                              nullptr, nullptr, nullptr, nullptr, nullptr, 0,
-                             m_pRenderStatus->m_bDropObjects, nullptr, TRUE);
+                             m_pRenderStatus->m_bDropObjects, nullptr, true);
     CPDF_ImageRenderer image_render;
     if (image_render.Start(&bitmap_render, m_Loader.m_pMask, 0xffffffff, 255,
-                           &new_matrix, m_Flags, TRUE)) {
+                           &new_matrix, m_Flags, true)) {
       image_render.Continue(nullptr);
     }
     if (m_Loader.m_MatteColor != 0xffffffff) {
       int matte_r = FXARGB_R(m_Loader.m_MatteColor);
       int matte_g = FXARGB_G(m_Loader.m_MatteColor);
       int matte_b = FXARGB_B(m_Loader.m_MatteColor);
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan =
             (uint8_t*)bitmap_device1.GetBitmap()->GetScanline(row);
         const uint8_t* mask_scan = bitmap_device2.GetBitmap()->GetScanline(row);
@@ skipping 36 matching lines @@
 #else
     bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
     bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
     if (m_BitmapAlpha < 255) {
       bitmap_device1.GetBitmap()->MultiplyAlpha(m_BitmapAlpha);
     }
   }
   m_pRenderStatus->m_pDevice->SetDIBitsWithBlend(
       bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
 #endif  //  _SKIA_SUPPORT_
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_ImageRenderer::StartDIBSource() {
+bool CPDF_ImageRenderer::StartDIBSource() {
   if (!(m_Flags & RENDER_FORCE_DOWNSAMPLE) && m_pDIBSource->GetBPP() > 1) {
     FX_SAFE_SIZE_T image_size = m_pDIBSource->GetBPP();
     image_size /= 8;
     image_size *= m_pDIBSource->GetWidth();
     image_size *= m_pDIBSource->GetHeight();
     if (!image_size.IsValid()) {
-      return FALSE;
+      return false;
     }
 
     if (image_size.ValueOrDie() > FPDF_HUGE_IMAGE_SIZE &&
         !(m_Flags & RENDER_FORCE_HALFTONE)) {
       m_Flags |= RENDER_FORCE_DOWNSAMPLE;
     }
   }
 #ifdef _SKIA_SUPPORT_
   CFX_DIBitmap* premultiplied = m_pDIBSource->Clone();
   if (m_pDIBSource->HasAlpha())
     CFX_SkiaDeviceDriver::PreMultiply(premultiplied);
   if (m_pRenderStatus->m_pDevice->StartDIBitsWithBlend(
           premultiplied, m_BitmapAlpha, m_FillArgb, &m_ImageMatrix, m_Flags,
           m_DeviceHandle, m_BlendType)) {
     if (m_DeviceHandle) {
       m_Status = 3;
-      return TRUE;
+      return true;
     }
-    return FALSE;
+    return false;
   }
 #else
   if (m_pRenderStatus->m_pDevice->StartDIBitsWithBlend(
           m_pDIBSource, m_BitmapAlpha, m_FillArgb, &m_ImageMatrix, m_Flags,
           m_DeviceHandle, m_BlendType)) {
     if (m_DeviceHandle) {
       m_Status = 3;
-      return TRUE;
+      return true;
     }
-    return FALSE;
+    return false;
   }
 #endif
   CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
   FX_RECT image_rect = image_rect_f.GetOuterRect();
   int dest_width = image_rect.Width();
   int dest_height = image_rect.Height();
   if ((FXSYS_fabs(m_ImageMatrix.b) >= 0.5f || m_ImageMatrix.a == 0) ||
       (FXSYS_fabs(m_ImageMatrix.c) >= 0.5f || m_ImageMatrix.d == 0)) {
     if (m_pRenderStatus->m_bPrint &&
         !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
-      m_Result = FALSE;
-      return FALSE;
+      m_Result = false;
+      return false;
     }
     FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox();
     clip_box.Intersect(image_rect);
     m_Status = 2;
     m_pTransformer.reset(new CFX_ImageTransformer(m_pDIBSource, &m_ImageMatrix,
                                                   m_Flags, &clip_box));
     m_pTransformer->Start();
-    return TRUE;
+    return true;
   }
   if (m_ImageMatrix.a < 0)
     dest_width = -dest_width;
 
   if (m_ImageMatrix.d > 0)
     dest_height = -dest_height;
 
   int dest_left = dest_width > 0 ? image_rect.left : image_rect.right;
   int dest_top = dest_height > 0 ? image_rect.top : image_rect.bottom;
   if (m_pDIBSource->IsOpaqueImage() && m_BitmapAlpha == 255) {
     if (m_pRenderStatus->m_pDevice->StretchDIBitsWithFlagsAndBlend(
             m_pDIBSource, dest_left, dest_top, dest_width, dest_height, m_Flags,
             m_BlendType)) {
-      return FALSE;
+      return false;
     }
   }
   if (m_pDIBSource->IsAlphaMask()) {
     if (m_BitmapAlpha != 255)
       m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
     if (m_pRenderStatus->m_pDevice->StretchBitMaskWithFlags(
             m_pDIBSource, dest_left, dest_top, dest_width, dest_height,
             m_FillArgb, m_Flags)) {
-      return FALSE;
+      return false;
     }
   }
   if (m_pRenderStatus->m_bPrint &&
       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
-    m_Result = FALSE;
-    return TRUE;
+    m_Result = false;
+    return true;
   }
 
   FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox();
   FX_RECT dest_rect = clip_box;
   dest_rect.Intersect(image_rect);
   FX_RECT dest_clip(
       dest_rect.left - image_rect.left, dest_rect.top - image_rect.top,
       dest_rect.right - image_rect.left, dest_rect.bottom - image_rect.top);
   std::unique_ptr<CFX_DIBitmap> pStretched(
       m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip));
   if (pStretched) {
     m_pRenderStatus->CompositeDIBitmap(pStretched.get(), dest_rect.left,
                                        dest_rect.top, m_FillArgb, m_BitmapAlpha,
-                                       m_BlendType, FALSE);
+                                       m_BlendType, false);
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha() {
+bool CPDF_ImageRenderer::StartBitmapAlpha() {
   if (m_pDIBSource->IsOpaqueImage()) {
     CFX_PathData path;
     path.AppendRect(0, 0, 1, 1);
     path.Transform(&m_ImageMatrix);
     uint32_t fill_color =
         ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha);
     m_pRenderStatus->m_pDevice->DrawPath(&path, nullptr, nullptr, fill_color, 0,
                                          FXFILL_WINDING);
   } else {
     const CFX_DIBSource* pAlphaMask = m_pDIBSource->IsAlphaMask()
                                           ? m_pDIBSource
                                           : m_pDIBSource->GetAlphaMask();
     if (FXSYS_fabs(m_ImageMatrix.b) >= 0.5f ||
         FXSYS_fabs(m_ImageMatrix.c) >= 0.5f) {
       int left, top;
       std::unique_ptr<CFX_DIBitmap> pTransformed(
           pAlphaMask->TransformTo(&m_ImageMatrix, left, top));
       if (!pTransformed)
-        return TRUE;
+        return true;
 
       m_pRenderStatus->m_pDevice->SetBitMask(
           pTransformed.get(), left, top,
           ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
     } else {
       CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
       FX_RECT image_rect = image_rect_f.GetOuterRect();
       int dest_width =
           m_ImageMatrix.a > 0 ? image_rect.Width() : -image_rect.Width();
       int dest_height =
           m_ImageMatrix.d > 0 ? -image_rect.Height() : image_rect.Height();
       int left = dest_width > 0 ? image_rect.left : image_rect.right;
       int top = dest_height > 0 ? image_rect.top : image_rect.bottom;
       m_pRenderStatus->m_pDevice->StretchBitMask(
           pAlphaMask, left, top, dest_width, dest_height,
           ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
     }
     if (m_pDIBSource != pAlphaMask) {
       delete pAlphaMask;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_ImageRenderer::Continue(IFX_Pause* pPause) {
+bool CPDF_ImageRenderer::Continue(IFX_Pause* pPause) {
   if (m_Status == 2) {
     if (m_pTransformer->Continue(pPause))
-      return TRUE;
+      return true;
 
     std::unique_ptr<CFX_DIBitmap> pBitmap(m_pTransformer->DetachBitmap());
     if (!pBitmap)
-      return FALSE;
+      return false;
 
     if (pBitmap->IsAlphaMask()) {
       if (m_BitmapAlpha != 255)
         m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
       m_Result = m_pRenderStatus->m_pDevice->SetBitMask(
           pBitmap.get(), m_pTransformer->result().left,
           m_pTransformer->result().top, m_FillArgb);
     } else {
       if (m_BitmapAlpha != 255)
         pBitmap->MultiplyAlpha(m_BitmapAlpha);
       m_Result = m_pRenderStatus->m_pDevice->SetDIBitsWithBlend(
           pBitmap.get(), m_pTransformer->result().left,
           m_pTransformer->result().top, m_BlendType);
     }
-    return FALSE;
+    return false;
   }
   if (m_Status == 3)
     return m_pRenderStatus->m_pDevice->ContinueDIBits(m_DeviceHandle, pPause);
 
   if (m_Status == 4) {
     if (m_Loader.Continue(m_LoadHandle.get(), pPause))
-      return TRUE;
+      return true;
 
     if (StartRenderDIBSource())
       return Continue(pPause);
   }
-  return FALSE;
+  return false;
 }
 
 CCodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
     const uint8_t* src_buf,
     uint32_t src_size,
     int width,
     int height,
     int nComps,
     int bpc,
     const CPDF_Dictionary* pParams);
@@ skipping 14 matching lines @@
     pFunc = CPDF_Function::Load(pFuncObj);
 
   CFX_Matrix matrix = *pMatrix;
   matrix.TranslateI(-pClipRect->left, -pClipRect->top);
 
   CPDF_Form form(m_pContext->GetDocument(), m_pContext->GetPageResources(),
                  pGroup);
   form.ParseContent(nullptr, nullptr, nullptr);
 
   CFX_FxgeDevice bitmap_device;
-  FX_BOOL bLuminosity = pSMaskDict->GetStringFor("S") != "Alpha";
+  bool bLuminosity = pSMaskDict->GetStringFor("S") != "Alpha";
   int width = pClipRect->right - pClipRect->left;
   int height = pClipRect->bottom - pClipRect->top;
   FXDIB_Format format;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ || defined _SKIA_SUPPORT_
   format = bLuminosity ? FXDIB_Rgb32 : FXDIB_8bppMask;
 #else
   format = bLuminosity ? FXDIB_Rgb : FXDIB_8bppMask;
 #endif
   if (!bitmap_device.Create(width, height, format, nullptr))
     return nullptr;
@@ skipping 43 matching lines @@
     bitmap.Clear(0);
   }
   CPDF_Dictionary* pFormResource = nullptr;
   if (form.m_pFormDict) {
     pFormResource = form.m_pFormDict->GetDictFor("Resources");
   }
   CPDF_RenderOptions options;
   options.m_ColorMode = bLuminosity ? RENDER_COLOR_NORMAL : RENDER_COLOR_ALPHA;
   CPDF_RenderStatus status;
   status.Initialize(m_pContext, &bitmap_device, nullptr, nullptr, nullptr,
-                    nullptr, &options, 0, m_bDropObjects, pFormResource, TRUE,
+                    nullptr, &options, 0, m_bDropObjects, pFormResource, true,
                     nullptr, 0, color_space_family, bLuminosity);
   status.RenderObjectList(&form, &matrix);
   std::unique_ptr<CFX_DIBitmap> pMask(new CFX_DIBitmap);
   if (!pMask->Create(width, height, FXDIB_8bppMask))
     return nullptr;
 
   uint8_t* dest_buf = pMask->GetBuffer();
   int dest_pitch = pMask->GetPitch();
   uint8_t* src_buf = bitmap.GetBuffer();
   int src_pitch = bitmap.GetPitch();
@@ skipping 24 matching lines @@
   } else if (pFunc) {
     int size = dest_pitch * height;
     for (int i = 0; i < size; i++) {
       dest_buf[i] = transfers[src_buf[i]];
     }
   } else {
     FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height);
   }
   return pMask.release();
 }