FX_BOOL considered harmful.

core/src/fxge/dib/fx_dib_transform.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 "dib_int.h"
 int SDP_Table[513] = {
     256, 256, 256, 256, 256, 256, 256, 256, 256, 255, 255, 255, 255, 255, 255, 254, 254, 254, 254,
@@ skipping 36 matching lines @@
         if (res_x < 0 && res_x > -base) {
             res_x = base + res_x;
         }
         if (res_y < 0 && res_x > -base) {
             res_y = base + res_y;
         }
         x1 /= base;
         y1 /= base;
     }
 };
-CFX_DIBitmap* CFX_DIBSource::SwapXY(FX_BOOL bXFlip, FX_BOOL bYFlip, const FX_RECT* pDestClip) const
+CFX_DIBitmap* CFX_DIBSource::SwapXY(bool bXFlip, bool bYFlip, const FX_RECT* pDestClip) const
 {
     FX_RECT dest_clip(0, 0, m_Height, m_Width);
     if (pDestClip) {
         dest_clip.Intersect(*pDestClip);
     }
     if (dest_clip.IsEmpty()) {
         return NULL;
     }
     CFX_DIBitmap* pTransBitmap = new CFX_DIBitmap;
     int result_height = dest_clip.Height(), result_width = dest_clip.Width();
@@ skipping 73 matching lines @@
             const uint8_t* src_scan = m_pAlphaMask->GetScanline(row) + col_start;
             for (int col = col_start; col < col_end; col ++) {
                 *dest_scan = *src_scan++;
                 dest_scan += dest_step;
             }
         }
     }
     return pTransBitmap;
 }
 #define FIX16_005 0.05f
-FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, FX_BOOL bFlipX, FX_BOOL bFlipY)
+FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, bool bFlipX, bool bFlipY)
 {
     FX_RECT rect;
     if (bFlipY) {
         rect.left = height - clip.top;
         rect.right = height - clip.bottom;
     } else {
         rect.left = clip.top;
         rect.right = clip.bottom;
     }
     if (bFlipX) {
@@ skipping 37 matching lines @@
     return storer.Detach();
 }
 CFX_ImageTransformer::CFX_ImageTransformer()
 {
     m_Status = 0;
     m_pMatrix = NULL;
 }
 CFX_ImageTransformer::~CFX_ImageTransformer()
 {
 }
-FX_BOOL CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineMatrix* pDestMatrix, int flags, const FX_RECT* pDestClip)
+bool CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineMatrix* pDestMatrix, int flags, const FX_RECT* pDestClip)
 {
     m_pMatrix = (CFX_AffineMatrix*)pDestMatrix;
     CFX_FloatRect unit_rect = pDestMatrix->GetUnitRect();
     FX_RECT result_rect = unit_rect.GetClosestRect();
     FX_RECT result_clip = result_rect;
     if (pDestClip) {
         result_clip.Intersect(*pDestClip);
     }
     if (result_clip.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     m_ResultLeft = result_clip.left;
     m_ResultTop = result_clip.top;
     m_ResultWidth = result_clip.Width();
     m_ResultHeight = result_clip.Height();
     m_Flags = flags;
     if (FXSYS_fabs(pDestMatrix->a) < FXSYS_fabs(pDestMatrix->b) / 20 &&
             FXSYS_fabs(pDestMatrix->d) < FXSYS_fabs(pDestMatrix->c) / 20 &&
             FXSYS_fabs(pDestMatrix->a) < 0.5f && FXSYS_fabs(pDestMatrix->d) < 0.5f) {
         int dest_width = result_rect.Width();
         int dest_height = result_rect.Height();
         result_clip.Offset(-result_rect.left, -result_rect.top);
         result_clip = _FXDIB_SwapClipBox(result_clip, dest_width, dest_height, pDestMatrix->c > 0, pDestMatrix->b < 0);
         m_Stretcher.Start(&m_Storer, pSrc, dest_height, dest_width, result_clip, flags);
         m_Status = 1;
-        return TRUE;
+        return true;
     }
     if (FXSYS_fabs(pDestMatrix->b) < FIX16_005 && FXSYS_fabs(pDestMatrix->c) < FIX16_005) {
         int dest_width = pDestMatrix->a > 0 ? (int)FXSYS_ceil(pDestMatrix->a) : (int)FXSYS_floor(pDestMatrix->a);
         int dest_height = pDestMatrix->d > 0 ? (int) - FXSYS_ceil(pDestMatrix->d) : (int) - FXSYS_floor(pDestMatrix->d);
         result_clip.Offset(-result_rect.left, -result_rect.top);
         m_Stretcher.Start(&m_Storer, pSrc, dest_width, dest_height, result_clip, flags);
         m_Status = 2;
-        return TRUE;
+        return true;
     }
     int stretch_width = (int)FXSYS_ceil(FXSYS_sqrt2(pDestMatrix->a, pDestMatrix->b));
     int stretch_height = (int)FXSYS_ceil(FXSYS_sqrt2(pDestMatrix->c, pDestMatrix->d));
     CFX_AffineMatrix stretch2dest(1.0f, 0.0f, 0.0f, -1.0f, 0.0f, (FX_FLOAT)(stretch_height));
     stretch2dest.Concat(pDestMatrix->a / stretch_width, pDestMatrix->b / stretch_width,
                         pDestMatrix->c / stretch_height, pDestMatrix->d / stretch_height, pDestMatrix->e, pDestMatrix->f);
     m_dest2stretch.SetReverse(stretch2dest);
     CFX_FloatRect clip_rect_f(result_clip);
     clip_rect_f.Transform(&m_dest2stretch);
     m_StretchClip = clip_rect_f.GetOutterRect();
     m_StretchClip.Intersect(0, 0, stretch_width, stretch_height);
     m_Stretcher.Start(&m_Storer, pSrc, stretch_width, stretch_height, m_StretchClip, flags);
     m_Status = 3;
-    return TRUE;
+    return true;
 }
 uint8_t _bilinear_interpol(const uint8_t* buf, int row_offset_l, int row_offset_r,
                            int src_col_l, int src_col_r, int res_x, int res_y,
                            int bpp, int c_offset)
 {
     int i_resx = 255 - res_x;
     int col_bpp_l = src_col_l * bpp;
     int col_bpp_r = src_col_r * bpp;
     const uint8_t* buf_u = buf + row_offset_l + c_offset;
     const uint8_t* buf_d = buf + row_offset_r + c_offset;
@@ skipping 60 matching lines @@
         format = FXDIB_8bppMask;
     } else if (format >= 1025) {
         format = FXDIB_Cmyka;
     } else if (format <= 32 || format == FXDIB_Argb) {
         format = FXDIB_Argb;
     } else {
         format = FXDIB_Rgba;
     }
     return format;
 }
