Remove FX_BOOL from core

core/fpdfapi/render/fpdf_render_pattern.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/fpdfapi/render/render_int.h"
 
 #include <algorithm>
 
@@ skipping 43 matching lines @@
   FX_FLOAT start_y = pCoords->GetNumberAt(1);
   FX_FLOAT end_x = pCoords->GetNumberAt(2);
   FX_FLOAT end_y = pCoords->GetNumberAt(3);
   FX_FLOAT t_min = 0;
   FX_FLOAT t_max = 1.0f;
   CPDF_Array* pArray = pDict->GetArrayFor("Domain");
   if (pArray) {
     t_min = pArray->GetNumberAt(0);
     t_max = pArray->GetNumberAt(1);
   }
-  FX_BOOL bStartExtend = FALSE;
-  FX_BOOL bEndExtend = FALSE;
+  bool bStartExtend = false;
+  bool bEndExtend = false;
   pArray = pDict->GetArrayFor("Extend");
   if (pArray) {
     bStartExtend = !!pArray->GetIntegerAt(0);
     bEndExtend = !!pArray->GetIntegerAt(1);
   }
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   FX_FLOAT x_span = end_x - start_x;
   FX_FLOAT y_span = end_y - start_y;
   FX_FLOAT axis_len_square = (x_span * x_span) + (y_span * y_span);
@@ skipping 65 matching lines @@
   FX_FLOAT end_r = pCoords->GetNumberAt(5);
   CFX_Matrix matrix;
   matrix.SetReverse(*pObject2Bitmap);
   FX_FLOAT t_min = 0;
   FX_FLOAT t_max = 1.0f;
   CPDF_Array* pArray = pDict->GetArrayFor("Domain");
   if (pArray) {
     t_min = pArray->GetNumberAt(0);
     t_max = pArray->GetNumberAt(1);
   }
-  FX_BOOL bStartExtend = FALSE;
-  FX_BOOL bEndExtend = FALSE;
+  bool bStartExtend = false;
+  bool bEndExtend = false;
   pArray = pDict->GetArrayFor("Extend");
   if (pArray) {
     bStartExtend = !!pArray->GetIntegerAt(0);
     bEndExtend = !!pArray->GetIntegerAt(1);
   }
   uint32_t total_results =
       std::max(CountOutputs(funcs), pCS->CountComponents());
   CFX_FixedBufGrow<FX_FLOAT, 16> result_array(total_results);
   FX_FLOAT* pResults = result_array;
   FXSYS_memset(pResults, 0, total_results * sizeof(FX_FLOAT));
