FX_BOOL considered harmful.

core/src/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 "../../../include/fxge/fx_dib.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "dib_int.h"
 #include <limits.h>
@@ skipping 199 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 = NULL;
     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) < m_SrcWidth * m_SrcHeight * 8 / FXSYS_abs(dest_width)) {
             flags = FXDIB_INTERPOL;
         }
         m_Flags = flags;
     } else {
         m_Flags = FXDIB_NOSMOOTH;
         if (flags & FXDIB_DOWNSAMPLE) {
             m_Flags |= FXDIB_DOWNSAMPLE;
         }
     }
@@ skipping 42 matching lines @@
             }
         }
     } else {
         if (!m_bHasAlpha) {
             m_TransMethod = 7;
         } else {
             m_TransMethod = 8;
         }
     }
 }
-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;
 }
 CStretchEngine::~CStretchEngine()
 {
     if (m_pDestScanline) {
         FX_Free(m_pDestScanline);
     }
     if (m_pInterBuf) {
         FX_Free(m_pInterBuf);
     }
     if (m_pExtraAlphaBuf) {
         FX_Free(m_pExtraAlphaBuf);
     }
     if (m_pDestMaskScanline) {
         FX_Free(m_pDestMaskScanline);
     }
 }
-FX_BOOL CStretchEngine::StartStretchHorz()
+bool CStretchEngine::StartStretchHorz()
 {
     if (m_DestWidth == 0 || m_pDestScanline == NULL || m_SrcClip.Height() > (int)((1U << 29) / m_InterPitch) || m_SrcClip.Height() == 0) {
-        return FALSE;
+        return false;
     }
     m_pInterBuf = FX_TryAlloc(unsigned char, m_SrcClip.Height() * m_InterPitch);
     if (m_pInterBuf == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_pSource && m_bHasAlpha && m_pSource->m_pAlphaMask) {
         m_pExtraAlphaBuf = FX_Alloc2D(unsigned char, m_SrcClip.Height(), m_ExtraMaskPitch);
         FX_DWORD size = (m_DestClip.Width() * 8 + 31) / 32 * 4;
         m_pDestMaskScanline = FX_TryAlloc(unsigned char, size);
         if (!m_pDestMaskScanline) {
-            return FALSE;
+            return false;
         }
     }
     m_WeightTable.Calc(m_DestWidth, m_DestClip.left, m_DestClip.right, m_SrcWidth, m_SrcClip.left, m_SrcClip.right, m_Flags);
     if (m_WeightTable.m_pWeightTables == NULL) {
-        return FALSE;
+        return false;
     }
     m_CurRow = m_SrcClip.top;
     m_State = 1;
-    return TRUE;
+    return true;
 }
 #define FX_STRECH_PAUSE_ROWS    10
