Remove FX_BOOL from core

core/fpdfapi/render/fpdf_render_loadimage.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 <algorithm>
 #include <memory>
@@ skipping 84 matching lines @@
     : m_pDocument(nullptr),
       m_pStream(nullptr),
       m_pDict(nullptr),
       m_pColorSpace(nullptr),
       m_Family(0),
       m_bpc(0),
       m_bpc_orig(0),
       m_nComponents(0),
       m_GroupFamily(0),
       m_MatteColor(0),
-      m_bLoadMask(FALSE),
-      m_bDefaultDecode(TRUE),
-      m_bImageMask(FALSE),
-      m_bDoBpcCheck(TRUE),
-      m_bColorKey(FALSE),
-      m_bHasMask(FALSE),
-      m_bStdCS(FALSE),
+      m_bLoadMask(false),
+      m_bDefaultDecode(true),
+      m_bImageMask(false),
+      m_bDoBpcCheck(true),
+      m_bColorKey(false),
+      m_bHasMask(false),
+      m_bStdCS(false),
       m_pCompData(nullptr),
       m_pLineBuf(nullptr),
       m_pMaskedLine(nullptr),
       m_pMask(nullptr),
       m_pMaskStream(nullptr),
       m_Status(0) {}
 
 CPDF_DIBSource::~CPDF_DIBSource() {
   FX_Free(m_pMaskedLine);
   FX_Free(m_pLineBuf);
   m_pCachedBitmap.reset();
   FX_Free(m_pCompData);
   CPDF_ColorSpace* pCS = m_pColorSpace;
   if (pCS && m_pDocument) {
     m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
   }
 }
 
 CFX_DIBitmap* CPDF_DIBSource::GetBitmap() const {
   return m_pCachedBitmap ? m_pCachedBitmap.get() : Clone();
 }
 
 void CPDF_DIBSource::ReleaseBitmap(CFX_DIBitmap* pBitmap) const {
   if (pBitmap && pBitmap != m_pCachedBitmap.get()) {
     delete pBitmap;
   }
 }
 
