Remove FX_BOOL from core

core/fxge/dib/fx_dib_engine.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 <limits.h>
 
 #include <algorithm>
 
@@ skipping 290 matching lines @@
     FXSYS_memset(m_pDestScanline, 255, size);
   }
   m_InterPitch = (m_DestClip.Width() * m_DestBpp + 31) / 32 * 4;
   m_ExtraMaskPitch = (m_DestClip.Width() * 8 + 31) / 32 * 4;
   m_pInterBuf = nullptr;
   m_pSource = pSrcBitmap;
   m_SrcWidth = pSrcBitmap->GetWidth();
   m_SrcHeight = pSrcBitmap->GetHeight();
   m_SrcPitch = (m_SrcWidth * m_SrcBpp + 31) / 32 * 4;
   if ((flags & FXDIB_NOSMOOTH) == 0) {
-    FX_BOOL bInterpol =
-        flags & FXDIB_INTERPOL || flags & FXDIB_BICUBIC_INTERPOL;
+    bool bInterpol = flags & FXDIB_INTERPOL || flags & FXDIB_BICUBIC_INTERPOL;
     if (!bInterpol && FXSYS_abs(dest_width) != 0 &&
         FXSYS_abs(dest_height) / 8 < static_cast<long long>(m_SrcWidth) *
                                          m_SrcHeight / FXSYS_abs(dest_width)) {
       flags = FXDIB_INTERPOL;
     }
     m_Flags = flags;
   } else {
     m_Flags = FXDIB_NOSMOOTH;
     if (flags & FXDIB_DOWNSAMPLE) {
       m_Flags |= FXDIB_DOWNSAMPLE;
@@ skipping 52 matching lines @@
   }
 }
 
 CStretchEngine::~CStretchEngine() {
   FX_Free(m_pDestScanline);
   FX_Free(m_pInterBuf);
   FX_Free(m_pExtraAlphaBuf);
   FX_Free(m_pDestMaskScanline);
 }
 