-FX_BOOL CFX_ImageTransformer::Continue(IFX_Pause* pPause)
+bool CFX_ImageTransformer::Continue(IFX_Pause* pPause)
 {
     if (m_Status == 1) {
         if (m_Stretcher.Continue(pPause)) {
-            return TRUE;
+            return true;
         }
         if (m_Storer.GetBitmap()) {
             m_Storer.Replace(m_Storer.GetBitmap()->SwapXY(m_pMatrix->c > 0, m_pMatrix->b < 0));
         }
-        return FALSE;
+        return false;
     } else if (m_Status == 2) {
         return m_Stretcher.Continue(pPause);
     } else if (m_Status != 3) {
-        return FALSE;
+        return false;
     }
     if (m_Stretcher.Continue(pPause)) {
-        return TRUE;
+        return true;
     }
     int stretch_width = m_StretchClip.Width();
     int stretch_height = m_StretchClip.Height();
     if (m_Storer.GetBitmap() == NULL) {
-        return FALSE;
+        return false;
     }
     const uint8_t* stretch_buf = m_Storer.GetBitmap()->GetBuffer();
     const uint8_t* stretch_buf_mask = NULL;
     if (m_Storer.GetBitmap()->m_pAlphaMask) {
         stretch_buf_mask = m_Storer.GetBitmap()->m_pAlphaMask->GetBuffer();
     }
     int stretch_pitch = m_Storer.GetBitmap()->GetPitch();
     CFX_DIBitmap* pTransformed = new CFX_DIBitmap;
     FXDIB_Format transformF = _GetTransformedFormat(m_Stretcher.m_pSource);
     if (!pTransformed->Create(m_ResultWidth, m_ResultHeight, transformF)) {
         delete pTransformed;
-        return FALSE;
+        return false;
     }
     pTransformed->Clear(0);
     if (pTransformed->m_pAlphaMask) {
         pTransformed->m_pAlphaMask->Clear(0);
     }
     CFX_AffineMatrix result2stretch(1.0f, 0.0f, 0.0f, 1.0f, (FX_FLOAT)(m_ResultLeft), (FX_FLOAT)(m_ResultTop));
     result2stretch.Concat(m_dest2stretch);
     result2stretch.TranslateI(-m_StretchClip.left, -m_StretchClip.top);
     if (stretch_buf_mask == NULL && pTransformed->m_pAlphaMask) {
         pTransformed->m_pAlphaMask->Clear(0xff000000);
@@ skipping 250 matching lines @@
                                 dest_pos[2] = (uint8_t)(r_bgra_cmyk >> 8);
                             } else {
                                 *(FX_DWORD*)dest_pos = r_bgra_cmyk;
                             }
                         }
                         dest_pos += destBpp;
                     }
                 }
             }
         } else {
-            FX_BOOL bHasAlpha = m_Storer.GetBitmap()->HasAlpha();
+            bool bHasAlpha = m_Storer.GetBitmap()->HasAlpha();
             int destBpp = pTransformed->GetBPP() / 8;
             if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
                 for (int row = 0; row < m_ResultHeight; row ++) {
                     uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
                     for (int col = 0; col < m_ResultWidth; col ++) {
                         int src_col_l, src_row_l, res_x, res_y, r_pos_k_r = 0;
                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);
                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {
                             if (src_col_l == stretch_width) {
@@ skipping 124 matching lines @@
                                 }
                             }
                         }
                         dest_pos += destBpp;
                     }
                 }
             }
         }
     }
     m_Storer.Replace(pTransformed);
-    return FALSE;
+    return false;
 }