Remove FX_BOOL from core

core/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 "core/fxge/dib/dib_int.h"
 
 #include "core/fxge/fx_dib.h"
 #include "third_party/base/ptr_util.h"
@@ skipping 157 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,
+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 nullptr;
   }
   CFX_DIBitmap* pTransBitmap = new CFX_DIBitmap;
   int result_height = dest_clip.Height(), result_width = dest_clip.Width();
@@ skipping 80 matching lines @@
         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) {
+                          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) {
     rect.top = width - clip.left;
@@ skipping 46 matching lines @@
                                            int flags,
                                            const FX_RECT* pClip)
     : m_pSrc(pSrc),
       m_pMatrix(pMatrix),
       m_pClip(pClip),
       m_Flags(flags),
       m_Status(0) {}
 
 CFX_ImageTransformer::~CFX_ImageTransformer() {}
 
-FX_BOOL CFX_ImageTransformer::Start() {
+bool CFX_ImageTransformer::Start() {
   CFX_FloatRect unit_rect = m_pMatrix->GetUnitRect();
   FX_RECT result_rect = unit_rect.GetClosestRect();
   FX_RECT result_clip = result_rect;
   if (m_pClip)
     result_clip.Intersect(*m_pClip);
 
   if (result_clip.IsEmpty())
-    return FALSE;
+    return false;
 
   m_result = result_clip;
   if (FXSYS_fabs(m_pMatrix->a) < FXSYS_fabs(m_pMatrix->b) / 20 &&
       FXSYS_fabs(m_pMatrix->d) < FXSYS_fabs(m_pMatrix->c) / 20 &&
       FXSYS_fabs(m_pMatrix->a) < 0.5f && FXSYS_fabs(m_pMatrix->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,
                                     m_pMatrix->c > 0, m_pMatrix->b < 0);
     m_Stretcher = pdfium::MakeUnique<CFX_ImageStretcher>(
         &m_Storer, m_pSrc, dest_height, dest_width, result_clip, m_Flags);
     m_Stretcher->Start();
     m_Status = 1;
-    return TRUE;
+    return true;
   }
   if (FXSYS_fabs(m_pMatrix->b) < FIX16_005 &&
       FXSYS_fabs(m_pMatrix->c) < FIX16_005) {
     int dest_width = m_pMatrix->a > 0 ? (int)FXSYS_ceil(m_pMatrix->a)
                                       : (int)FXSYS_floor(m_pMatrix->a);
     int dest_height = m_pMatrix->d > 0 ? (int)-FXSYS_ceil(m_pMatrix->d)
                                        : (int)-FXSYS_floor(m_pMatrix->d);
     result_clip.Offset(-result_rect.left, -result_rect.top);
     m_Stretcher = pdfium::MakeUnique<CFX_ImageStretcher>(
         &m_Storer, m_pSrc, dest_width, dest_height, result_clip, m_Flags);
     m_Stretcher->Start();
     m_Status = 2;
-    return TRUE;
+    return true;
   }
   int stretch_width = (int)FXSYS_ceil(FXSYS_sqrt2(m_pMatrix->a, m_pMatrix->b));
   int stretch_height = (int)FXSYS_ceil(FXSYS_sqrt2(m_pMatrix->c, m_pMatrix->d));
   CFX_Matrix stretch2dest(1.0f, 0.0f, 0.0f, -1.0f, 0.0f,
                           (FX_FLOAT)(stretch_height));
   stretch2dest.Concat(
       m_pMatrix->a / stretch_width, m_pMatrix->b / stretch_width,
       m_pMatrix->c / stretch_height, m_pMatrix->d / stretch_height,
       m_pMatrix->e, m_pMatrix->f);
   m_dest2stretch.SetReverse(stretch2dest);
   CFX_FloatRect clip_rect_f(result_clip);
   clip_rect_f.Transform(&m_dest2stretch);
   m_StretchClip = clip_rect_f.GetOuterRect();
   m_StretchClip.Intersect(0, 0, stretch_width, stretch_height);
   m_Stretcher = pdfium::MakeUnique<CFX_ImageStretcher>(
       &m_Storer, m_pSrc, stretch_width, stretch_height, m_StretchClip, m_Flags);
   m_Stretcher->Start();
   m_Status = 3;
-  return TRUE;
+  return true;
 }
 
-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()) {
       std::unique_ptr<CFX_DIBitmap> swapped(
           m_Storer.GetBitmap()->SwapXY(m_pMatrix->c > 0, m_pMatrix->b < 0));
       m_Storer.Replace(std::move(swapped));
     }
-    return FALSE;
+    return false;
   }
 
   if (m_Status == 2)
     return m_Stretcher->Continue(pPause);
 
   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())
-    return FALSE;
+    return false;
 
   const uint8_t* stretch_buf = m_Storer.GetBitmap()->GetBuffer();
   const uint8_t* stretch_buf_mask = nullptr;
   if (m_Storer.GetBitmap()->m_pAlphaMask)
     stretch_buf_mask = m_Storer.GetBitmap()->m_pAlphaMask->GetBuffer();
 
   int stretch_pitch = m_Storer.GetBitmap()->GetPitch();
   std::unique_ptr<CFX_DIBitmap> pTransformed(new CFX_DIBitmap);
   FXDIB_Format transformF = GetTransformedFormat(m_Stretcher->source());
   if (!pTransformed->Create(m_result.Width(), m_result.Height(), transformF))
-    return FALSE;
+    return false;
 
   pTransformed->Clear(0);
   if (pTransformed->m_pAlphaMask)
     pTransformed->m_pAlphaMask->Clear(0);
 
   CFX_Matrix result2stretch(1.0f, 0.0f, 0.0f, 1.0f, (FX_FLOAT)(m_result.left),
                             (FX_FLOAT)(m_result.top));
   result2stretch.Concat(m_dest2stretch);
   result2stretch.TranslateI(-m_StretchClip.left, -m_StretchClip.top);
   if (!stretch_buf_mask && pTransformed->m_pAlphaMask) {
@@ skipping 289 matching lines @@
                 dest_pos[2] = (uint8_t)(r_bgra_cmyk >> 8);
               } else {
                 *(uint32_t*)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_result.Height(); row++) {
           uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
           for (int col = 0; col < m_result.Width(); 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);
@@ skipping 177 matching lines @@
                 }
               }
             }
             dest_pos += destBpp;
           }
         }
       }
     }
   }
   m_Storer.Replace(std::move(pTransformed));
-  return FALSE;
+  return false;
 }
 
 std::unique_ptr<CFX_DIBitmap> CFX_ImageTransformer::DetachBitmap() {
   return m_Storer.Detach();
 }