Remove FX_BOOL from core

core/fxge/dib/fx_dib_main.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fxge/fx_dib.h"
 
 #include <limits.h>
 #include <algorithm>
@@ skipping 37 matching lines @@
       m_Pitch(0) {}
 
 CFX_DIBSource::~CFX_DIBSource() {
   delete m_pAlphaMask;
 }
 
 uint8_t* CFX_DIBSource::GetBuffer() const {
   return nullptr;
 }
 
-FX_BOOL CFX_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const {
-  return FALSE;
+bool CFX_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const {
+  return false;
 }
 
 CFX_DIBitmap::CFX_DIBitmap() {
-  m_bExtBuf = FALSE;
+  m_bExtBuf = false;
   m_pBuffer = nullptr;
   m_pPalette = nullptr;
 }
 
 #define _MAX_OOM_LIMIT_ 12000000
-FX_BOOL CFX_DIBitmap::Create(int width,
-                             int height,
-                             FXDIB_Format format,
-                             uint8_t* pBuffer,
-                             int pitch) {
+bool CFX_DIBitmap::Create(int width,
+                          int height,
+                          FXDIB_Format format,
+                          uint8_t* pBuffer,
+                          int pitch) {
   m_pBuffer = nullptr;
   m_bpp = (uint8_t)format;
   m_AlphaFlag = (uint8_t)(format >> 8);
   m_Width = m_Height = m_Pitch = 0;
   if (width <= 0 || height <= 0 || pitch < 0) {
-    return FALSE;
+    return false;
   }
   if ((INT_MAX - 31) / width < (format & 0xff)) {
-    return FALSE;
+    return false;
   }
   if (!pitch) {
     pitch = (width * (format & 0xff) + 31) / 32 * 4;
   }
   if ((1 << 30) / pitch < height) {
-    return FALSE;
+    return false;
   }
   if (pBuffer) {
     m_pBuffer = pBuffer;
-    m_bExtBuf = TRUE;
+    m_bExtBuf = true;
   } else {
     int size = pitch * height + 4;
     int oomlimit = _MAX_OOM_LIMIT_;
     if (oomlimit >= 0 && size >= oomlimit) {
       m_pBuffer = FX_TryAlloc(uint8_t, size);
       if (!m_pBuffer) {
-        return FALSE;
+        return false;
       }
     } else {
       m_pBuffer = FX_Alloc(uint8_t, size);
     }
   }
   m_Width = width;
   m_Height = height;
   m_Pitch = pitch;
   if (HasAlpha() && format != FXDIB_Argb) {
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     ret = BuildAlphaMask();
     if (!ret) {
       if (!m_bExtBuf) {
         FX_Free(m_pBuffer);
         m_pBuffer = nullptr;
         m_Width = m_Height = m_Pitch = 0;
-        return FALSE;
+        return false;
       }
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc) {
+bool CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc) {
   if (m_pBuffer) {
-    return FALSE;
+    return false;
   }
   if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat())) {
-    return FALSE;
+    return false;
   }
   CopyPalette(pSrc->GetPalette());
   CopyAlphaMask(pSrc->m_pAlphaMask);
   for (int row = 0; row < pSrc->GetHeight(); row++) {
     FXSYS_memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
   }
-  return TRUE;
+  return true;
 }
 
 CFX_DIBitmap::~CFX_DIBitmap() {
   if (!m_bExtBuf)
     FX_Free(m_pBuffer);
 
   m_pBuffer = nullptr;
 }
 
 uint8_t* CFX_DIBitmap::GetBuffer() const {
@@ skipping 82 matching lines @@
         m_pPalette.get()[i] = 0xff - i;
       }
     } else {
       for (int i = 0; i < 256; i++) {
         m_pPalette.get()[i] = 0xff000000 | (i * 0x10101);
       }
     }
   }
 }
 
