Remove FX_BOOL from core

core/fxge/ge/cfx_pathdata.cpp

 // Copyright 2016 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/cfx_pathdata.h"
 
 #include "core/fxcrt/fx_system.h"
 #include "third_party/base/numerics/safe_math.h"
@@ skipping 142 matching lines @@
                                   FX_FLOAT start_x,
                                   FX_FLOAT start_y,
                                   FX_FLOAT middle_x,
                                   FX_FLOAT middle_y,
                                   FX_FLOAT end_x,
                                   FX_FLOAT end_y,
                                   FX_FLOAT half_width,
                                   FX_FLOAT miter_limit) {
   FX_FLOAT start_k = 0, start_c = 0, end_k = 0, end_c = 0, start_len = 0,
            start_dc = 0, end_len = 0, end_dc = 0;
-  FX_BOOL bStartVert = FXSYS_fabs(start_x - middle_x) < 1.0f / 20;
-  FX_BOOL bEndVert = FXSYS_fabs(middle_x - end_x) < 1.0f / 20;
+  bool bStartVert = FXSYS_fabs(start_x - middle_x) < 1.0f / 20;
+  bool bEndVert = FXSYS_fabs(middle_x - end_x) < 1.0f / 20;
   if (bStartVert && bEndVert) {
     int start_dir = middle_y > start_y ? 1 : -1;
     FX_FLOAT point_y = middle_y + half_width * start_dir;
     rect.UpdateRect(middle_x + half_width, point_y);
     rect.UpdateRect(middle_x - half_width, point_y);
     return;
   }
   if (!bStartVert) {
     start_k = (middle_y - start_y) / (middle_x - start_x);
     start_c = middle_y - (start_k * middle_x);
@@ skipping 69 matching lines @@
 
 CFX_FloatRect CFX_PathData::GetBoundingBox(FX_FLOAT line_width,
                                            FX_FLOAT miter_limit) const {
   CFX_FloatRect rect(100000 * 1.0f, 100000 * 1.0f, -100000 * 1.0f,
                      -100000 * 1.0f);
   int iPoint = 0;
   FX_FLOAT half_width = line_width;
   int iStartPoint = 0;
   int iEndPoint = 0;
   int iMiddlePoint = 0;
-  FX_BOOL bJoin;
+  bool bJoin;
   while (iPoint < m_PointCount) {
     if (m_pPoints[iPoint].m_Flag == FXPT_MOVETO) {
       iStartPoint = iPoint + 1;
       iEndPoint = iPoint;
-      bJoin = FALSE;
+      bJoin = false;
     } else {
       if (m_pPoints[iPoint].m_Flag == FXPT_BEZIERTO) {
         rect.UpdateRect(m_pPoints[iPoint].m_PointX, m_pPoints[iPoint].m_PointY);
         rect.UpdateRect(m_pPoints[iPoint + 1].m_PointX,
                         m_pPoints[iPoint + 1].m_PointY);
         iPoint += 2;
       }
       if (iPoint == m_PointCount - 1 ||
           m_pPoints[iPoint + 1].m_Flag == FXPT_MOVETO) {
         iStartPoint = iPoint - 1;
         iEndPoint = iPoint;
-        bJoin = FALSE;
+        bJoin = false;
       } else {
         iStartPoint = iPoint - 1;
         iMiddlePoint = iPoint;
         iEndPoint = iPoint + 1;
-        bJoin = TRUE;
+        bJoin = true;
       }
     }
     FX_FLOAT start_x = m_pPoints[iStartPoint].m_PointX;
     FX_FLOAT start_y = m_pPoints[iStartPoint].m_PointY;
     FX_FLOAT end_x = m_pPoints[iEndPoint].m_PointX;
     FX_FLOAT end_y = m_pPoints[iEndPoint].m_PointY;
     if (bJoin) {
       FX_FLOAT middle_x = m_pPoints[iMiddlePoint].m_PointX;
       FX_FLOAT middle_y = m_pPoints[iMiddlePoint].m_PointY;
       _UpdateLineJoinPoints(rect, start_x, start_y, middle_x, middle_y, end_x,
                             end_y, half_width, miter_limit);
     } else {
       _UpdateLineEndPoints(rect, start_x, start_y, end_x, end_y, half_width);
     }
     iPoint++;
   }
   return rect;
 }
 
 void CFX_PathData::Transform(const CFX_Matrix* pMatrix) {
   if (!pMatrix) {
     return;
   }
   for (int i = 0; i < m_PointCount; i++) {
     pMatrix->Transform(m_pPoints[i].m_PointX, m_pPoints[i].m_PointY);
   }
 }
 
-FX_BOOL CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath,
-                                      CFX_Matrix* pMatrix,
-                                      FX_BOOL& bThin,
-                                      FX_BOOL bAdjust) const {
+bool CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath,
+                                   CFX_Matrix* pMatrix,
+                                   bool& bThin,
+                                   bool bAdjust) const {
   if (m_PointCount < 3) {
-    return FALSE;
+    return false;
   }
   if (m_PointCount == 3 && (m_pPoints[0].m_Flag & FXPT_TYPE) == FXPT_MOVETO &&
       (m_pPoints[1].m_Flag & FXPT_TYPE) == FXPT_LINETO &&
       (m_pPoints[2].m_Flag & FXPT_TYPE) == FXPT_LINETO &&
       m_pPoints[0].m_PointX == m_pPoints[2].m_PointX &&
       m_pPoints[0].m_PointY == m_pPoints[2].m_PointY) {
     NewPath.AddPointCount(2);
     if (bAdjust) {
       if (pMatrix) {
         FX_FLOAT x = m_pPoints[0].m_PointX, y = m_pPoints[0].m_PointY;
@@ skipping 16 matching lines @@
         NewPath.SetPoint(1, x, y, FXPT_LINETO);
       }
     } else {
       NewPath.SetPoint(0, m_pPoints[0].m_PointX, m_pPoints[0].m_PointY,
                        FXPT_MOVETO);
       NewPath.SetPoint(1, m_pPoints[1].m_PointX, m_pPoints[1].m_PointY,
                        FXPT_LINETO);
     }
     if (m_pPoints[0].m_PointX != m_pPoints[1].m_PointX &&
         m_pPoints[0].m_PointY != m_pPoints[1].m_PointY) {
-      bThin = TRUE;
+      bThin = true;
     }
-    return TRUE;
+    return true;
   }
   if (((m_PointCount > 3) && (m_PointCount % 2))) {
     int mid = m_PointCount / 2;
-    FX_BOOL bZeroArea = FALSE;
+    bool bZeroArea = false;
     CFX_PathData t_path;
     for (int i = 0; i < mid; i++) {
       if (!(m_pPoints[mid - i - 1].m_PointX ==
                 m_pPoints[mid + i + 1].m_PointX &&
             m_pPoints[mid - i - 1].m_PointY ==
                 m_pPoints[mid + i + 1].m_PointY &&
             ((m_pPoints[mid - i - 1].m_Flag & FXPT_TYPE) != FXPT_BEZIERTO &&
              (m_pPoints[mid + i + 1].m_Flag & FXPT_TYPE) != FXPT_BEZIERTO))) {
-        bZeroArea = TRUE;
+        bZeroArea = true;
         break;
       }
       int new_count = t_path.GetPointCount();
       t_path.AddPointCount(2);
       t_path.SetPoint(new_count, m_pPoints[mid - i].m_PointX,
                       m_pPoints[mid - i].m_PointY, FXPT_MOVETO);
       t_path.SetPoint(new_count + 1, m_pPoints[mid - i - 1].m_PointX,
                       m_pPoints[mid - i - 1].m_PointY, FXPT_LINETO);
     }
     if (!bZeroArea) {
       NewPath.Append(&t_path, nullptr);
-      bThin = TRUE;
-      return TRUE;
+      bThin = true;
+      return true;
     }
   }
   int stratPoint = 0;
   int next = 0, i;
   for (i = 0; i < m_PointCount; i++) {
     int point_type = m_pPoints[i].m_Flag & FXPT_TYPE;
     if (point_type == FXPT_MOVETO) {
       stratPoint = i;
     } else if (point_type == FXPT_LINETO) {
       next = (i + 1 - stratPoint) % (m_PointCount - stratPoint) + stratPoint;
@@ skipping 37 matching lines @@
                    (m_pPoints[next].m_Flag & FXPT_TYPE) == FXPT_LINETO &&
                    m_pPoints[i - 1].m_PointX == m_pPoints[next].m_PointX &&
                    m_pPoints[i - 1].m_PointY == m_pPoints[next].m_PointY &&
                    m_pPoints[next].m_Flag & FXPT_CLOSEFIGURE) {
           int new_count = NewPath.GetPointCount();
           NewPath.AddPointCount(2);
           NewPath.SetPoint(new_count, m_pPoints[i - 1].m_PointX,
                            m_pPoints[i - 1].m_PointY, FXPT_MOVETO);
           NewPath.SetPoint(new_count + 1, m_pPoints[i].m_PointX,
                            m_pPoints[i].m_PointY, FXPT_LINETO);
-          bThin = TRUE;
+          bThin = true;
         }
       }
     } else if (point_type == FXPT_BEZIERTO) {
       i += 2;
       continue;
     }
   }
   if (m_PointCount > 3 && NewPath.GetPointCount()) {
-    bThin = TRUE;
+    bThin = true;
   }
   if (NewPath.GetPointCount() == 0) {
-    return FALSE;
+    return false;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_PathData::IsRect() const {
+bool CFX_PathData::IsRect() const {
   if (m_PointCount != 5 && m_PointCount != 4) {
-    return FALSE;
+    return false;
   }
   if ((m_PointCount == 5 && (m_pPoints[0].m_PointX != m_pPoints[4].m_PointX ||
                              m_pPoints[0].m_PointY != m_pPoints[4].m_PointY)) ||
       (m_pPoints[0].m_PointX == m_pPoints[2].m_PointX &&
        m_pPoints[0].m_PointY == m_pPoints[2].m_PointY) ||
       (m_pPoints[1].m_PointX == m_pPoints[3].m_PointX &&
        m_pPoints[1].m_PointY == m_pPoints[3].m_PointY)) {
-    return FALSE;
+    return false;
   }
   if (m_pPoints[0].m_PointX != m_pPoints[3].m_PointX &&
       m_pPoints[0].m_PointY != m_pPoints[3].m_PointY) {
-    return FALSE;
+    return false;
   }
   for (int i = 1; i < 4; i++) {
     if ((m_pPoints[i].m_Flag & FXPT_TYPE) != FXPT_LINETO) {
-      return FALSE;
+      return false;
     }
     if (m_pPoints[i].m_PointX != m_pPoints[i - 1].m_PointX &&
         m_pPoints[i].m_PointY != m_pPoints[i - 1].m_PointY) {
-      return FALSE;
+      return false;
     }
   }
   return m_PointCount == 5 || (m_pPoints[3].m_Flag & FXPT_CLOSEFIGURE);
 }
 
-FX_BOOL CFX_PathData::IsRect(const CFX_Matrix* pMatrix,
-                             CFX_FloatRect* pRect) const {
+bool CFX_PathData::IsRect(const CFX_Matrix* pMatrix,
+                          CFX_FloatRect* pRect) const {
   if (!pMatrix) {
     if (!IsRect()) {
-      return FALSE;
+      return false;
     }
     if (pRect) {
       pRect->left = m_pPoints[0].m_PointX;
       pRect->right = m_pPoints[2].m_PointX;
       pRect->bottom = m_pPoints[0].m_PointY;
       pRect->top = m_pPoints[2].m_PointY;
       pRect->Normalize();
     }
-    return TRUE;
+    return true;
   }
   if (m_PointCount != 5 && m_PointCount != 4) {
-    return FALSE;
+    return false;
   }
   if ((m_PointCount == 5 && (m_pPoints[0].m_PointX != m_pPoints[4].m_PointX ||
                              m_pPoints[0].m_PointY != m_pPoints[4].m_PointY)) ||
       (m_pPoints[1].m_PointX == m_pPoints[3].m_PointX &&
        m_pPoints[1].m_PointY == m_pPoints[3].m_PointY)) {
-    return FALSE;
+    return false;
   }
   if (m_PointCount == 4 && m_pPoints[0].m_PointX != m_pPoints[3].m_PointX &&
       m_pPoints[0].m_PointY != m_pPoints[3].m_PointY) {
-    return FALSE;
+    return false;
   }
   FX_FLOAT x[5], y[5];
   for (int i = 0; i < m_PointCount; i++) {
     pMatrix->Transform(m_pPoints[i].m_PointX, m_pPoints[i].m_PointY, x[i],
                        y[i]);
     if (i) {
       if ((m_pPoints[i].m_Flag & FXPT_TYPE) != FXPT_LINETO) {
-        return FALSE;
+        return false;
       }
       if (x[i] != x[i - 1] && y[i] != y[i - 1]) {
-        return FALSE;
+        return false;
       }
     }
   }
   if (pRect) {
     pRect->left = x[0];
     pRect->right = x[2];
     pRect->bottom = y[0];
     pRect->top = y[2];
     pRect->Normalize();
   }
-  return TRUE;
+  return true;
 }
 
 void CFX_PathData::Copy(const CFX_PathData& src) {
   SetPointCount(src.m_PointCount);
   FXSYS_memcpy(m_pPoints, src.m_pPoints, sizeof(FX_PATHPOINT) * m_PointCount);
 }