-FX_BOOL CStretchEngine::Continue(IFX_Pause* pPause) {
+bool CStretchEngine::Continue(IFX_Pause* pPause) {
   while (m_State == 1) {
     if (ContinueStretchHorz(pPause)) {
-      return TRUE;
+      return true;
     }
     m_State = 2;
     StretchVert();
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CStretchEngine::StartStretchHorz() {
+bool CStretchEngine::StartStretchHorz() {
   if (m_DestWidth == 0 || m_InterPitch == 0 || !m_pDestScanline)
-    return FALSE;
+    return false;
 
   if (m_SrcClip.Height() == 0 ||
       m_SrcClip.Height() > (1 << 29) / m_InterPitch) {
-    return FALSE;
+    return false;
   }
 
   m_pInterBuf = FX_TryAlloc(unsigned char, m_SrcClip.Height() * m_InterPitch);
   if (!m_pInterBuf)
-    return FALSE;
+    return false;
 
   if (m_pSource && m_bHasAlpha && m_pSource->m_pAlphaMask) {
     m_pExtraAlphaBuf =
         FX_Alloc2D(unsigned char, m_SrcClip.Height(), m_ExtraMaskPitch);
     uint32_t size = (m_DestClip.Width() * 8 + 31) / 32 * 4;
     m_pDestMaskScanline = FX_TryAlloc(unsigned char, size);
     if (!m_pDestMaskScanline)
-      return FALSE;
+      return false;
   }
   bool ret =
       m_WeightTable.Calc(m_DestWidth, m_DestClip.left, m_DestClip.right,
                          m_SrcWidth, m_SrcClip.left, m_SrcClip.right, m_Flags);
   if (!ret)
-    return FALSE;
+    return false;
 
   m_CurRow = m_SrcClip.top;
   m_State = 1;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CStretchEngine::ContinueStretchHorz(IFX_Pause* pPause) {
+bool CStretchEngine::ContinueStretchHorz(IFX_Pause* pPause) {
   if (!m_DestWidth)
-    return FALSE;
+    return false;
 
   if (m_pSource->SkipToScanline(m_CurRow, pPause))
-    return TRUE;
+    return true;
 
   int Bpp = m_DestBpp / 8;
   static const int kStrechPauseRows = 10;
   int rows_to_go = kStrechPauseRows;
   for (; m_CurRow < m_SrcClip.bottom; m_CurRow++) {
     if (rows_to_go == 0) {
       if (pPause && pPause->NeedToPauseNow())
-        return TRUE;
+        return true;
 
       rows_to_go = kStrechPauseRows;
     }
 
     const uint8_t* src_scan = m_pSource->GetScanline(m_CurRow);
     uint8_t* dest_scan =
         m_pInterBuf + (m_CurRow - m_SrcClip.top) * m_InterPitch;
     const uint8_t* src_scan_mask = nullptr;
     uint8_t* dest_scan_mask = nullptr;
     if (m_pExtraAlphaBuf) {
       src_scan_mask = m_pSource->m_pAlphaMask->GetScanline(m_CurRow);
       dest_scan_mask =
           m_pExtraAlphaBuf + (m_CurRow - m_SrcClip.top) * m_ExtraMaskPitch;
     }
     switch (m_TransMethod) {
       case 1:
       case 2: {
         for (int col = m_DestClip.left; col < m_DestClip.right; col++) {
           PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
           int dest_a = 0;
           for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
                j++) {
             int* pWeight =
                 m_WeightTable.GetValueFromPixelWeight(pPixelWeights, j);
             if (!pWeight)
-              return FALSE;
+              return false;
 
             int pixel_weight = *pWeight;
             if (src_scan[j / 8] & (1 << (7 - j % 8))) {
               dest_a += pixel_weight * 255;
             }
           }
           if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
           }
           *dest_scan++ = (uint8_t)(dest_a >> 16);
         }
         break;
       }
       case 3: {
         for (int col = m_DestClip.left; col < m_DestClip.right; col++) {
           PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
           int dest_a = 0;
           for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
                j++) {
             int* pWeight =
                 m_WeightTable.GetValueFromPixelWeight(pPixelWeights, j);
             if (!pWeight)
-              return FALSE;
+              return false;
 
             int pixel_weight = *pWeight;
             dest_a += pixel_weight * src_scan[j];
           }
           if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
             dest_a = dest_a < 0 ? 0 : dest_a > 16711680 ? 16711680 : dest_a;
           }
           *dest_scan++ = (uint8_t)(dest_a >> 16);
         }
         break;
       }
       case 4: {
         for (int col = m_DestClip.left; col < m_DestClip.right; col++) {
           PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
           int dest_a = 0, dest_r = 0;
           for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
                j++) {
             int* pWeight =
                 m_WeightTable.GetValueFromPixelWeight(pPixelWeights, j);
             if (!pWeight)
-              return FALSE;
+              return false;
 
             int pixel_weight = *pWeight;
             pixel_weight = pixel_weight * src_scan_mask[j] / 255;
             dest_r += pixel_weight * src_scan[j];
             dest_a += pixel_weight;
           }
           if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
             dest_r = dest_r < 0 ? 0 : dest_r > 16711680 ? 16711680 : dest_r;
             dest_a = dest_a < 0 ? 0 : dest_a > 65536 ? 65536 : dest_a;
           }
           *dest_scan++ = (uint8_t)(dest_r >> 16);
           *dest_scan_mask++ = (uint8_t)((dest_a * 255) >> 16);
         }
         break;
       }
       case 5: {
         for (int col = m_DestClip.left; col < m_DestClip.right; col++) {
           PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
           int dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
           for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
                j++) {
             int* pWeight =
                 m_WeightTable.GetValueFromPixelWeight(pPixelWeights, j);
             if (!pWeight)
-              return FALSE;
+              return false;
 
             int pixel_weight = *pWeight;
             unsigned long argb_cmyk = m_pSrcPalette[src_scan[j]];
             if (m_DestFormat == FXDIB_Rgb) {
               dest_r_y += pixel_weight * (uint8_t)(argb_cmyk >> 16);
               dest_g_m += pixel_weight * (uint8_t)(argb_cmyk >> 8);
               dest_b_c += pixel_weight * (uint8_t)argb_cmyk;
             } else {
               dest_b_c += pixel_weight * (uint8_t)(argb_cmyk >> 24);
               dest_g_m += pixel_weight * (uint8_t)(argb_cmyk >> 16);
@@ skipping 16 matching lines @@
       }
       case 6: {
         for (int col = m_DestClip.left; col < m_DestClip.right; col++) {
           PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
           int dest_a = 0, dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
           for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
                j++) {
             int* pWeight =
                 m_WeightTable.GetValueFromPixelWeight(pPixelWeights, j);
             if (!pWeight)
-              return FALSE;
+              return false;
 
             int pixel_weight = *pWeight;
             pixel_weight = pixel_weight * src_scan_mask[j] / 255;
             unsigned long argb_cmyk = m_pSrcPalette[src_scan[j]];
             if (m_DestFormat == FXDIB_Rgba) {
               dest_r_y += pixel_weight * (uint8_t)(argb_cmyk >> 16);
               dest_g_m += pixel_weight * (uint8_t)(argb_cmyk >> 8);
               dest_b_c += pixel_weight * (uint8_t)argb_cmyk;
             } else {
               dest_b_c += pixel_weight * (uint8_t)(argb_cmyk >> 24);
@@ skipping 20 matching lines @@
       }
       case 7: {
         for (int col = m_DestClip.left; col < m_DestClip.right; col++) {
           PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
           int dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
           for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
                j++) {
             int* pWeight =
                 m_WeightTable.GetValueFromPixelWeight(pPixelWeights, j);
             if (!pWeight)
-              return FALSE;
+              return false;
 
             int pixel_weight = *pWeight;
             const uint8_t* src_pixel = src_scan + j * Bpp;
             dest_b_c += pixel_weight * (*src_pixel++);
             dest_g_m += pixel_weight * (*src_pixel++);
             dest_r_y += pixel_weight * (*src_pixel);
           }
           if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
             dest_b_c =
                 dest_b_c < 0 ? 0 : dest_b_c > 16711680 ? 16711680 : dest_b_c;
@@ skipping 11 matching lines @@
       }
       case 8: {
         for (int col = m_DestClip.left; col < m_DestClip.right; col++) {
           PixelWeight* pPixelWeights = m_WeightTable.GetPixelWeight(col);
           int dest_a = 0, dest_r_y = 0, dest_g_m = 0, dest_b_c = 0;
           for (int j = pPixelWeights->m_SrcStart; j <= pPixelWeights->m_SrcEnd;
                j++) {
             int* pWeight =
                 m_WeightTable.GetValueFromPixelWeight(pPixelWeights, j);
             if (!pWeight)
-              return FALSE;
+              return false;
 
             int pixel_weight = *pWeight;
             const uint8_t* src_pixel = src_scan + j * Bpp;
             if (m_DestFormat == FXDIB_Argb) {
               pixel_weight = pixel_weight * src_pixel[3] / 255;
             } else {
               pixel_weight = pixel_weight * src_scan_mask[j] / 255;
             }
             dest_b_c += pixel_weight * (*src_pixel++);
             dest_g_m += pixel_weight * (*src_pixel++);
@@ skipping 18 matching lines @@
           if (dest_scan_mask) {
             *dest_scan_mask++ = (uint8_t)((dest_a * 255) >> 16);
           }
           dest_scan += Bpp - 3;
         }
         break;
       }
     }
     rows_to_go--;
   }
-  return FALSE;
+  return false;
 }
 
 void CStretchEngine::StretchVert() {
   if (m_DestHeight == 0)
     return;
 
   CWeightTable table;
   bool ret = table.Calc(m_DestHeight, m_DestClip.top, m_DestClip.bottom,
                         m_SrcHeight, m_SrcClip.top, m_SrcClip.bottom, m_Flags);
   if (!ret)
@@ skipping 162 matching lines @@
 
 CFX_ImageStretcher::CFX_ImageStretcher(IFX_ScanlineComposer* pDest,
                                        const CFX_DIBSource* pSource,
                                        int dest_width,
                                        int dest_height,
                                        const FX_RECT& bitmap_rect,
                                        uint32_t flags)
     : m_pDest(pDest),
       m_pSource(pSource),
       m_Flags(flags),
-      m_bFlipX(FALSE),
-      m_bFlipY(FALSE),
+      m_bFlipX(false),
+      m_bFlipY(false),
       m_DestWidth(dest_width),
       m_DestHeight(dest_height),
       m_ClipRect(bitmap_rect),
       m_DestFormat(GetStretchedFormat(*pSource)),
       m_DestBPP(m_DestFormat & 0xff),
       m_LineIndex(0) {}
 
 CFX_ImageStretcher::~CFX_ImageStretcher() {
 }
 
-FX_BOOL CFX_ImageStretcher::Start() {
+bool CFX_ImageStretcher::Start() {
   if (m_DestWidth == 0 || m_DestHeight == 0)
-    return FALSE;
+    return false;
 
   if (m_pSource->GetFormat() == FXDIB_1bppRgb && m_pSource->GetPalette()) {
     FX_ARGB pal[256];
     int a0, r0, g0, b0, a1, r1, g1, b1;
     ArgbDecode(m_pSource->GetPaletteEntry(0), a0, r0, g0, b0);
     ArgbDecode(m_pSource->GetPaletteEntry(1), a1, r1, g1, b1);
     for (int i = 0; i < 256; i++) {
       int a = a0 + (a1 - a0) * i / 255;
       int r = r0 + (r1 - r0) * i / 255;
       int g = g0 + (g1 - g0) * i / 255;
       int b = b0 + (b1 - b0) * i / 255;
       pal[i] = ArgbEncode(a, r, g, b);
     }
     if (!m_pDest->SetInfo(m_ClipRect.Width(), m_ClipRect.Height(), m_DestFormat,
                           pal)) {
-      return FALSE;
+      return false;
     }
   } else if (m_pSource->GetFormat() == FXDIB_1bppCmyk &&
              m_pSource->GetPalette()) {
     FX_CMYK pal[256];
     int c0, m0, y0, k0, c1, m1, y1, k1;
     CmykDecode(m_pSource->GetPaletteEntry(0), c0, m0, y0, k0);
     CmykDecode(m_pSource->GetPaletteEntry(1), c1, m1, y1, k1);
     for (int i = 0; i < 256; i++) {
       int c = c0 + (c1 - c0) * i / 255;
       int m = m0 + (m1 - m0) * i / 255;
       int y = y0 + (y1 - y0) * i / 255;
       int k = k0 + (k1 - k0) * i / 255;
       pal[i] = CmykEncode(c, m, y, k);
     }
     if (!m_pDest->SetInfo(m_ClipRect.Width(), m_ClipRect.Height(), m_DestFormat,
                           pal)) {
-      return FALSE;
+      return false;
     }
   } else if (!m_pDest->SetInfo(m_ClipRect.Width(), m_ClipRect.Height(),
                                m_DestFormat, nullptr)) {
-    return FALSE;
+    return false;
   }
 
   if (m_Flags & FXDIB_DOWNSAMPLE)
     return StartQuickStretch();
   return StartStretch();
 }
 
-FX_BOOL CFX_ImageStretcher::Continue(IFX_Pause* pPause) {
+bool CFX_ImageStretcher::Continue(IFX_Pause* pPause) {
   if (m_Flags & FXDIB_DOWNSAMPLE)
     return ContinueQuickStretch(pPause);
   return ContinueStretch(pPause);
 }
 
-FX_BOOL CFX_ImageStretcher::StartStretch() {
+bool CFX_ImageStretcher::StartStretch() {
   m_pStretchEngine = pdfium::MakeUnique<CStretchEngine>(
       m_pDest, m_DestFormat, m_DestWidth, m_DestHeight, m_ClipRect, m_pSource,
       m_Flags);
   m_pStretchEngine->StartStretchHorz();
   if (SourceSizeWithinLimit(m_pSource->GetWidth(), m_pSource->GetHeight())) {
     m_pStretchEngine->Continue(nullptr);
-    return FALSE;
+    return false;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_ImageStretcher::ContinueStretch(IFX_Pause* pPause) {
+bool CFX_ImageStretcher::ContinueStretch(IFX_Pause* pPause) {
   return m_pStretchEngine && m_pStretchEngine->Continue(pPause);
 }
 
-FX_BOOL CFX_ImageStretcher::StartQuickStretch() {
+bool CFX_ImageStretcher::StartQuickStretch() {
   if (m_DestWidth < 0) {
-    m_bFlipX = TRUE;
+    m_bFlipX = true;
     m_DestWidth = -m_DestWidth;
   }
   if (m_DestHeight < 0) {
-    m_bFlipY = TRUE;
+    m_bFlipY = true;
     m_DestHeight = -m_DestHeight;
   }
   uint32_t size = m_ClipRect.Width();
   if (size && m_DestBPP > (int)(INT_MAX / size)) {
-    return FALSE;
+    return false;
   }
   size *= m_DestBPP;
   m_pScanline.reset(FX_Alloc(uint8_t, (size / 8 + 3) / 4 * 4));
   if (m_pSource->m_pAlphaMask)
     m_pMaskScanline.reset(FX_Alloc(uint8_t, (m_ClipRect.Width() + 3) / 4 * 4));
 
   if (SourceSizeWithinLimit(m_pSource->GetWidth(), m_pSource->GetHeight())) {
     ContinueQuickStretch(nullptr);
-    return FALSE;
+    return false;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_ImageStretcher::ContinueQuickStretch(IFX_Pause* pPause) {
+bool CFX_ImageStretcher::ContinueQuickStretch(IFX_Pause* pPause) {
   if (!m_pScanline)
-    return FALSE;
+    return false;
 
   int result_width = m_ClipRect.Width();
   int result_height = m_ClipRect.Height();
   int src_height = m_pSource->GetHeight();
   for (; m_LineIndex < result_height; m_LineIndex++) {
     int dest_y;
     int src_y;
     if (m_bFlipY) {
       dest_y = result_height - m_LineIndex - 1;
       src_y = (m_DestHeight - (dest_y + m_ClipRect.top) - 1) * src_height /
               m_DestHeight;
     } else {
       dest_y = m_LineIndex;
       src_y = (dest_y + m_ClipRect.top) * src_height / m_DestHeight;
     }
     src_y = std::max(std::min(src_y, src_height - 1), 0);
 
     if (m_pSource->SkipToScanline(src_y, pPause))
-      return TRUE;
+      return true;
 
     m_pSource->DownSampleScanline(src_y, m_pScanline.get(), m_DestBPP,
                                   m_DestWidth, m_bFlipX, m_ClipRect.left,
                                   result_width);
     if (m_pMaskScanline) {
       m_pSource->m_pAlphaMask->DownSampleScanline(
           src_y, m_pMaskScanline.get(), 1, m_DestWidth, m_bFlipX,
           m_ClipRect.left, result_width);
     }
     m_pDest->ComposeScanline(dest_y, m_pScanline.get(), m_pMaskScanline.get());
   }
-  return FALSE;
+  return false;
 }