-FX_BOOL CFX_DIBSource::BuildAlphaMask() {
+bool CFX_DIBSource::BuildAlphaMask() {
   if (m_pAlphaMask) {
-    return TRUE;
+    return true;
   }
   m_pAlphaMask = new CFX_DIBitmap;
   if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
     delete m_pAlphaMask;
     m_pAlphaMask = nullptr;
-    return FALSE;
+    return false;
   }
   FXSYS_memset(m_pAlphaMask->GetBuffer(), 0xff,
                m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
-  return TRUE;
+  return true;
 }
 
 uint32_t CFX_DIBSource::GetPaletteEntry(int index) const {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   if (m_pPalette) {
     return m_pPalette.get()[index];
   }
   if (IsCmykImage()) {
     if (GetBPP() == 1) {
       return index ? 0 : 0xff;
@@ skipping 129 matching lines @@
     dest_rect.Intersect(pClipRgn->GetBox());
   }
   dest_left = dest_rect.left;
   dest_top = dest_rect.top;
   src_left = dest_left - x_offset;
   src_top = dest_top - y_offset;
   width = dest_rect.right - dest_rect.left;
   height = dest_rect.bottom - dest_rect.top;
 }
 
-FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left,
-                                     int dest_top,
-                                     int width,
-                                     int height,
-                                     const CFX_DIBSource* pSrcBitmap,
-                                     int src_left,
-                                     int src_top) {
+bool CFX_DIBitmap::TransferBitmap(int dest_left,
+                                  int dest_top,
+                                  int width,
+                                  int height,
+                                  const CFX_DIBSource* pSrcBitmap,
+                                  int src_left,
+                                  int src_top) {
   if (!m_pBuffer)
-    return FALSE;
+    return false;
 
   GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(),
                  pSrcBitmap->GetHeight(), src_left, src_top, nullptr);
   if (width == 0 || height == 0)
-    return TRUE;
+    return true;
 
   FXDIB_Format dest_format = GetFormat();
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
   if (dest_format == src_format) {
     if (GetBPP() == 1) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
         for (int col = 0; col < width; col++) {
           if (src_scan[(src_left + col) / 8] &
@@ skipping 11 matching lines @@
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan =
             m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
         const uint8_t* src_scan =
             pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
         FXSYS_memcpy(dest_scan, src_scan, width * Bpp);
       }
     }
   } else {
     if (m_pPalette)
-      return FALSE;
+      return false;
 
     if (m_bpp == 8)
       dest_format = FXDIB_8bppMask;
 
     uint8_t* dest_buf =
         m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
     std::unique_ptr<uint32_t, FxFreeDeleter> d_plt;
     if (!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height,
                        pSrcBitmap, src_left, src_top, &d_plt)) {
-      return FALSE;
+      return false;
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_DIBitmap::TransferMask(int dest_left,
-                                   int dest_top,
-                                   int width,
-                                   int height,
-                                   const CFX_DIBSource* pMask,
-                                   uint32_t color,
-                                   int src_left,
-                                   int src_top,
-                                   int alpha_flag,
-                                   void* pIccTransform) {
+bool CFX_DIBitmap::TransferMask(int dest_left,
+                                int dest_top,
+                                int width,
+                                int height,
+                                const CFX_DIBSource* pMask,
+                                uint32_t color,
+                                int src_left,
+                                int src_top,
+                                int alpha_flag,
+                                void* pIccTransform) {
   if (!m_pBuffer) {
-    return FALSE;
+    return false;
   }
   ASSERT(HasAlpha() && (m_bpp >= 24));
   ASSERT(pMask->IsAlphaMask());
   if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
-    return FALSE;
+    return false;
   }
   GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(),
                  pMask->GetHeight(), src_left, src_top, nullptr);
   if (width == 0 || height == 0) {
-    return TRUE;
+    return true;
   }
   int src_bpp = pMask->GetBPP();
   int alpha;
   uint32_t dst_color;
   if (alpha_flag >> 8) {
     alpha = alpha_flag & 0xff;
     dst_color = FXCMYK_TODIB(color);
   } else {
     alpha = FXARGB_A(color);
     dst_color = FXARGB_TODIB(color);
   }
   uint8_t* color_p = (uint8_t*)&dst_color;
   if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
     CCodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
   } else {
     if (alpha_flag >> 8 && !IsCmykImage()) {
       AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
                          FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                          color_p[2], color_p[1], color_p[0]);
     } else if (!(alpha_flag >> 8) && IsCmykImage()) {
-      return FALSE;
+      return false;
     }
   }
   if (!IsCmykImage()) {
     color_p[3] = (uint8_t)alpha;
   }
   if (GetFormat() == FXDIB_Argb) {
     for (int row = 0; row < height; row++) {
       uint32_t* dest_pos =
           (uint32_t*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
       const uint8_t* src_scan = pMask->GetScanline(src_top + row);
@@ skipping 41 matching lines @@
       } else {
         src_scan += src_left;
         for (int col = 0; col < width; col++) {
           FXSYS_memcpy(dest_color_pos, color_p, comps);
           dest_color_pos += comps;
           *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
         }
       }
     }
   }
-  return TRUE;
+  return true;
 }
 
 void CFX_DIBSource::CopyPalette(const uint32_t* pSrc) {
   static const uint32_t kPaletteSize = 256;
 
   if (!pSrc || GetBPP() > 8) {
     m_pPalette.reset();
   } else {
     uint32_t pal_size = 1 << GetBPP();
     if (!m_pPalette)
@@ skipping 41 matching lines @@
     const uint8_t* src_scan = GetScanline(row) + rect.left * 4 + 3;
     uint8_t* dest_scan = (uint8_t*)pMask->GetScanline(row - rect.top);
     for (int col = rect.left; col < rect.right; col++) {
       *dest_scan++ = *src_scan;
       src_scan += 4;
     }
   }
   return pMask;
 }
 