-FX_BOOL CPDF_DIBSource::Load(CPDF_Document* pDoc,
-                             const CPDF_Stream* pStream,
-                             CPDF_DIBSource** ppMask,
-                             uint32_t* pMatteColor,
-                             CPDF_Dictionary* pFormResources,
-                             CPDF_Dictionary* pPageResources,
-                             FX_BOOL bStdCS,
-                             uint32_t GroupFamily,
-                             FX_BOOL bLoadMask) {
+bool CPDF_DIBSource::Load(CPDF_Document* pDoc,
+                          const CPDF_Stream* pStream,
+                          CPDF_DIBSource** ppMask,
+                          uint32_t* pMatteColor,
+                          CPDF_Dictionary* pFormResources,
+                          CPDF_Dictionary* pPageResources,
+                          bool bStdCS,
+                          uint32_t GroupFamily,
+                          bool bLoadMask) {
   if (!pStream) {
-    return FALSE;
+    return false;
   }
   m_pDocument = pDoc;
   m_pDict = pStream->GetDict();
   if (!m_pDict) {
-    return FALSE;
+    return false;
   }
   m_pStream = pStream;
   m_Width = m_pDict->GetIntegerFor("Width");
   m_Height = m_pDict->GetIntegerFor("Height");
   if (m_Width <= 0 || m_Height <= 0 || m_Width > kMaxImageDimension ||
       m_Height > kMaxImageDimension) {
-    return FALSE;
+    return false;
   }
   m_GroupFamily = GroupFamily;
   m_bLoadMask = bLoadMask;
   if (!LoadColorInfo(m_pStream->IsInline() ? pFormResources : nullptr,
                      pPageResources)) {
-    return FALSE;
+    return false;
   }
   if (m_bDoBpcCheck && (m_bpc == 0 || m_nComponents == 0)) {
-    return FALSE;
+    return false;
   }
   FX_SAFE_UINT32 src_size =
       CalculatePitch8(m_bpc, m_nComponents, m_Width) * m_Height;
   if (!src_size.IsValid()) {
-    return FALSE;
+    return false;
   }
   m_pStreamAcc.reset(new CPDF_StreamAcc);
-  m_pStreamAcc->LoadAllData(pStream, FALSE, src_size.ValueOrDie(), TRUE);
+  m_pStreamAcc->LoadAllData(pStream, false, src_size.ValueOrDie(), true);
   if (m_pStreamAcc->GetSize() == 0 || !m_pStreamAcc->GetData()) {
-    return FALSE;
+    return false;
   }
   if (!CreateDecoder()) {
-    return FALSE;
+    return false;
   }
   if (m_bImageMask) {
     m_bpp = 1;
     m_bpc = 1;
     m_nComponents = 1;
     m_AlphaFlag = 1;
   } else if (m_bpc * m_nComponents == 1) {
     m_bpp = 1;
   } else if (m_bpc * m_nComponents <= 8) {
     m_bpp = 8;
   } else {
     m_bpp = 24;
   }
   FX_SAFE_UINT32 pitch = CalculatePitch32(m_bpp, m_Width);
   if (!pitch.IsValid()) {
-    return FALSE;
+    return false;
   }
   m_pLineBuf = FX_Alloc(uint8_t, pitch.ValueOrDie());
   if (m_pColorSpace && bStdCS) {
-    m_pColorSpace->EnableStdConversion(TRUE);
+    m_pColorSpace->EnableStdConversion(true);
   }
   LoadPalette();
   if (m_bColorKey) {
     m_bpp = 32;
     m_AlphaFlag = 2;
     pitch = CalculatePitch32(m_bpp, m_Width);
     if (!pitch.IsValid()) {
-      return FALSE;
+      return false;
     }
     m_pMaskedLine = FX_Alloc(uint8_t, pitch.ValueOrDie());
   }
   m_Pitch = pitch.ValueOrDie();
   if (ppMask) {
     *ppMask = LoadMask(*pMatteColor);
   }
   if (m_pColorSpace && bStdCS) {
-    m_pColorSpace->EnableStdConversion(FALSE);
+    m_pColorSpace->EnableStdConversion(false);
   }
-  return TRUE;
+  return true;
 }
 
 int CPDF_DIBSource::ContinueToLoadMask() {
   if (m_bImageMask) {
     m_bpp = 1;
     m_bpc = 1;
     m_nComponents = 1;
     m_AlphaFlag = 1;
   } else if (m_bpc * m_nComponents == 1) {
     m_bpp = 1;
   } else if (m_bpc * m_nComponents <= 8) {
     m_bpp = 8;
   } else {
     m_bpp = 24;
   }
   if (!m_bpc || !m_nComponents) {
     return 0;
   }
   FX_SAFE_UINT32 pitch = CalculatePitch32(m_bpp, m_Width);
   if (!pitch.IsValid()) {
     return 0;
   }
   m_pLineBuf = FX_Alloc(uint8_t, pitch.ValueOrDie());
   if (m_pColorSpace && m_bStdCS) {
-    m_pColorSpace->EnableStdConversion(TRUE);
+    m_pColorSpace->EnableStdConversion(true);
   }
   LoadPalette();
   if (m_bColorKey) {
     m_bpp = 32;
     m_AlphaFlag = 2;
     pitch = CalculatePitch32(m_bpp, m_Width);
     if (!pitch.IsValid()) {
       return 0;
     }
     m_pMaskedLine = FX_Alloc(uint8_t, pitch.ValueOrDie());
   }
   m_Pitch = pitch.ValueOrDie();
   return 1;
 }
 
 int CPDF_DIBSource::StartLoadDIBSource(CPDF_Document* pDoc,
                                        const CPDF_Stream* pStream,
-                                       FX_BOOL bHasMask,
+                                       bool bHasMask,
                                        CPDF_Dictionary* pFormResources,
                                        CPDF_Dictionary* pPageResources,
-                                       FX_BOOL bStdCS,
+                                       bool bStdCS,
                                        uint32_t GroupFamily,
-                                       FX_BOOL bLoadMask) {
+                                       bool bLoadMask) {
   if (!pStream) {
     return 0;
   }
   m_pDocument = pDoc;
   m_pDict = pStream->GetDict();
   m_pStream = pStream;
   m_bStdCS = bStdCS;
   m_bHasMask = bHasMask;
   m_Width = m_pDict->GetIntegerFor("Width");
   m_Height = m_pDict->GetIntegerFor("Height");
   if (m_Width <= 0 || m_Height <= 0 || m_Width > kMaxImageDimension ||
       m_Height > kMaxImageDimension) {
     return 0;
   }
   m_GroupFamily = GroupFamily;
   m_bLoadMask = bLoadMask;
   if (!LoadColorInfo(m_pStream->IsInline() ? pFormResources : nullptr,
                      pPageResources)) {
     return 0;
   }
   if (m_bDoBpcCheck && (m_bpc == 0 || m_nComponents == 0)) {
     return 0;
   }
   FX_SAFE_UINT32 src_size =
       CalculatePitch8(m_bpc, m_nComponents, m_Width) * m_Height;
   if (!src_size.IsValid()) {
     return 0;
   }
   m_pStreamAcc.reset(new CPDF_StreamAcc);
-  m_pStreamAcc->LoadAllData(pStream, FALSE, src_size.ValueOrDie(), TRUE);
+  m_pStreamAcc->LoadAllData(pStream, false, src_size.ValueOrDie(), true);
   if (m_pStreamAcc->GetSize() == 0 || !m_pStreamAcc->GetData()) {
     return 0;
   }
   int ret = CreateDecoder();
   if (!ret)
     return ret;
 
   if (ret != 1) {
     if (!ContinueToLoadMask()) {
       return 0;
     }
     if (m_bHasMask) {
       StratLoadMask();
     }
     return ret;
   }
   if (!ContinueToLoadMask()) {
     return 0;
   }
   if (m_bHasMask) {
     ret = StratLoadMask();
   }
   if (ret == 2) {
     return ret;
   }
   if (m_pColorSpace && m_bStdCS) {
-    m_pColorSpace->EnableStdConversion(FALSE);
+    m_pColorSpace->EnableStdConversion(false);
   }
   return ret;
 }
 
 int CPDF_DIBSource::ContinueLoadDIBSource(IFX_Pause* pPause) {
   FXCODEC_STATUS ret;
   if (m_Status == 1) {
     const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
     if (decoder == "JPXDecode") {
       return 0;
     }
     CCodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
     if (!m_pJbig2Context) {
       m_pJbig2Context.reset(new CCodec_Jbig2Context());
       if (m_pStreamAcc->GetImageParam()) {
         CPDF_Stream* pGlobals =
             m_pStreamAcc->GetImageParam()->GetStreamFor("JBIG2Globals");
         if (pGlobals) {
           m_pGlobalStream.reset(new CPDF_StreamAcc);
-          m_pGlobalStream->LoadAllData(pGlobals, FALSE);
+          m_pGlobalStream->LoadAllData(pGlobals, false);
         }
       }
       ret = pJbig2Module->StartDecode(
           m_pJbig2Context.get(), m_pDocument->CodecContext(), m_Width, m_Height,
           m_pStreamAcc.get(), m_pGlobalStream.get(),
           m_pCachedBitmap->GetBuffer(), m_pCachedBitmap->GetPitch(), pPause);
       if (ret < 0) {
         m_pCachedBitmap.reset();
         m_pGlobalStream.reset();
         m_pJbig2Context.reset();
         return 0;
       }
       if (ret == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
         return 2;
       }
       int ret1 = 1;
       if (m_bHasMask) {
         ret1 = ContinueLoadMaskDIB(pPause);
         m_Status = 2;
       }
       if (ret1 == 2) {
         return ret1;
       }
       if (m_pColorSpace && m_bStdCS) {
-        m_pColorSpace->EnableStdConversion(FALSE);
+        m_pColorSpace->EnableStdConversion(false);
       }
       return ret1;
     }
     ret = pJbig2Module->ContinueDecode(m_pJbig2Context.get(), pPause);
     if (ret < 0) {
       m_pCachedBitmap.reset();
       m_pGlobalStream.reset();
       m_pJbig2Context.reset();
       return 0;
     }
     if (ret == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       return 2;
     }
     int ret1 = 1;
     if (m_bHasMask) {
       ret1 = ContinueLoadMaskDIB(pPause);
       m_Status = 2;
     }
     if (ret1 == 2) {
       return ret1;
     }
     if (m_pColorSpace && m_bStdCS) {
-      m_pColorSpace->EnableStdConversion(FALSE);
+      m_pColorSpace->EnableStdConversion(false);
     }
     return ret1;
   }
   if (m_Status == 2) {
     return ContinueLoadMaskDIB(pPause);
   }
   return 0;
 }
 
 bool CPDF_DIBSource::LoadColorInfo(const CPDF_Dictionary* pFormResources,
                                    const CPDF_Dictionary* pPageResources) {
   m_bpc_orig = m_pDict->GetIntegerFor("BitsPerComponent");
   if (m_pDict->GetIntegerFor("ImageMask"))
-    m_bImageMask = TRUE;
+    m_bImageMask = true;
 
   if (m_bImageMask || !m_pDict->KeyExist("ColorSpace")) {
     if (!m_bImageMask) {
       CPDF_Object* pFilter = m_pDict->GetDirectObjectFor("Filter");
       if (pFilter) {
         CFX_ByteString filter;
         if (pFilter->IsName()) {
           filter = pFilter->GetString();
         } else if (CPDF_Array* pArray = pFilter->AsArray()) {
           filter = pArray->GetStringAt(pArray->GetCount() - 1);
         }
 
         if (filter == "JPXDecode") {
-          m_bDoBpcCheck = FALSE;
+          m_bDoBpcCheck = false;
           return true;
         }
       }
     }
-    m_bImageMask = TRUE;
+    m_bImageMask = true;
     m_bpc = m_nComponents = 1;
     CPDF_Array* pDecode = m_pDict->GetArrayFor("Decode");
     m_bDefaultDecode = !pDecode || !pDecode->GetIntegerAt(0);
     return true;
   }
 
   CPDF_Object* pCSObj = m_pDict->GetDirectObjectFor("ColorSpace");
   if (!pCSObj)
     return false;
 
@@ skipping 15 matching lines @@
       m_nComponents = 3;
     } else if (cs == "DeviceCMYK") {
       m_nComponents = 4;
     }
   }
   ValidateDictParam();
   m_pCompData = GetDecodeAndMaskArray(m_bDefaultDecode, m_bColorKey);
   return !!m_pCompData;
 }
 
-DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode,
-                                                     FX_BOOL& bColorKey) {
+DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(bool& bDefaultDecode,
+                                                     bool& bColorKey) {
   if (!m_pColorSpace) {
     return nullptr;
   }
   DIB_COMP_DATA* pCompData = FX_Alloc(DIB_COMP_DATA, m_nComponents);
   int max_data = (1 << m_bpc) - 1;
   CPDF_Array* pDecode = m_pDict->GetArrayFor("Decode");
   if (pDecode) {
     for (uint32_t i = 0; i < m_nComponents; i++) {
       pCompData[i].m_DecodeMin = pDecode->GetNumberAt(i * 2);
       FX_FLOAT max = pDecode->GetNumberAt(i * 2 + 1);
       pCompData[i].m_DecodeStep = (max - pCompData[i].m_DecodeMin) / max_data;
       FX_FLOAT def_value;
       FX_FLOAT def_min;
       FX_FLOAT def_max;
       m_pColorSpace->GetDefaultValue(i, def_value, def_min, def_max);
       if (m_Family == PDFCS_INDEXED) {
         def_max = max_data;
       }
       if (def_min != pCompData[i].m_DecodeMin || def_max != max) {
-        bDefaultDecode = FALSE;
+        bDefaultDecode = false;
       }
     }
   } else {
     for (uint32_t i = 0; i < m_nComponents; i++) {
       FX_FLOAT def_value;
       m_pColorSpace->GetDefaultValue(i, def_value, pCompData[i].m_DecodeMin,
                                      pCompData[i].m_DecodeStep);
       if (m_Family == PDFCS_INDEXED) {
         pCompData[i].m_DecodeStep = max_data;
       }
       pCompData[i].m_DecodeStep =
           (pCompData[i].m_DecodeStep - pCompData[i].m_DecodeMin) / max_data;
     }
   }
   if (!m_pDict->KeyExist("SMask")) {
     CPDF_Object* pMask = m_pDict->GetDirectObjectFor("Mask");
     if (!pMask) {
       return pCompData;
     }
     if (CPDF_Array* pArray = pMask->AsArray()) {
       if (pArray->GetCount() >= m_nComponents * 2) {
         for (uint32_t i = 0; i < m_nComponents; i++) {
           int min_num = pArray->GetIntegerAt(i * 2);
           int max_num = pArray->GetIntegerAt(i * 2 + 1);
           pCompData[i].m_ColorKeyMin = std::max(min_num, 0);
           pCompData[i].m_ColorKeyMax = std::min(max_num, max_data);
         }
       }
-      bColorKey = TRUE;
+      bColorKey = true;
     }
   }
   return pCompData;
 }
 
 CCodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
     const uint8_t* src_buf,
     uint32_t src_size,
     int width,
     int height,
@@ skipping 102 matching lines @@
   if (!context->decoder())
     return;
 
   uint32_t width = 0;
   uint32_t height = 0;
   uint32_t components = 0;
   pJpxModule->GetImageInfo(context->decoder(), &width, &height, &components);
   if (static_cast<int>(width) < m_Width || static_cast<int>(height) < m_Height)
     return;
 
-  FX_BOOL bSwapRGB = FALSE;
+  bool bSwapRGB = false;
   if (m_pColorSpace) {
     if (components != m_pColorSpace->CountComponents())
       return;
 
     if (m_pColorSpace == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB)) {
-      bSwapRGB = TRUE;
+      bSwapRGB = true;
       m_pColorSpace = nullptr;
     }
   } else {
     if (components == 3) {
-      bSwapRGB = TRUE;
+      bSwapRGB = true;
     } else if (components == 4) {
       m_pColorSpace = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
     }
     m_nComponents = components;
   }
 
   FXDIB_Format format;
   if (components == 1) {
     format = FXDIB_8bppRgb;
   } else if (components <= 3) {
@@ skipping 88 matching lines @@
 
 int CPDF_DIBSource::ContinueLoadMaskDIB(IFX_Pause* pPause) {
   if (!m_pMask) {
     return 1;
   }
   int ret = m_pMask->ContinueLoadDIBSource(pPause);
   if (ret == 2) {
     return ret;
   }
   if (m_pColorSpace && m_bStdCS) {
-    m_pColorSpace->EnableStdConversion(FALSE);
+    m_pColorSpace->EnableStdConversion(false);
   }
   if (!ret) {
     delete m_pMask;
     m_pMask = nullptr;
     return ret;
   }
   return 1;
 }
 
 CPDF_DIBSource* CPDF_DIBSource::DetachMask() {
   CPDF_DIBSource* pDIBSource = m_pMask;
   m_pMask = nullptr;
   return pDIBSource;
 }
 
 CPDF_DIBSource* CPDF_DIBSource::LoadMaskDIB(CPDF_Stream* pMask) {
   CPDF_DIBSource* pMaskSource = new CPDF_DIBSource;
   if (!pMaskSource->Load(m_pDocument, pMask, nullptr, nullptr, nullptr, nullptr,
-                         TRUE)) {
+                         true)) {
     delete pMaskSource;
     return nullptr;
   }
   return pMaskSource;
 }
 
 int CPDF_DIBSource::StartLoadMaskDIB() {
   m_pMask = new CPDF_DIBSource;
-  int ret = m_pMask->StartLoadDIBSource(m_pDocument, m_pMaskStream, FALSE,
-                                        nullptr, nullptr, TRUE);
+  int ret = m_pMask->StartLoadDIBSource(m_pDocument, m_pMaskStream, false,
+                                        nullptr, nullptr, true);
   if (ret == 2) {
     if (m_Status == 0)
       m_Status = 2;
     return 2;
   }
   if (!ret) {
     delete m_pMask;
     m_pMask = nullptr;
     return 1;
   }
@@ skipping 347 matching lines @@
       *pDestPixel++ = *pSrcPixel++;
       *pDestPixel++ = *pSrcPixel++;
       *pDestPixel++ = *pSrcPixel++;
       pDestPixel++;
     }
     return m_pMaskedLine;
   }
   return pSrcLine;
 }
 