@@ skipping 13 matching lines @@
     rgb_array[i] =
         FXARGB_TODIB(FXARGB_MAKE(alpha, FXSYS_round(R * 255),
                                  FXSYS_round(G * 255), FXSYS_round(B * 255)));
   }
   FX_FLOAT a = ((start_x - end_x) * (start_x - end_x)) +
                ((start_y - end_y) * (start_y - end_y)) -
                ((start_r - end_r) * (start_r - end_r));
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   int pitch = pBitmap->GetPitch();
-  FX_BOOL bDecreasing = FALSE;
+  bool bDecreasing = false;
   if (start_r > end_r) {
     int length = (int)FXSYS_sqrt((((start_x - end_x) * (start_x - end_x)) +
                                   ((start_y - end_y) * (start_y - end_y))));
     if (length < start_r - end_r) {
-      bDecreasing = TRUE;
+      bDecreasing = true;
     }
   }
   for (int row = 0; row < height; row++) {
     uint32_t* dib_buf = (uint32_t*)(pBitmap->GetBuffer() + row * pitch);
     for (int column = 0; column < width; column++) {
       FX_FLOAT x = (FX_FLOAT)column, y = (FX_FLOAT)row;
       matrix.Transform(x, y);
       FX_FLOAT b = -2 * (((x - start_x) * (end_x - start_x)) +
                          ((y - start_y) * (end_y - start_y)) +
                          (start_r * (end_r - start_r)));
@@ skipping 106 matching lines @@
   }
 }
 
 bool GetScanlineIntersect(int y,
                           FX_FLOAT x1,
                           FX_FLOAT y1,
                           FX_FLOAT x2,
                           FX_FLOAT y2,
                           FX_FLOAT* x) {
   if (y1 == y2)
-    return FALSE;
+    return false;
 
   if (y1 < y2) {
     if (y < y1 || y > y2)
-      return FALSE;
+      return false;
   } else {
     if (y < y2 || y > y1)
-      return FALSE;
+      return false;
   }
   *x = x1 + ((x2 - x1) * (y - y1) / (y2 - y1));
-  return TRUE;
+  return true;
 }
 
 void DrawGouraud(CFX_DIBitmap* pBitmap,
                  int alpha,
                  CPDF_MeshVertex triangle[3]) {
   FX_FLOAT min_y = triangle[0].y, max_y = triangle[0].y;
   for (int i = 1; i < 3; i++) {
     if (min_y > triangle[i].y) {
       min_y = triangle[i].y;
     }
@@ skipping 304 matching lines @@
   int fill_mode;
   int alpha;
   void Draw(int x_scale,
             int y_scale,
             int left,
             int bottom,
             Coon_Bezier C1,
             Coon_Bezier C2,
             Coon_Bezier D1,
             Coon_Bezier D2) {
-    FX_BOOL bSmall = C1.Distance() < 2 && C2.Distance() < 2 &&
-                     D1.Distance() < 2 && D2.Distance() < 2;
+    bool bSmall = C1.Distance() < 2 && C2.Distance() < 2 && D1.Distance() < 2 &&
+                  D2.Distance() < 2;
     Coon_Color div_colors[4];
     int d_bottom = 0;
     int d_left = 0;
     int d_top = 0;
     int d_right = 0;
     div_colors[0].BiInterpol(patch_colors, left, bottom, x_scale, y_scale);
     if (!bSmall) {
       div_colors[1].BiInterpol(patch_colors, left, bottom + 1, x_scale,
                                y_scale);
       div_colors[2].BiInterpol(patch_colors, left + 1, bottom + 1, x_scale,
@@ skipping 178 matching lines @@
   context.Render(&bitmap_device, &options, nullptr);
   return pBitmap;
 }
 
 }  // namespace
 
 void CPDF_RenderStatus::DrawShading(CPDF_ShadingPattern* pPattern,
                                     CFX_Matrix* pMatrix,
                                     FX_RECT& clip_rect,
                                     int alpha,
-                                    FX_BOOL bAlphaMode) {
+                                    bool bAlphaMode) {
   const auto& funcs = pPattern->GetFuncs();
   CPDF_Dictionary* pDict = pPattern->GetShadingObject()->GetDict();
   CPDF_ColorSpace* pColorSpace = pPattern->GetCS();
   if (!pColorSpace)
     return;
 
   FX_ARGB background = 0;
   if (!pPattern->IsShadingObject() && pDict->KeyExist("Background")) {
     CPDF_Array* pBackColor = pDict->GetArrayFor("Background");
     if (pBackColor &&
@@ skipping 71 matching lines @@
     pBitmap->LoadChannel(FXDIB_Red, pBitmap, FXDIB_Alpha);
 
   if (m_Options.m_ColorMode == RENDER_COLOR_GRAY)
     pBitmap->ConvertColorScale(m_Options.m_ForeColor, m_Options.m_BackColor);
   buffer.OutputToDevice();
 }
 
 void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern,
                                            const CPDF_PageObject* pPageObj,
                                            const CFX_Matrix* pObj2Device,
-                                           FX_BOOL bStroke) {
+                                           bool bStroke) {
   if (!pattern->Load())
     return;
 
   m_pDevice->SaveState();
   if (pPageObj->IsPath()) {
     if (!SelectClipPath(pPageObj->AsPath(), pObj2Device, bStroke)) {
       m_pDevice->RestoreState(false);
       return;
     }
   } else if (pPageObj->IsImage()) {
     m_pDevice->SetClip_Rect(pPageObj->GetBBox(pObj2Device));
   } else {
     return;
   }
   FX_RECT rect;
-  if (GetObjectClippedRect(pPageObj, pObj2Device, FALSE, rect)) {
+  if (GetObjectClippedRect(pPageObj, pObj2Device, false, rect)) {
     m_pDevice->RestoreState(false);
     return;
   }
   CFX_Matrix matrix = *pattern->pattern_to_form();
   matrix.Concat(*pObj2Device);
   GetScaledMatrix(matrix);
   int alpha =
       FXSYS_round(255 * (bStroke ? pPageObj->m_GeneralState.GetStrokeAlpha()
                                  : pPageObj->m_GeneralState.GetFillAlpha()));
   DrawShading(pattern, &matrix, rect, alpha,
@@ skipping 12 matching lines @@
   CFX_Matrix matrix = pShadingObj->m_Matrix;
   matrix.Concat(*pObj2Device);
   DrawShading(pShadingObj->m_pShading, &matrix, rect,
               FXSYS_round(255 * pShadingObj->m_GeneralState.GetFillAlpha()),
               m_Options.m_ColorMode == RENDER_COLOR_ALPHA);
 }
 
 void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern,
                                           CPDF_PageObject* pPageObj,
                                           const CFX_Matrix* pObj2Device,
-                                          FX_BOOL bStroke) {
+                                          bool bStroke) {
   if (!pPattern->Load()) {
     return;
   }
   m_pDevice->SaveState();
   if (pPageObj->IsPath()) {
     if (!SelectClipPath(pPageObj->AsPath(), pObj2Device, bStroke)) {
       m_pDevice->RestoreState(false);
       return;
     }
   } else if (pPageObj->IsImage()) {
     m_pDevice->SetClip_Rect(pPageObj->GetBBox(pObj2Device));
   } else {
     return;
   }
   FX_RECT clip_box = m_pDevice->GetClipBox();
   if (clip_box.IsEmpty()) {
     m_pDevice->RestoreState(false);
     return;
   }
   CFX_Matrix dCTM = m_pDevice->GetCTM();
   FX_FLOAT sa = FXSYS_fabs(dCTM.a);
   FX_FLOAT sd = FXSYS_fabs(dCTM.d);
   clip_box.right = clip_box.left + (int32_t)FXSYS_ceil(clip_box.Width() * sa);
   clip_box.bottom = clip_box.top + (int32_t)FXSYS_ceil(clip_box.Height() * sd);
   CFX_Matrix mtPattern2Device = *pPattern->pattern_to_form();
   mtPattern2Device.Concat(*pObj2Device);
   GetScaledMatrix(mtPattern2Device);
-  FX_BOOL bAligned = FALSE;
+  bool bAligned = false;
   if (pPattern->bbox().left == 0 && pPattern->bbox().bottom == 0 &&
       pPattern->bbox().right == pPattern->x_step() &&
       pPattern->bbox().top == pPattern->y_step() &&
       (mtPattern2Device.IsScaled() || mtPattern2Device.Is90Rotated())) {
-    bAligned = TRUE;
+    bAligned = true;
   }
   CFX_FloatRect cell_bbox = pPattern->bbox();
   mtPattern2Device.TransformRect(cell_bbox);
   int width = (int)FXSYS_ceil(cell_bbox.Width());
   int height = (int)FXSYS_ceil(cell_bbox.Height());
   if (width == 0) {
     width = 1;
   }
   if (height == 0) {
     height = 1;
@@ skipping 135 matching lines @@
           screen.CompositeBitmap(start_x, start_y, width, height,
                                  pPatternBitmap.get(), 0, 0);
         } else {
           screen.CompositeMask(start_x, start_y, width, height,
                                pPatternBitmap.get(), fill_argb, 0, 0);
         }
       }
     }
   }
   CompositeDIBitmap(&screen, clip_box.left, clip_box.top, 0, 255,
-                    FXDIB_BLEND_NORMAL, FALSE);
+                    FXDIB_BLEND_NORMAL, false);
   m_pDevice->RestoreState(false);
 }
 
 void CPDF_RenderStatus::DrawPathWithPattern(CPDF_PathObject* pPathObj,
                                             const CFX_Matrix* pObj2Device,
                                             const CPDF_Color* pColor,
-                                            FX_BOOL bStroke) {
+                                            bool bStroke) {
   CPDF_Pattern* pattern = pColor->GetPattern();
   if (!pattern)
     return;
 
   if (CPDF_TilingPattern* pTilingPattern = pattern->AsTilingPattern())
     DrawTilingPattern(pTilingPattern, pPathObj, pObj2Device, bStroke);
   else if (CPDF_ShadingPattern* pShadingPattern = pattern->AsShadingPattern())
     DrawShadingPattern(pShadingPattern, pPathObj, pObj2Device, bStroke);
 }
 
 void CPDF_RenderStatus::ProcessPathPattern(CPDF_PathObject* pPathObj,
                                            const CFX_Matrix* pObj2Device,
                                            int& filltype,
-                                           FX_BOOL& bStroke) {
+                                           bool& bStroke) {
   if (filltype) {
     const CPDF_Color& FillColor = *pPathObj->m_ColorState.GetFillColor();
     if (FillColor.IsPattern()) {
-      DrawPathWithPattern(pPathObj, pObj2Device, &FillColor, FALSE);
+      DrawPathWithPattern(pPathObj, pObj2Device, &FillColor, false);
       filltype = 0;
     }
   }
   if (bStroke) {
     const CPDF_Color& StrokeColor = *pPathObj->m_ColorState.GetStrokeColor();
     if (StrokeColor.IsPattern()) {
-      DrawPathWithPattern(pPathObj, pObj2Device, &StrokeColor, TRUE);
-      bStroke = FALSE;
+      DrawPathWithPattern(pPathObj, pObj2Device, &StrokeColor, true);
+      bStroke = false;
     }
   }
 }