-FX_BOOL CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
-                                     const FX_RECT* pClip) {
+bool CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
+                                  const FX_RECT* pClip) {
   if (!HasAlpha() || GetFormat() == FXDIB_Argb) {
-    return FALSE;
+    return false;
   }
   if (pAlphaMask) {
     FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
     if (pClip) {
       rect.Intersect(*pClip);
       if (rect.IsEmpty() || rect.Width() != m_Width ||
           rect.Height() != m_Height) {
-        return FALSE;
+        return false;
       }
     } else {
       if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height) {
-        return FALSE;
+        return false;
       }
     }
     for (int row = 0; row < m_Height; row++)
       FXSYS_memcpy((void*)m_pAlphaMask->GetScanline(row),
                    pAlphaMask->GetScanline(row + rect.top) + rect.left,
                    m_pAlphaMask->m_Pitch);
   } else {
     m_pAlphaMask->Clear(0xff000000);
   }
-  return TRUE;
+  return true;
 }
 
 const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
-FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel,
-                                  const CFX_DIBSource* pSrcBitmap,
-                                  FXDIB_Channel srcChannel) {
+bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel,
+                               const CFX_DIBSource* pSrcBitmap,
+                               FXDIB_Channel srcChannel) {
   if (!m_pBuffer) {
-    return FALSE;
+    return false;
   }
   CFX_DIBSource* pSrcClone = (CFX_DIBSource*)pSrcBitmap;
   CFX_DIBitmap* pDst = this;
   int destOffset, srcOffset;
   if (srcChannel == FXDIB_Alpha) {
     if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask()) {
-      return FALSE;
+      return false;
     }
     if (pSrcBitmap->GetBPP() == 1) {
       pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
       if (!pSrcClone) {
-        return FALSE;
+        return false;
       }
     }
     if (pSrcBitmap->GetFormat() == FXDIB_Argb) {
       srcOffset = 3;
     } else {
       srcOffset = 0;
     }
   } else {
     if (pSrcBitmap->IsAlphaMask()) {
-      return FALSE;
+      return false;
     }
     if (pSrcBitmap->GetBPP() < 24) {
       if (pSrcBitmap->IsCmykImage()) {
         pSrcClone = pSrcBitmap->CloneConvert(
             (FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x20));
       } else {
         pSrcClone = pSrcBitmap->CloneConvert(
             (FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x18));
       }
       if (!pSrcClone) {
-        return FALSE;
+        return false;
       }
     }
     srcOffset = g_ChannelOffset[srcChannel];
   }
   if (destChannel == FXDIB_Alpha) {
     if (IsAlphaMask()) {
       if (!ConvertFormat(FXDIB_8bppMask)) {
         if (pSrcClone != pSrcBitmap) {
           delete pSrcClone;
         }
-        return FALSE;
+        return false;
       }
       destOffset = 0;
     } else {
       destOffset = 0;
       if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
         if (pSrcClone != pSrcBitmap) {
           delete pSrcClone;
         }
-        return FALSE;
+        return false;
       }
       if (GetFormat() == FXDIB_Argb) {
         destOffset = 3;
       }
     }
   } else {
     if (IsAlphaMask()) {
       if (pSrcClone != pSrcBitmap) {
         delete pSrcClone;
       }
-      return FALSE;
+      return false;
     }
     if (GetBPP() < 24) {
       if (HasAlpha()) {
         if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
           if (pSrcClone != pSrcBitmap) {
             delete pSrcClone;
           }
-          return FALSE;
+          return false;
         }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
 #else
       } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
 #endif
         if (pSrcClone != pSrcBitmap) {
           delete pSrcClone;
         }
-        return FALSE;
+        return false;
       }
     }
     destOffset = g_ChannelOffset[destChannel];
   }
   if (srcChannel == FXDIB_Alpha && pSrcClone->m_pAlphaMask) {
     CFX_DIBitmap* pAlphaMask = pSrcClone->m_pAlphaMask;
     if (pSrcClone->GetWidth() != m_Width ||
         pSrcClone->GetHeight() != m_Height) {
       if (pAlphaMask) {
         pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
         if (!pAlphaMask) {
           if (pSrcClone != pSrcBitmap) {
             delete pSrcClone;
           }
-          return FALSE;
+          return false;
         }
       }
     }
     if (pSrcClone != pSrcBitmap) {
       pSrcClone->m_pAlphaMask = nullptr;
       delete pSrcClone;
     }
     pSrcClone = pAlphaMask;
     srcOffset = 0;
   } else if (pSrcClone->GetWidth() != m_Width ||
              pSrcClone->GetHeight() != m_Height) {
     CFX_DIBitmap* pSrcMatched = pSrcClone->StretchTo(m_Width, m_Height);
     if (pSrcClone != pSrcBitmap) {
       delete pSrcClone;
     }
     if (!pSrcMatched) {
-      return FALSE;
+      return false;
     }
     pSrcClone = pSrcMatched;
   }
   if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
     pDst = m_pAlphaMask;
     destOffset = 0;
   }
   int srcBytes = pSrcClone->GetBPP() / 8;
   int destBytes = pDst->GetBPP() / 8;
   for (int row = 0; row < m_Height; row++) {
     uint8_t* dest_pos = (uint8_t*)pDst->GetScanline(row) + destOffset;
     const uint8_t* src_pos = pSrcClone->GetScanline(row) + srcOffset;
     for (int col = 0; col < m_Width; col++) {
       *dest_pos = *src_pos;
       dest_pos += destBytes;
       src_pos += srcBytes;
     }
   }
   if (pSrcClone != pSrcBitmap && pSrcClone != pSrcBitmap->m_pAlphaMask) {
     delete pSrcClone;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value) {
+bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value) {
   if (!m_pBuffer) {
-    return FALSE;
+    return false;
   }
   int destOffset;
   if (destChannel == FXDIB_Alpha) {
     if (IsAlphaMask()) {
       if (!ConvertFormat(FXDIB_8bppMask)) {
-        return FALSE;
+        return false;
       }
       destOffset = 0;
     } else {
       destOffset = 0;
       if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-        return FALSE;
+        return false;
       }
       if (GetFormat() == FXDIB_Argb) {
         destOffset = 3;
       }
     }
   } else {
     if (IsAlphaMask()) {
-      return FALSE;
+      return false;
     }
     if (GetBPP() < 24) {
       if (HasAlpha()) {
         if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-          return FALSE;
+          return false;
         }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
 #else
       } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
 #endif
-        return FALSE;
+        return false;
       }
     }
     destOffset = g_ChannelOffset[destChannel];
   }
   int Bpp = GetBPP() / 8;
   if (Bpp == 1) {
     FXSYS_memset(m_pBuffer, value, m_Height * m_Pitch);
-    return TRUE;
+    return true;
   }
   if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
     FXSYS_memset(m_pAlphaMask->GetBuffer(), value,
                  m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
-    return TRUE;
+    return true;
   }
   for (int row = 0; row < m_Height; row++) {
     uint8_t* scan_line = m_pBuffer + row * m_Pitch + destOffset;
     for (int col = 0; col < m_Width; col++) {
       *scan_line = value;
       scan_line += Bpp;
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap) {
+bool CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap) {
   if (!m_pBuffer) {
-    return FALSE;
+    return false;
   }
   ASSERT(pSrcBitmap->IsAlphaMask());
   if (!pSrcBitmap->IsAlphaMask()) {
-    return FALSE;
+    return false;
   }
   if (!IsAlphaMask() && !HasAlpha()) {
     return LoadChannel(FXDIB_Alpha, pSrcBitmap, FXDIB_Alpha);
   }
   CFX_DIBitmap* pSrcClone = (CFX_DIBitmap*)pSrcBitmap;
   if (pSrcBitmap->GetWidth() != m_Width ||
       pSrcBitmap->GetHeight() != m_Height) {
     pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
     if (!pSrcClone) {
-      return FALSE;
+      return false;
     }
   }
   if (IsAlphaMask()) {
     if (!ConvertFormat(FXDIB_8bppMask)) {
       if (pSrcClone != pSrcBitmap) {
         delete pSrcClone;
       }
-      return FALSE;
+      return false;
     }
     for (int row = 0; row < m_Height; row++) {
       uint8_t* dest_scan = m_pBuffer + m_Pitch * row;
       uint8_t* src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
       if (pSrcClone->GetBPP() == 1) {
         for (int col = 0; col < m_Width; col++) {
           if (!((1 << (7 - col % 8)) & src_scan[col / 8])) {
             dest_scan[col] = 0;
           }
         }
       } else {
         for (int col = 0; col < m_Width; col++) {
           *dest_scan = (*dest_scan) * src_scan[col] / 255;
           dest_scan++;
         }
       }
     }
   } else {
     if (GetFormat() == FXDIB_Argb) {
       if (pSrcClone->GetBPP() == 1) {
         if (pSrcClone != pSrcBitmap) {
           delete pSrcClone;
         }
-        return FALSE;
+        return false;
       }
       for (int row = 0; row < m_Height; row++) {
         uint8_t* dest_scan = m_pBuffer + m_Pitch * row + 3;
         uint8_t* src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
         for (int col = 0; col < m_Width; col++) {
           *dest_scan = (*dest_scan) * src_scan[col] / 255;
           dest_scan += 4;
         }
       }
     } else {
       m_pAlphaMask->MultiplyAlpha(pSrcClone);
     }
   }
   if (pSrcClone != pSrcBitmap) {
     delete pSrcClone;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform) {
+bool CFX_DIBitmap::GetGrayData(void* pIccTransform) {
   if (!m_pBuffer) {
-    return FALSE;
+    return false;
   }
   switch (GetFormat()) {
     case FXDIB_1bppRgb: {
       if (!m_pPalette) {
-        return FALSE;
+        return false;
       }
       uint8_t gray[2];
       for (int i = 0; i < 2; i++) {
         int r = static_cast<uint8_t>(m_pPalette.get()[i] >> 16);
         int g = static_cast<uint8_t>(m_pPalette.get()[i] >> 8);
         int b = static_cast<uint8_t>(m_pPalette.get()[i]);
         gray[i] = static_cast<uint8_t>(FXRGB2GRAY(r, g, b));
       }
       CFX_DIBitmap* pMask = new CFX_DIBitmap;
       if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
         delete pMask;
-        return FALSE;
+        return false;
       }
       FXSYS_memset(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
       for (int row = 0; row < m_Height; row++) {
         uint8_t* src_pos = m_pBuffer + row * m_Pitch;
         uint8_t* dest_pos = (uint8_t*)pMask->GetScanline(row);
         for (int col = 0; col < m_Width; col++) {
           if (src_pos[col / 8] & (1 << (7 - col % 8))) {
             *dest_pos = gray[1];
           }
           dest_pos++;
         }
       }
       TakeOver(pMask);
       delete pMask;
       break;
     }
     case FXDIB_8bppRgb: {
       if (!m_pPalette) {
-        return FALSE;
+        return false;
       }
       uint8_t gray[256];
       for (int i = 0; i < 256; i++) {
         int r = static_cast<uint8_t>(m_pPalette.get()[i] >> 16);
         int g = static_cast<uint8_t>(m_pPalette.get()[i] >> 8);
         int b = static_cast<uint8_t>(m_pPalette.get()[i]);
         gray[i] = static_cast<uint8_t>(FXRGB2GRAY(r, g, b));
       }
       CFX_DIBitmap* pMask = new CFX_DIBitmap;
       if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
         delete pMask;
-        return FALSE;
+        return false;
       }
       for (int row = 0; row < m_Height; row++) {
         uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
         uint8_t* src_pos = m_pBuffer + row * m_Pitch;
         for (int col = 0; col < m_Width; col++) {
           *dest_pos++ = gray[*src_pos++];
         }
       }
       TakeOver(pMask);
       delete pMask;
       break;
     }
     case FXDIB_Rgb: {
       CFX_DIBitmap* pMask = new CFX_DIBitmap;
       if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
         delete pMask;
-        return FALSE;
+        return false;
       }
       for (int row = 0; row < m_Height; row++) {
         uint8_t* src_pos = m_pBuffer + row * m_Pitch;
         uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
         for (int col = 0; col < m_Width; col++) {
           *dest_pos++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
           src_pos += 3;
         }
       }
       TakeOver(pMask);
       delete pMask;
       break;
     }
     case FXDIB_Rgb32: {
       CFX_DIBitmap* pMask = new CFX_DIBitmap;
       if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
         delete pMask;
-        return FALSE;
+        return false;
       }
       for (int row = 0; row < m_Height; row++) {
         uint8_t* src_pos = m_pBuffer + row * m_Pitch;
         uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
         for (int col = 0; col < m_Width; col++) {
           *dest_pos++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
           src_pos += 4;
         }
       }
       TakeOver(pMask);
       delete pMask;
       break;
     }
     default:
-      return FALSE;
+      return false;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha) {
+bool CFX_DIBitmap::MultiplyAlpha(int alpha) {
   if (!m_pBuffer) {
-    return FALSE;
+    return false;
   }
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       if (!ConvertFormat(FXDIB_8bppMask)) {
-        return FALSE;
+        return false;
       }
       MultiplyAlpha(alpha);
       break;
     case FXDIB_8bppMask: {
       for (int row = 0; row < m_Height; row++) {
         uint8_t* scan_line = m_pBuffer + row * m_Pitch;
         for (int col = 0; col < m_Width; col++) {
           scan_line[col] = scan_line[col] * alpha / 255;
         }
       }
       break;
     }
     case FXDIB_Argb: {
       for (int row = 0; row < m_Height; row++) {
         uint8_t* scan_line = m_pBuffer + row * m_Pitch + 3;
         for (int col = 0; col < m_Width; col++) {
           *scan_line = (*scan_line) * alpha / 255;
           scan_line += 4;
         }
       }
       break;
     }
     default:
       if (HasAlpha()) {
         m_pAlphaMask->MultiplyAlpha(alpha);
       } else if (IsCmykImage()) {
         if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
-          return FALSE;
+          return false;
         }
         m_pAlphaMask->MultiplyAlpha(alpha);
       } else {
         if (!ConvertFormat(FXDIB_Argb)) {
-          return FALSE;
+          return false;
         }
         MultiplyAlpha(alpha);
       }
       break;
   }
-  return TRUE;
+  return true;
 }
 
 uint32_t CFX_DIBitmap::GetPixel(int x, int y) const {
   if (!m_pBuffer) {
     return 0;
   }
   uint8_t* pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
     case FXDIB_1bppMask: {
       if ((*pos) & (1 << (7 - x % 8))) {
@@ skipping 91 matching lines @@
       break;
     default:
       break;
   }
 }
 
 void CFX_DIBitmap::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 (!m_pBuffer) {
     return;
   }
   int src_Bpp = m_bpp / 8;
   uint8_t* scanline = m_pBuffer + line * m_Pitch;
   if (src_Bpp == 0) {
     for (int i = 0; i < clip_width; i++) {
       uint32_t dest_x = clip_left + i;
@@ skipping 42 matching lines @@
       int dest_pos = i * src_Bpp;
       for (int b = 0; b < src_Bpp; b++) {
         dest_scan[dest_pos + b] = scanline[src_x + b];
       }
     }
   }
 }
 
 // TODO(weili): Split this function into two for handling CMYK and RGB
 // colors separately.
