FX_BOOL considered harmful.

core/src/fxcodec/jbig2/JBig2_Image.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include <limits.h>
 
 #include "../../../include/fxcrt/fx_coordinates.h"
 #include "../../../include/fxcrt/fx_safe_types.h"
 #include "JBig2_Image.h"
 
 CJBig2_Image::CJBig2_Image(int32_t w, int32_t h)
 {
     m_nWidth    = w;
     m_nHeight   = h;
     if (m_nWidth <= 0 || m_nHeight <= 0 || m_nWidth > INT_MAX - 31) {
         m_pData = NULL;
-        m_bNeedFree = FALSE;
+        m_bNeedFree = false;
         return;
     }
     m_nStride  = ((w + 31) >> 5) << 2;
     if (m_nStride * m_nHeight > 0 && 104857600 / (int)m_nStride > m_nHeight) {
         m_pData = (uint8_t *)m_pModule->JBig2_Malloc2(m_nStride, m_nHeight);
     } else {
         m_pData = NULL;
     }
-    m_bNeedFree = TRUE;
+    m_bNeedFree = true;
 }
 CJBig2_Image::CJBig2_Image(int32_t w, int32_t h, int32_t stride, uint8_t*pBuf)
 {
     m_nWidth = w;
     m_nHeight = h;
     m_nStride = stride;
     m_pData = pBuf;
-    m_bNeedFree = FALSE;
+    m_bNeedFree = false;
 }
 CJBig2_Image::CJBig2_Image(CJBig2_Image &im)
 {
     m_pModule = im.m_pModule;
     m_nWidth    = im.m_nWidth;
     m_nHeight   = im.m_nHeight;
     m_nStride   = im.m_nStride;
     if (im.m_pData) {
         m_pData = (uint8_t*)m_pModule->JBig2_Malloc2(m_nStride, m_nHeight);
         JBIG2_memcpy(m_pData, im.m_pData, m_nStride * m_nHeight);
     } else {
         m_pData = NULL;
     }
-    m_bNeedFree = TRUE;
+    m_bNeedFree = true;
 }
 CJBig2_Image::~CJBig2_Image()
 {
     if(m_bNeedFree && m_pData) {
         m_pModule->JBig2_Free(m_pData);
     }
 }
-FX_BOOL CJBig2_Image::getPixel(int32_t x, int32_t y)
+bool CJBig2_Image::getPixel(int32_t x, int32_t y)
 {
     if (!m_pData) {
         return 0;
     }
     int32_t m, n;
     if(x < 0 || x >= m_nWidth) {
         return 0;
     }
     if(y < 0 || y >= m_nHeight) {
         return 0;
     }
     m = y * m_nStride + (x >> 3);
     n = x & 7;
     return ((m_pData[m] >> (7 - n)) & 1);
 }
 
-int32_t CJBig2_Image::setPixel(int32_t x, int32_t y, FX_BOOL v)
+int32_t CJBig2_Image::setPixel(int32_t x, int32_t y, bool v)
 {
     if (!m_pData) {
         return 0;
     }
     int32_t m, n;
     if(x < 0 || x >= m_nWidth) {
         return 0;
     }
     if(y < 0 || y >= m_nHeight) {
         return 0;
@@ skipping 11 matching lines @@
 {
     if (!m_pData) {
         return;
     }
     if(hFrom < 0 || hFrom >= m_nHeight) {
         JBIG2_memset(m_pData + hTo * m_nStride, 0, m_nStride);
     } else {
         JBIG2_memcpy(m_pData + hTo * m_nStride, m_pData + hFrom * m_nStride, m_nStride);
     }
 }
-void CJBig2_Image::fill(FX_BOOL v)
+void CJBig2_Image::fill(bool v)
 {
     if (!m_pData) {
         return;
     }
     JBIG2_memset(m_pData, v ? 0xff : 0, m_nStride * m_nHeight);
 }
-FX_BOOL CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
+bool CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
 {
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     return composeTo_opt2(pDst, x, y, op);
 }
-FX_BOOL CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect)
+bool CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect)
 {
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     if (NULL == pSrcRect || *pSrcRect == FX_RECT(0, 0, m_nWidth, m_nHeight)) {
         return composeTo_opt2(pDst, x, y, op);
     }
     return composeTo_opt2(pDst, x, y, op, pSrcRect);
 }