-FX_BOOL CStretchEngine::ContinueStretchHorz(IFX_Pause* pPause)
+bool CStretchEngine::ContinueStretchHorz(IFX_Pause* pPause)
 {
     if (!m_DestWidth) {
         return 0;
     }
     if (m_pSource->SkipToScanline(m_CurRow, pPause)) {
-        return TRUE;
+        return true;
     }
     int Bpp = m_DestBpp / 8;
     int rows_to_go = FX_STRECH_PAUSE_ROWS;
     for (; m_CurRow < m_SrcClip.bottom; m_CurRow ++) {
         if (rows_to_go == 0) {
             if (pPause && pPause->NeedToPauseNow()) {
-                return TRUE;
+                return true;
             } else {
                 rows_to_go = FX_STRECH_PAUSE_ROWS;
             }
         }
         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 = NULL;
         uint8_t* dest_scan_mask = NULL;
         if (m_pExtraAlphaBuf) {
             src_scan_mask = m_pSource->m_pAlphaMask->GetScanline(m_CurRow);
@@ skipping 167 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;
     table.Calc(m_DestHeight, m_DestClip.top, m_DestClip.bottom, m_SrcHeight, m_SrcClip.top, m_SrcClip.bottom, m_Flags);
     if (table.m_pWeightTables == NULL) {
         return;
@@ skipping 144 matching lines @@
         format = FXDIB_8bppMask;
     } else if (format == FXDIB_1bppRgb) {
         format = FXDIB_8bppRgb;
     } else if (format == FXDIB_8bppRgb) {
         if (pSrc->GetPalette()) {
             format = FXDIB_Rgb;
         }
     }
     return format;
 }
-FX_BOOL CFX_ImageStretcher::Start(IFX_ScanlineComposer* pDest,
+bool CFX_ImageStretcher::Start(IFX_ScanlineComposer* pDest,
                                   const CFX_DIBSource* pSource, int dest_width, int dest_height,
                                   const FX_RECT& rect, FX_DWORD flags)
 {
     m_DestFormat = _GetStretchedFormat(pSource);
     m_DestBPP = m_DestFormat & 0xff;
     m_pDest = pDest;
     m_pSource = pSource;
     m_DestWidth = dest_width;
     m_DestHeight = dest_height;
     m_ClipRect = rect;
     m_Flags = flags;
     if (pSource->GetFormat() == FXDIB_1bppRgb && pSource->GetPalette()) {
         FX_ARGB pal[256];
         int a0, r0, g0, b0, a1, r1, g1, b1;
         ArgbDecode(pSource->GetPaletteEntry(0), a0, r0, g0, b0);
         ArgbDecode(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 (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, pal)) {
-            return FALSE;
+            return false;
         }
     } else if (pSource->GetFormat() == FXDIB_1bppCmyk && pSource->GetPalette()) {
         FX_CMYK pal[256];
         int c0, m0, y0, k0, c1, m1, y1, k1;
         CmykDecode(pSource->GetPaletteEntry(0), c0, m0, y0, k0);
         CmykDecode(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 (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, pal)) {
-            return FALSE;
+            return false;
         }
     } else if (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, NULL)) {
-        return FALSE;
+        return false;
     }
     if (flags & FXDIB_DOWNSAMPLE) {
         return StartQuickStretch();
     } else {
         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);
     } else {
         return ContinueStretch(pPause);
     }
 }
 #define MAX_PROGRESSIVE_STRETCH_PIXELS  1000000
-FX_BOOL CFX_ImageStretcher::StartStretch()
+bool CFX_ImageStretcher::StartStretch()
 {
     m_pStretchEngine = new CStretchEngine(m_pDest, m_DestFormat, m_DestWidth, m_DestHeight, m_ClipRect, m_pSource, m_Flags);
     m_pStretchEngine->StartStretchHorz();
     if (m_pSource->GetWidth() * m_pSource->GetHeight() < MAX_PROGRESSIVE_STRETCH_PIXELS) {
         m_pStretchEngine->Continue(NULL);
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_ImageStretcher::ContinueStretch(IFX_Pause* pPause)
+bool CFX_ImageStretcher::ContinueStretch(IFX_Pause* pPause)
 {
     if (m_pStretchEngine == NULL) {
-        return FALSE;
+        return false;
     }
     return m_pStretchEngine->Continue(pPause);
 }
-FX_BOOL CFX_ImageStretcher::StartQuickStretch()
+bool CFX_ImageStretcher::StartQuickStretch()
 {
-    m_bFlipX = FALSE;
-    m_bFlipY = FALSE;
+    m_bFlipX = false;
+    m_bFlipY = false;
     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;
     }
     m_LineIndex = 0;
     FX_DWORD size = m_ClipRect.Width();
     if (size && m_DestBPP > (int)(INT_MAX / size)) {
-        return FALSE;
+        return false;
     }
     size *= m_DestBPP;
     m_pScanline = FX_Alloc(uint8_t, (size / 8 + 3) / 4 * 4);
     if (m_pSource->m_pAlphaMask) {
         m_pMaskScanline = FX_Alloc(uint8_t, (m_ClipRect.Width() + 3) / 4 * 4);
     }
     if (m_pSource->GetWidth() * m_pSource->GetHeight() < MAX_PROGRESSIVE_STRETCH_PIXELS) {
         ContinueQuickStretch(NULL);
-        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 == NULL) {
-        return FALSE;
+        return false;
     }
     int result_width = m_ClipRect.Width(), result_height = m_ClipRect.Height();
     int src_height = m_pSource->GetHeight();
     for (; m_LineIndex < result_height; m_LineIndex ++) {
         int dest_y, 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;
         }
         if (src_y >= src_height) {
             src_y = src_height - 1;
         }
         if (src_y < 0) {
             src_y = 0;
         }
         if (m_pSource->SkipToScanline(src_y, pPause)) {
-            return TRUE;
+            return true;
         }
         m_pSource->DownSampleScanline(src_y, m_pScanline, m_DestBPP, m_DestWidth, m_bFlipX, m_ClipRect.left, result_width);
         if (m_pMaskScanline) {
             m_pSource->m_pAlphaMask->DownSampleScanline(src_y, m_pMaskScanline, 1, m_DestWidth, m_bFlipX, m_ClipRect.left, result_width);
         }
         m_pDest->ComposeScanline(dest_y, m_pScanline, m_pMaskScanline);
     }
-    return FALSE;
+    return false;
 }