-FX_BOOL CFX_DIBitmap::ConvertColorScale(uint32_t forecolor,
-                                        uint32_t backcolor) {
+bool CFX_DIBitmap::ConvertColorScale(uint32_t forecolor, uint32_t backcolor) {
   ASSERT(!IsAlphaMask());
   if (!m_pBuffer || IsAlphaMask()) {
-    return FALSE;
+    return false;
   }
   // Values used for CMYK colors.
   int fc = 0;
   int fm = 0;
   int fy = 0;
   int fk = 0;
   int bc = 0;
   int bm = 0;
   int by = 0;
   int bk = 0;
   // Values used for RGB colors.
   int fr = 0;
   int fg = 0;
   int fb = 0;
   int br = 0;
   int bg = 0;
   int bb = 0;
-  FX_BOOL isCmykImage = IsCmykImage();
+  bool isCmykImage = IsCmykImage();
   if (isCmykImage) {
     fc = FXSYS_GetCValue(forecolor);
     fm = FXSYS_GetMValue(forecolor);
     fy = FXSYS_GetYValue(forecolor);
     fk = FXSYS_GetKValue(forecolor);
     bc = FXSYS_GetCValue(backcolor);
     bm = FXSYS_GetMValue(backcolor);
     by = FXSYS_GetYValue(backcolor);
     bk = FXSYS_GetKValue(backcolor);
   } else {
     fr = FXSYS_GetRValue(forecolor);
     fg = FXSYS_GetGValue(forecolor);
     fb = FXSYS_GetBValue(forecolor);
     br = FXSYS_GetRValue(backcolor);
     bg = FXSYS_GetGValue(backcolor);
     bb = FXSYS_GetBValue(backcolor);
   }
   if (m_bpp <= 8) {
     if (isCmykImage) {
       if (forecolor == 0xff && backcolor == 0 && !m_pPalette) {
-        return TRUE;
+        return true;
       }
     } else if (forecolor == 0 && backcolor == 0xffffff && !m_pPalette) {
-      return TRUE;
+      return true;
     }
     if (!m_pPalette) {
       BuildPalette();
     }
     int size = 1 << m_bpp;
     if (isCmykImage) {
       for (int i = 0; i < size; i++) {
         uint8_t b, g, r;
         AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette.get()[i]),
                            FXSYS_GetMValue(m_pPalette.get()[i]),
                            FXSYS_GetYValue(m_pPalette.get()[i]),
                            FXSYS_GetKValue(m_pPalette.get()[i]), r, g, b);
         int gray = 255 - FXRGB2GRAY(r, g, b);
         m_pPalette.get()[i] = CmykEncode(
             bc + (fc - bc) * gray / 255, bm + (fm - bm) * gray / 255,
             by + (fy - by) * gray / 255, bk + (fk - bk) * gray / 255);
       }
     } else {
       for (int i = 0; i < size; i++) {
         int gray = FXRGB2GRAY(FXARGB_R(m_pPalette.get()[i]),
                               FXARGB_G(m_pPalette.get()[i]),
                               FXARGB_B(m_pPalette.get()[i]));
         m_pPalette.get()[i] = FXARGB_MAKE(0xff, br + (fr - br) * gray / 255,
                                           bg + (fg - bg) * gray / 255,
                                           bb + (fb - bb) * gray / 255);
       }
     }
-    return TRUE;
+    return true;
   }
   if (isCmykImage) {
     if (forecolor == 0xff && backcolor == 0x00) {
       for (int row = 0; row < m_Height; row++) {
         uint8_t* scanline = m_pBuffer + row * m_Pitch;
         for (int col = 0; col < m_Width; col++) {
           uint8_t b, g, r;
           AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
                              r, g, b);
           *scanline++ = 0;
           *scanline++ = 0;
           *scanline++ = 0;
           *scanline++ = 255 - FXRGB2GRAY(r, g, b);
         }
       }
-      return TRUE;
+      return true;
     }
   } else if (forecolor == 0 && backcolor == 0xffffff) {
     for (int row = 0; row < m_Height; row++) {
       uint8_t* scanline = m_pBuffer + row * m_Pitch;
       int gap = m_bpp / 8 - 2;
       for (int col = 0; col < m_Width; col++) {
         int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
         *scanline++ = gray;
         *scanline++ = gray;
         *scanline = gray;
         scanline += gap;
       }
     }
-    return TRUE;
+    return true;
   }
   if (isCmykImage) {
     for (int row = 0; row < m_Height; row++) {
       uint8_t* scanline = m_pBuffer + row * m_Pitch;
       for (int col = 0; col < m_Width; col++) {
         uint8_t b, g, r;
         AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
                            r, g, b);
         int gray = 255 - FXRGB2GRAY(r, g, b);
         *scanline++ = bc + (fc - bc) * gray / 255;
         *scanline++ = bm + (fm - bm) * gray / 255;
         *scanline++ = by + (fy - by) * gray / 255;
         *scanline++ = bk + (fk - bk) * gray / 255;
       }
     }
   } else {
     for (int row = 0; row < m_Height; row++) {
       uint8_t* scanline = m_pBuffer + row * m_Pitch;
       int gap = m_bpp / 8 - 2;
       for (int col = 0; col < m_Width; col++) {
         int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
         *scanline++ = bb + (fb - bb) * gray / 255;
         *scanline++ = bg + (fg - bg) * gray / 255;
         *scanline = br + (fr - br) * gray / 255;
         scanline += gap;
       }
     }
   }