-FX_BOOL CJBig2_Image::composeTo_unopt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
+bool CJBig2_Image::composeTo_unopt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
 {
     int32_t w, h, dx, dy;
     int32_t i, j;
     w = m_nWidth;
     h = m_nHeight;
     dx = dy = 0;
     if(x < 0) {
         dx += -x;
         w  -= -x;
         x = 0;
@@ skipping 43 matching lines @@
             }
             break;
         case JBIG2_COMPOSE_REPLACE:
             for(j = 0; j < h; j++) {
                 for(i = 0; i < w; i++) {
                     pDst->setPixel(x + i, y + j, getPixel(i + dx, j + dy));
                 }
             }
             break;
     }
-    return TRUE;
+    return true;
 }
 
-FX_BOOL CJBig2_Image::composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
+bool CJBig2_Image::composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
 {
     int32_t x0, x1, y0, y1, xx, yy;
     uint8_t *pLineSrc, *pLineDst, *srcPtr, *destPtr;
     FX_DWORD src0, src1, src, dest, s1, s2, m1, m2, m3;
-    FX_BOOL oneByte;
+    bool oneByte;
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     if (y < 0) {
         y0 = -y;
     } else {
         y0 = 0;
     }
     if (y + m_nHeight > pDst->m_nHeight) {
         y1 = pDst->m_nHeight - y;
     } else {
         y1 = m_nHeight;
     }
     if (y0 >= y1) {
-        return FALSE;
+        return false;
     }
     if (x >= 0) {
         x0 = x & ~7;
     } else {
         x0 = 0;
     }
     x1 = x + m_nWidth;
     if (x1 > pDst->m_nWidth) {
         x1 = pDst->m_nWidth;
     }
     if (x0 >= x1) {
-        return FALSE;
+        return false;
     }
     s1 = x & 7;
     s2 = 8 - s1;
     m1 = 0xff >> (x1 & 7);
     m2 = 0xff << (((x1 & 7) == 0) ? 0 : 8 - (x1 & 7));
     m3 = (0xff >> s1) & m2;
     oneByte = x0 == ((x1 - 1) & ~7);
     pLineDst = pDst->m_pData + y * pDst->m_nStride;
     pLineSrc = m_pData + y0 * m_nStride;
     if(oneByte) {
@@ skipping 431 matching lines @@
                             dest = (src & m2) | (dest & m1);
                             *destPtr = (uint8_t)dest;
                             pLineDst += pDst->m_nStride;
                             pLineSrc += m_nStride;
                         }
                     }
                     break;
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op)
+bool CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op)
 {
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     return pSrc->composeTo(this, x, y, op);
 }
-FX_BOOL CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op, const FX_RECT* pSrcRect)
+bool CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op, const FX_RECT* pSrcRect)
 {
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     return pSrc->composeTo(this, x, y, op, pSrcRect);
 }
 CJBig2_Image *CJBig2_Image::subImage_unopt(int32_t x, int32_t y, int32_t w, int32_t h)
 {
     CJBig2_Image *pImage;
     int32_t i, j;
     JBIG2_ALLOC(pImage, CJBig2_Image(w, h));
     for(j = 0; j < h; j++) {
         for(i = 0; i < w; i++) {
@@ skipping 53 matching lines @@
                 pDst[1] = (uint8_t)(wTmp >> 16);
                 pDst[2] = (uint8_t)(wTmp >> 8);
                 pDst[3] = (uint8_t)wTmp;
             }
             pLineSrc += m_nStride;
             pLineDst += pImage->m_nStride;
         }
     }
     return pImage;
 }