-FX_BOOL CPDF_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const {
+bool CPDF_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const {
   return m_pDecoder && m_pDecoder->SkipToScanline(line, pPause);
 }
 
 void CPDF_DIBSource::DownSampleScanline(int line,
                                         uint8_t* dest_scan,
                                         int dest_bpp,
                                         int dest_width,
-                                        FX_BOOL bFlipX,
+                                        bool bFlipX,
                                         int clip_left,
                                         int clip_width) const {
   if (line < 0 || !dest_scan || dest_bpp <= 0 || dest_width <= 0 ||
       clip_left < 0 || clip_width <= 0) {
     return;
   }
 
   uint32_t src_width = m_Width;
   FX_SAFE_UINT32 pitch = CalculatePitch8(m_bpc, m_nComponents, m_Width);
   if (!pitch.IsValid())
@@ skipping 40 matching lines @@
                             dest_width, bFlipX, clip_left, clip_width);
   }
 }
 
 void CPDF_DIBSource::DownSampleScanline1Bit(int orig_Bpp,
                                             int dest_Bpp,
                                             uint32_t src_width,
                                             const uint8_t* pSrcLine,
                                             uint8_t* dest_scan,
                                             int dest_width,
-                                            FX_BOOL bFlipX,
+                                            bool bFlipX,
                                             int clip_left,
                                             int clip_width) const {
   uint32_t set_argb = (uint32_t)-1;
   uint32_t reset_argb = 0;
   if (m_bImageMask) {
     if (m_bDefaultDecode) {
       set_argb = 0;
       reset_argb = (uint32_t)-1;
     }
   } else if (m_bColorKey) {
@@ skipping 58 matching lines @@
     }
   }
 }
 
 void CPDF_DIBSource::DownSampleScanline8Bit(int orig_Bpp,
                                             int dest_Bpp,
                                             uint32_t src_width,
                                             const uint8_t* pSrcLine,
                                             uint8_t* dest_scan,
                                             int dest_width,
-                                            FX_BOOL bFlipX,
+                                            bool bFlipX,
                                             int clip_left,
                                             int clip_width) const {
   if (m_bpc < 8) {
     uint64_t src_bit_pos = 0;
     for (uint32_t col = 0; col < src_width; col++) {
       unsigned int color_index = 0;
       for (uint32_t color = 0; color < m_nComponents; color++) {
         unsigned int data = GetBits8(pSrcLine, src_bit_pos, m_bpc);
         color_index |= data << (color * m_bpc);
         src_bit_pos += m_bpc;
@@ skipping 45 matching lines @@
     }
   }
 }
 
 void CPDF_DIBSource::DownSampleScanline32Bit(int orig_Bpp,
                                              int dest_Bpp,
                                              uint32_t src_width,
                                              const uint8_t* pSrcLine,
                                              uint8_t* dest_scan,
                                              int dest_width,
-                                             FX_BOOL bFlipX,
+                                             bool bFlipX,
                                              int clip_left,
                                              int clip_width) const {
   // last_src_x used to store the last seen src_x position which should be
   // in [0, src_width). Set the initial value to be an invalid src_x value.
   uint32_t last_src_x = src_width;
   FX_ARGB last_argb = FXARGB_MAKE(0xFF, 0xFF, 0xFF, 0xFF);
   FX_FLOAT unit_To8Bpc = 255.0f / ((1 << m_bpc) - 1);
   for (int i = 0; i < clip_width; i++) {
     int dest_x = clip_left + i;
     uint32_t src_x = (bFlipX ? (dest_width - dest_x - 1) : dest_x) *
@@ skipping 24 matching lines @@
         pSrcPixel = pSrcLine + src_x * orig_Bpp;
         if (m_bpc == 16) {
           for (uint32_t j = 0; j < m_nComponents; ++j)
             extracted_components[j] = pSrcPixel[j * 2];
           pSrcPixel = extracted_components;
         }
       }
 
       if (m_pColorSpace) {
         uint8_t color[4];
-        const FX_BOOL bTransMask = TransMask();
+        const bool bTransMask = TransMask();
         if (m_bDefaultDecode) {
           m_pColorSpace->TranslateImageLine(color, pSrcPixel, 1, 0, 0,
                                             bTransMask);
         } else {
           for (uint32_t j = 0; j < m_nComponents; ++j) {
             FX_FLOAT component_value =
                 static_cast<FX_FLOAT>(extracted_components[j]);
             int color_value = static_cast<int>(
                 (m_pCompData[j].m_DecodeMin +
                  m_pCompData[j].m_DecodeStep * component_value) *
@@ skipping 30 matching lines @@
     if (dest_Bpp == 4) {
       *reinterpret_cast<uint32_t*>(pDestPixel) = FXARGB_TODIB(argb);
     } else {
       *pDestPixel++ = FXARGB_B(argb);
       *pDestPixel++ = FXARGB_G(argb);
       *pDestPixel = FXARGB_R(argb);
     }
   }
 }
 
-FX_BOOL CPDF_DIBSource::TransMask() const {
+bool CPDF_DIBSource::TransMask() const {
   return m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK &&
          m_Family == PDFCS_DEVICECMYK;
 }
 
 CPDF_ImageLoaderHandle::CPDF_ImageLoaderHandle() {
   m_pImageLoader = nullptr;
   m_pCache = nullptr;
   m_pImage = nullptr;
 }
 
 CPDF_ImageLoaderHandle::~CPDF_ImageLoaderHandle() {}
 
-FX_BOOL CPDF_ImageLoaderHandle::Start(CPDF_ImageLoader* pImageLoader,
-                                      const CPDF_ImageObject* pImage,
-                                      CPDF_PageRenderCache* pCache,
-                                      FX_BOOL bStdCS,
-                                      uint32_t GroupFamily,
-                                      FX_BOOL bLoadMask,
-                                      CPDF_RenderStatus* pRenderStatus,
-                                      int32_t nDownsampleWidth,
-                                      int32_t nDownsampleHeight) {
+bool CPDF_ImageLoaderHandle::Start(CPDF_ImageLoader* pImageLoader,
+                                   const CPDF_ImageObject* pImage,
+                                   CPDF_PageRenderCache* pCache,
+                                   bool bStdCS,
+                                   uint32_t GroupFamily,
+                                   bool bLoadMask,
+                                   CPDF_RenderStatus* pRenderStatus,
+                                   int32_t nDownsampleWidth,
+                                   int32_t nDownsampleHeight) {
   m_pImageLoader = pImageLoader;
   m_pCache = pCache;
   m_pImage = const_cast<CPDF_ImageObject*>(pImage);
   m_nDownsampleWidth = nDownsampleWidth;
   m_nDownsampleHeight = nDownsampleHeight;
-  FX_BOOL ret;
+  bool ret;
   if (pCache) {
     ret = pCache->StartGetCachedBitmap(
         m_pImage->GetImage()->GetStream(), bStdCS, GroupFamily, bLoadMask,
         pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
   } else {
     ret = m_pImage->GetImage()->StartLoadDIBSource(
         pRenderStatus->m_pFormResource, pRenderStatus->m_pPageResource, bStdCS,
         GroupFamily, bLoadMask);
   }
   if (!ret)
     HandleFailure();
   return ret;
 }
 
-FX_BOOL CPDF_ImageLoaderHandle::Continue(IFX_Pause* pPause) {
-  FX_BOOL ret = m_pCache ? m_pCache->Continue(pPause)
-                         : m_pImage->GetImage()->Continue(pPause);
+bool CPDF_ImageLoaderHandle::Continue(IFX_Pause* pPause) {
+  bool ret = m_pCache ? m_pCache->Continue(pPause)
+                      : m_pImage->GetImage()->Continue(pPause);
   if (!ret)
     HandleFailure();
   return ret;
 }
 
 void CPDF_ImageLoaderHandle::HandleFailure() {
   if (m_pCache) {
     CPDF_ImageCacheEntry* entry = m_pCache->GetCurImageCacheEntry();
-    m_pImageLoader->m_bCached = TRUE;
+    m_pImageLoader->m_bCached = true;
     m_pImageLoader->m_pBitmap = entry->DetachBitmap();
     m_pImageLoader->m_pMask = entry->DetachMask();
     m_pImageLoader->m_MatteColor = entry->m_MatteColor;
   } else {
     CPDF_Image* pImage = m_pImage->GetImage();
-    m_pImageLoader->m_bCached = FALSE;
+    m_pImageLoader->m_bCached = false;
     m_pImageLoader->m_pBitmap = pImage->DetachBitmap();
     m_pImageLoader->m_pMask = pImage->DetachMask();
     m_pImageLoader->m_MatteColor = pImage->m_MatteColor;
   }
 }
 
-FX_BOOL CPDF_ImageLoader::Start(
+bool CPDF_ImageLoader::Start(
     const CPDF_ImageObject* pImage,
     CPDF_PageRenderCache* pCache,
     std::unique_ptr<CPDF_ImageLoaderHandle>* pLoadHandle,
-    FX_BOOL bStdCS,
+    bool bStdCS,
     uint32_t GroupFamily,
-    FX_BOOL bLoadMask,
+    bool bLoadMask,
     CPDF_RenderStatus* pRenderStatus,
     int32_t nDownsampleWidth,
     int32_t nDownsampleHeight) {
   m_nDownsampleWidth = nDownsampleWidth;
   m_nDownsampleHeight = nDownsampleHeight;
   pLoadHandle->reset(new CPDF_ImageLoaderHandle);
   return (*pLoadHandle)
       ->Start(this, pImage, pCache, bStdCS, GroupFamily, bLoadMask,
               pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
 }
 
-FX_BOOL CPDF_ImageLoader::Continue(CPDF_ImageLoaderHandle* LoadHandle,
-                                   IFX_Pause* pPause) {
+bool CPDF_ImageLoader::Continue(CPDF_ImageLoaderHandle* LoadHandle,
+                                IFX_Pause* pPause) {
   return LoadHandle->Continue(pPause);
 }
 
 CPDF_ImageLoader::~CPDF_ImageLoader() {
   if (!m_bCached) {
     delete m_pBitmap;
     delete m_pMask;
   }
 }