-  return TRUE;
+  return true;
 }
 
-CFX_DIBitmap* CFX_DIBSource::FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const {
+CFX_DIBitmap* CFX_DIBSource::FlipImage(bool bXFlip, bool bYFlip) const {
   CFX_DIBitmap* pFlipped = new CFX_DIBitmap;
   if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
     delete pFlipped;
     return nullptr;
   }
   pFlipped->CopyPalette(m_pPalette.get());
   uint8_t* pDestBuffer = pFlipped->GetBuffer();
   int Bpp = m_bpp / 8;
   for (int row = 0; row < m_Height; row++) {
     const uint8_t* src_scan = GetScanline(row);
@@ skipping 76 matching lines @@
 CFX_DIBExtractor::~CFX_DIBExtractor() {}
 
 CFX_FilteredDIB::CFX_FilteredDIB() : m_pSrc(nullptr) {}
 
 CFX_FilteredDIB::~CFX_FilteredDIB() {
   if (m_bAutoDropSrc) {
     delete m_pSrc;
   }
 }
 
-void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc) {
+void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, bool bAutoDropSrc) {
   m_pSrc = pSrc;
   m_bAutoDropSrc = bAutoDropSrc;
   m_Width = pSrc->GetWidth();
   m_Height = pSrc->GetHeight();
   FXDIB_Format format = GetDestFormat();
   m_bpp = (uint8_t)format;
   m_AlphaFlag = (uint8_t)(format >> 8);
   m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
   m_pPalette.reset(GetDestPalette());
   m_Scanline.resize(m_Pitch);
 }
 
 const uint8_t* CFX_FilteredDIB::GetScanline(int line) const {
   TranslateScanline(m_pSrc->GetScanline(line), &m_Scanline);
   return m_Scanline.data();
 }
 
 void CFX_FilteredDIB::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 {
   m_pSrc->DownSampleScanline(line, dest_scan, dest_bpp, dest_width, bFlipX,
                              clip_left, clip_width);
   TranslateDownSamples(dest_scan, dest_scan, clip_width, dest_bpp);
 }
 
 CFX_ImageRenderer::CFX_ImageRenderer() {
   m_Status = 0;
-  m_bRgbByteOrder = FALSE;
+  m_bRgbByteOrder = false;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
 
 CFX_ImageRenderer::~CFX_ImageRenderer() {}
 
-FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice,
-                                 const CFX_ClipRgn* pClipRgn,
-                                 const CFX_DIBSource* pSource,
-                                 int bitmap_alpha,
-                                 uint32_t mask_color,
-                                 const CFX_Matrix* pMatrix,
-                                 uint32_t dib_flags,
-                                 FX_BOOL bRgbByteOrder,
-                                 int alpha_flag,
-                                 void* pIccTransform,
-                                 int blend_type) {
+bool CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice,
+                              const CFX_ClipRgn* pClipRgn,
+                              const CFX_DIBSource* pSource,
+                              int bitmap_alpha,
+                              uint32_t mask_color,
+                              const CFX_Matrix* pMatrix,
+                              uint32_t dib_flags,
+                              bool bRgbByteOrder,
+                              int alpha_flag,
+                              void* pIccTransform,
+                              int blend_type) {
   m_Matrix = *pMatrix;
   CFX_FloatRect image_rect_f = m_Matrix.GetUnitRect();
   FX_RECT image_rect = image_rect_f.GetOuterRect();
   m_ClipBox = pClipRgn ? pClipRgn->GetBox() : FX_RECT(0, 0, pDevice->GetWidth(),
                                                       pDevice->GetHeight());
   m_ClipBox.Intersect(image_rect);
   if (m_ClipBox.IsEmpty())
-    return FALSE;
+    return false;
 
   m_pDevice = pDevice;
   m_pClipRgn = pClipRgn;
   m_MaskColor = mask_color;
   m_BitmapAlpha = bitmap_alpha;
   m_Matrix = *pMatrix;
   m_Flags = dib_flags;
   m_AlphaFlag = alpha_flag;
   m_pIccTransform = pIccTransform;
   m_bRgbByteOrder = bRgbByteOrder;
   m_BlendType = blend_type;
 
   if ((FXSYS_fabs(m_Matrix.b) >= 0.5f || m_Matrix.a == 0) ||
       (FXSYS_fabs(m_Matrix.c) >= 0.5f || m_Matrix.d == 0)) {
     if (FXSYS_fabs(m_Matrix.a) < FXSYS_fabs(m_Matrix.b) / 20 &&
         FXSYS_fabs(m_Matrix.d) < FXSYS_fabs(m_Matrix.c) / 20 &&
         FXSYS_fabs(m_Matrix.a) < 0.5f && FXSYS_fabs(m_Matrix.d) < 0.5f) {
       int dest_width = image_rect.Width();
       int dest_height = image_rect.Height();
       FX_RECT bitmap_clip = m_ClipBox;
       bitmap_clip.Offset(-image_rect.left, -image_rect.top);
       bitmap_clip = FXDIB_SwapClipBox(bitmap_clip, dest_width, dest_height,
                                       m_Matrix.c > 0, m_Matrix.b < 0);
       m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color, m_ClipBox,
-                         TRUE, m_Matrix.c > 0, m_Matrix.b < 0, m_bRgbByteOrder,
+                         true, m_Matrix.c > 0, m_Matrix.b < 0, m_bRgbByteOrder,
                          alpha_flag, pIccTransform, m_BlendType);
       m_Stretcher = pdfium::MakeUnique<CFX_ImageStretcher>(
           &m_Composer, pSource, dest_height, dest_width, bitmap_clip,
           dib_flags);
       if (!m_Stretcher->Start())
-        return FALSE;
+        return false;
 
       m_Status = 1;
-      return TRUE;
+      return true;
     }
     m_Status = 2;
     m_pTransformer.reset(
         new CFX_ImageTransformer(pSource, &m_Matrix, dib_flags, &m_ClipBox));
     m_pTransformer->Start();
-    return TRUE;
+    return true;
   }
 
   int dest_width = image_rect.Width();
   if (m_Matrix.a < 0)
     dest_width = -dest_width;
 
   int dest_height = image_rect.Height();
   if (m_Matrix.d > 0)
     dest_height = -dest_height;
 
   if (dest_width == 0 || dest_height == 0)
-    return FALSE;
+    return false;
 
   FX_RECT bitmap_clip = m_ClipBox;
   bitmap_clip.Offset(-image_rect.left, -image_rect.top);
   m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color, m_ClipBox,
-                     FALSE, FALSE, FALSE, m_bRgbByteOrder, alpha_flag,
+                     false, false, false, m_bRgbByteOrder, alpha_flag,
                      pIccTransform, m_BlendType);
   m_Status = 1;
   m_Stretcher = pdfium::MakeUnique<CFX_ImageStretcher>(
       &m_Composer, pSource, dest_width, dest_height, bitmap_clip, dib_flags);
   return m_Stretcher->Start();
 }
 