-void CJBig2_Image::expand(int32_t h, FX_BOOL v)
+void CJBig2_Image::expand(int32_t h, bool v)
 {
     if (!m_pData || h <= m_nHeight) {
         return;
     }
     FX_DWORD dwH = pdfium::base::checked_cast<FX_DWORD>(h);
     FX_DWORD dwStride = pdfium::base::checked_cast<FX_DWORD>(m_nStride);
     FX_DWORD dwHeight = pdfium::base::checked_cast<FX_DWORD>(m_nHeight);
     FX_SAFE_DWORD safeMemSize = dwH; 
     safeMemSize *= dwStride;
     if (!safeMemSize.IsValid()) {
         return;
     }
     //The guaranteed reallocated memory is to be < 4GB (unsigned int). 
     m_pData = (uint8_t*)m_pModule->JBig2_Realloc(m_pData, safeMemSize.ValueOrDie());
     //The result of dwHeight * dwStride doesn't overflow after the 
     //checking of safeMemSize.
     //The same as the result of (dwH - dwHeight) * dwStride) because
     //dwH - dwHeight is always less than dwH(h) which is checked in
     //the calculation of dwH * dwStride. 
     JBIG2_memset(m_pData + dwHeight * dwStride, v ? 0xff : 0, (dwH - dwHeight) * dwStride);
     m_nHeight = h;
 }
-FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
+bool CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
 {
     int32_t xs0 = 0, ys0  = 0, xs1  = 0, ys1   = 0, xd0    = 0, yd0          = 0, xd1      = 0, 
              yd1 = 0, xx   = 0, yy   = 0, w     = 0, h      = 0, middleDwords = 0, lineLeft = 0;
 
     FX_DWORD s1  = 0, d1   = 0, d2   = 0, shift = 0, shift1 = 0, shift2       = 0, 
              tmp = 0, tmp1 = 0, tmp2 = 0, maskL = 0, maskR  = 0, maskM        = 0;
 
     uint8_t *lineSrc = NULL, *lineDst = NULL, *sp = NULL, *dp = NULL;
 
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
-        return FALSE;
+        return false;
     }
     if(y < 0) {
         ys0 = -y;
     }
     if(y + m_nHeight > pDst->m_nHeight) {
         ys1 = pDst->m_nHeight - y;
     } else {
         ys1 = m_nHeight;
     }
     if(x < 0) {
@@ skipping 382 matching lines @@
                     dp[2] = (uint8_t)(tmp >> 8);
                     dp[3] = (uint8_t)tmp;
                 }
                 lineSrc += m_nStride;
                 lineDst += pDst->m_nStride;
             }
         }
     }
     return 1;
 }
-FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect)
+bool CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect)
 {
     int32_t xs0, ys0, xs1, ys1, xd0, yd0, xd1, yd1, xx, yy, w, h, middleDwords, lineLeft;
     FX_DWORD s1, d1, d2, shift, shift1, shift2, tmp, tmp1, tmp2, maskL, maskR, maskM;
     uint8_t *lineSrc, *lineDst, *sp, *dp;
     int32_t sw, sh;
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
-        return FALSE;
+        return false;
     }
     sw = pSrcRect->Width();
     sh = pSrcRect->Height();
     if(y < 0) {
         ys0 = -y;
     } else {
         ys0 = 0;
     }
     if(y + sh > pDst->m_nHeight) {
         ys1 = pDst->m_nHeight - y;
@@ skipping 392 matching lines @@
                     dp[2] = (uint8_t)(tmp >> 8);
                     dp[3] = (uint8_t)tmp;
                 }
                 lineSrc += m_nStride;
                 lineDst += pDst->m_nStride;
             }
         }
     }
     return 1;
 }