Remove FX_BOOL from core

core/fxcrt/fx_basic_coords.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 "core/fxcrt/fx_coordinates.h"
 #include "core/fxcrt/fx_ext.h"
@@ skipping 24 matching lines @@
 }
 void FX_RECT::Union(const FX_RECT& other_rect) {
   Normalize();
   FX_RECT other = other_rect;
   other.Normalize();
   left = left < other.left ? left : other.left;
   right = right > other.right ? right : other.right;
   bottom = bottom > other.bottom ? bottom : other.bottom;
   top = top < other.top ? top : other.top;
 }
-FX_BOOL GetIntersection(FX_FLOAT low1,
-                        FX_FLOAT high1,
-                        FX_FLOAT low2,
-                        FX_FLOAT high2,
-                        FX_FLOAT& interlow,
-                        FX_FLOAT& interhigh) {
+bool GetIntersection(FX_FLOAT low1,
+                     FX_FLOAT high1,
+                     FX_FLOAT low2,
+                     FX_FLOAT high2,
+                     FX_FLOAT& interlow,
+                     FX_FLOAT& interhigh) {
   if (low1 >= high2 || low2 >= high1) {
-    return FALSE;
+    return false;
   }
   interlow = low1 > low2 ? low1 : low2;
   interhigh = high1 > high2 ? high2 : high1;
-  return TRUE;
+  return true;
 }
 extern "C" int FXSYS_round(FX_FLOAT d) {
   if (d < (FX_FLOAT)INT_MIN) {
     return INT_MIN;
   }
   if (d > (FX_FLOAT)INT_MAX) {
     return INT_MAX;
   }
 
   return (int)round(d);
@@ skipping 216 matching lines @@
   FX_FLOAT ee = m1.e * m2.a + m1.f * m2.c + m2.e;
   FX_FLOAT ff = m1.e * m2.b + m1.f * m2.d + m2.f;
   m.a = aa, m.b = bb, m.c = cc, m.d = dd, m.e = ee, m.f = ff;
 }
 void CFX_Matrix::Concat(FX_FLOAT a_in,
                         FX_FLOAT b_in,
                         FX_FLOAT c_in,
                         FX_FLOAT d_in,
                         FX_FLOAT e_in,
                         FX_FLOAT f_in,
-                        FX_BOOL bPrepended) {
+                        bool bPrepended) {
   CFX_Matrix m;
   m.Set(a_in, b_in, c_in, d_in, e_in, f_in);
   Concat(m, bPrepended);
 }
-void CFX_Matrix::Concat(const CFX_Matrix& m, FX_BOOL bPrepended) {
+void CFX_Matrix::Concat(const CFX_Matrix& m, bool bPrepended) {
   if (bPrepended) {
     FXCRT_Matrix_Concat(*this, m, *this);
   } else {
     FXCRT_Matrix_Concat(*this, *this, m);
   }
 }
-void CFX_Matrix::ConcatInverse(const CFX_Matrix& src, FX_BOOL bPrepended) {
+void CFX_Matrix::ConcatInverse(const CFX_Matrix& src, bool bPrepended) {
   CFX_Matrix m;
   m.SetReverse(src);
   Concat(m, bPrepended);
 }
-FX_BOOL CFX_Matrix::IsInvertible() const {
+bool CFX_Matrix::IsInvertible() const {
   return FXSYS_fabs(a * d - b * c) >= 0.0001f;
 }
-FX_BOOL CFX_Matrix::Is90Rotated() const {
+bool CFX_Matrix::Is90Rotated() const {
   return FXSYS_fabs(a * 1000) < FXSYS_fabs(b) &&
          FXSYS_fabs(d * 1000) < FXSYS_fabs(c);
 }
-FX_BOOL CFX_Matrix::IsScaled() const {
+bool CFX_Matrix::IsScaled() const {
   return FXSYS_fabs(b * 1000) < FXSYS_fabs(a) &&
          FXSYS_fabs(c * 1000) < FXSYS_fabs(d);
 }
-void CFX_Matrix::Translate(FX_FLOAT x, FX_FLOAT y, FX_BOOL bPrepended) {
+void CFX_Matrix::Translate(FX_FLOAT x, FX_FLOAT y, bool bPrepended) {
   if (bPrepended) {
     e += x * a + y * c;
     f += y * d + x * b;
   } else {
     e += x, f += y;
   }
 }
-void CFX_Matrix::Scale(FX_FLOAT sx, FX_FLOAT sy, FX_BOOL bPrepended) {
+void CFX_Matrix::Scale(FX_FLOAT sx, FX_FLOAT sy, bool bPrepended) {
   a *= sx, d *= sy;
   if (bPrepended) {
     b *= sx;
     c *= sy;
   } else {
     b *= sy;
     c *= sx;
     e *= sx;
     f *= sy;
   }
 }
-void CFX_Matrix::Rotate(FX_FLOAT fRadian, FX_BOOL bPrepended) {
+void CFX_Matrix::Rotate(FX_FLOAT fRadian, bool bPrepended) {
   FX_FLOAT cosValue = FXSYS_cos(fRadian);
   FX_FLOAT sinValue = FXSYS_sin(fRadian);
   CFX_Matrix m;
   m.Set(cosValue, sinValue, -sinValue, cosValue, 0, 0);
   if (bPrepended) {
     FXCRT_Matrix_Concat(*this, m, *this);
   } else {
     FXCRT_Matrix_Concat(*this, *this, m);
   }
 }
 void CFX_Matrix::RotateAt(FX_FLOAT fRadian,
                           FX_FLOAT dx,
                           FX_FLOAT dy,
-                          FX_BOOL bPrepended) {
+                          bool bPrepended) {
   Translate(dx, dy, bPrepended);
   Rotate(fRadian, bPrepended);
   Translate(-dx, -dy, bPrepended);
 }
 void CFX_Matrix::Shear(FX_FLOAT fAlphaRadian,
                        FX_FLOAT fBetaRadian,
-                       FX_BOOL bPrepended) {
+                       bool bPrepended) {
   CFX_Matrix m;
   m.Set(1, FXSYS_tan(fAlphaRadian), FXSYS_tan(fBetaRadian), 1, 0, 0);
   if (bPrepended) {
     FXCRT_Matrix_Concat(*this, m, *this);
   } else {
     FXCRT_Matrix_Concat(*this, *this, m);
   }
 }
 void CFX_Matrix::MatchRect(const CFX_FloatRect& dest,
                            const CFX_FloatRect& src) {
@@ skipping 135 matching lines @@
       left = x[i];
     }
     if (top < y[i]) {
       top = y[i];
     }
     if (bottom > y[i]) {
       bottom = y[i];
     }
   }
 }