-FX_BOOL CFX_ImageRenderer::Continue(IFX_Pause* pPause) {
+bool CFX_ImageRenderer::Continue(IFX_Pause* pPause) {
   if (m_Status == 1)
     return m_Stretcher->Continue(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 || !pBitmap->GetBuffer())
-      return FALSE;
+      return false;
 
     if (pBitmap->IsAlphaMask()) {
       if (m_BitmapAlpha != 255) {
         if (m_AlphaFlag >> 8) {
           m_AlphaFlag =
               (((uint8_t)((m_AlphaFlag & 0xff) * m_BitmapAlpha / 255)) |
                ((m_AlphaFlag >> 8) << 8));
         } else {
           m_MaskColor = FXARGB_MUL_ALPHA(m_MaskColor, m_BitmapAlpha);
         }
       }
       m_pDevice->CompositeMask(
           m_pTransformer->result().left, m_pTransformer->result().top,
           pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap.get(), m_MaskColor,
           0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_AlphaFlag,
           m_pIccTransform);
     } else {
       if (m_BitmapAlpha != 255)
         pBitmap->MultiplyAlpha(m_BitmapAlpha);
       m_pDevice->CompositeBitmap(
           m_pTransformer->result().left, m_pTransformer->result().top,
           pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap.get(), 0, 0,
           m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_pIccTransform);
     }
-    return FALSE;
+    return false;
   }
-  return FALSE;
+  return false;
 }
 
 CFX_BitmapStorer::CFX_BitmapStorer() {
 }
 
 CFX_BitmapStorer::~CFX_BitmapStorer() {
 }
 
 std::unique_ptr<CFX_DIBitmap> CFX_BitmapStorer::Detach() {
   return std::move(m_pBitmap);
@@ skipping 13 matching lines @@
           : nullptr;
   if (dest_buf)
     FXSYS_memcpy(dest_buf, scanline, m_pBitmap->GetPitch());
 
   if (dest_alpha_buf) {
     FXSYS_memcpy(dest_alpha_buf, scan_extra_alpha,
                  m_pBitmap->m_pAlphaMask->GetPitch());
   }
 }
 
-FX_BOOL CFX_BitmapStorer::SetInfo(int width,
-                                  int height,
-                                  FXDIB_Format src_format,
-                                  uint32_t* pSrcPalette) {
+bool CFX_BitmapStorer::SetInfo(int width,
+                               int height,
+                               FXDIB_Format src_format,
+                               uint32_t* pSrcPalette) {
   m_pBitmap = pdfium::MakeUnique<CFX_DIBitmap>();
   if (!m_pBitmap->Create(width, height, src_format)) {
     m_pBitmap.reset();
-    return FALSE;
+    return false;
   }
   if (pSrcPalette)
     m_pBitmap->CopyPalette(pSrcPalette);
-  return TRUE;
+  return true;
 }