Remove FX_BOOL from core

core/fpdfapi/page/cpdf_streamcontentparser.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/fpdfapi/page/cpdf_streamcontentparser.h"
 
 #include "core/fpdfapi/font/cpdf_font.h"
 #include "core/fpdfapi/font/cpdf_type3font.h"
@@ skipping 267 matching lines @@
   if (param.m_Type == ContentParam::NAME) {
     CPDF_Name* pName = new CPDF_Name(m_pDocument->GetByteStringPool()->Intern(
         CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len)));
     param.m_Type = ContentParam::OBJECT;
     param.m_pObject = pName;
     return pName;
   }
   if (param.m_Type == ContentParam::OBJECT) {
     return param.m_pObject;
   }
-  ASSERT(FALSE);
+  ASSERT(false);
   return nullptr;
 }
 
 CFX_ByteString CPDF_StreamContentParser::GetString(uint32_t index) {
   if (index >= m_ParamCount) {
     return CFX_ByteString();
   }
   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
   if (real_index >= kParamBufSize) {
     real_index -= kParamBufSize;
@@ skipping 281 matching lines @@
         m_pSyntax->GetWordBuf()[1] == 'I') {
       break;
     }
   }
   CPDF_ImageObject* pImgObj = AddImage(std::move(pStream));
   if (!pImgObj && !bGaveDictAway)
     pDict->Release();
 }
 
 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
-  m_CurContentMark.AddMark(GetString(0), nullptr, FALSE);
+  m_CurContentMark.AddMark(GetString(0), nullptr, false);
 }
 
 void CPDF_StreamContentParser::Handle_BeginText() {
   m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
   OnChangeTextMatrix();
   m_pCurStates->m_TextX = 0;
   m_pCurStates->m_TextY = 0;
   m_pCurStates->m_TextLineX = 0;
   m_pCurStates->m_TextLineY = 0;
 }
@@ skipping 89 matching lines @@
   pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
   pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
   CPDF_AllStates status;
   status.m_GeneralState = m_pCurStates->m_GeneralState;
   status.m_GraphState = m_pCurStates->m_GraphState;
   status.m_ColorState = m_pCurStates->m_ColorState;
   status.m_TextState = m_pCurStates->m_TextState;
   pFormObj->m_pForm->ParseContent(&status, nullptr, nullptr, m_Level + 1);
   if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
       pFormObj->m_pForm->BackgroundAlphaNeeded()) {
-    m_pObjectHolder->SetBackgroundAlphaNeeded(TRUE);
+    m_pObjectHolder->SetBackgroundAlphaNeeded(true);
   }
   pFormObj->CalcBoundingBox();
   SetGraphicStates(pFormObj.get(), true, true, true);
   m_pObjectHolder->GetPageObjectList()->push_back(std::move(pFormObj));
 }
 
 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(UniqueStream pStream) {
   if (!pStream)
     return nullptr;
 
@@ skipping 692 matching lines @@
 
 void CPDF_StreamContentParser::AddPathObject(int FillType, bool bStroke) {
   int PathPointCount = m_PathPointCount;
   uint8_t PathClipType = m_PathClipType;
   m_PathPointCount = 0;
   m_PathClipType = 0;
   if (PathPointCount <= 1) {
     if (PathPointCount && PathClipType) {
       CPDF_Path path;
       path.AppendRect(0, 0, 0, 0);
-      m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, TRUE);
+      m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, true);
     }
     return;
   }
   if (PathPointCount &&
       m_pPathPoints[PathPointCount - 1].m_Flag == FXPT_MOVETO) {
     PathPointCount--;
   }
   CPDF_Path Path;
   Path.SetPointCount(PathPointCount);
   FXSYS_memcpy(Path.GetMutablePoints(), m_pPathPoints,
                sizeof(FX_PATHPOINT) * PathPointCount);
   CFX_Matrix matrix = m_pCurStates->m_CTM;
   matrix.Concat(m_mtContentToUser);
   if (bStroke || FillType) {
     std::unique_ptr<CPDF_PathObject> pPathObj(new CPDF_PathObject);
     pPathObj->m_bStroke = bStroke;
     pPathObj->m_FillType = FillType;
     pPathObj->m_Path = Path;
     pPathObj->m_Matrix = matrix;
     SetGraphicStates(pPathObj.get(), true, false, true);
     pPathObj->CalcBoundingBox();
     m_pObjectHolder->GetPageObjectList()->push_back(std::move(pPathObj));
   }
   if (PathClipType) {
     if (!matrix.IsIdentity()) {
       Path.Transform(&matrix);
       matrix.SetIdentity();
     }
-    m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
+    m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, true);
   }
 }
 
 uint32_t CPDF_StreamContentParser::Parse(const uint8_t* pData,
                                          uint32_t dwSize,
                                          uint32_t max_cost) {
   if (m_Level > kMaxFormLevel)
     return dwSize;
 
   uint32_t InitObjCount = m_pObjectHolder->GetPageObjectList()->size();
@@ skipping 24 matching lines @@
   }
   return m_pSyntax->GetPos();
 }
 
 void CPDF_StreamContentParser::ParsePathObject() {
   FX_FLOAT params[6] = {};
   int nParams = 0;
   int last_pos = m_pSyntax->GetPos();
   while (1) {
     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
-    FX_BOOL bProcessed = TRUE;
+    bool bProcessed = true;
     switch (type) {
       case CPDF_StreamParser::EndOfData:
         return;
       case CPDF_StreamParser::Keyword: {
         int len = m_pSyntax->GetWordSize();
         if (len == 1) {
           switch (m_pSyntax->GetWordBuf()[0]) {
             case kPathOperatorSubpath:
               AddPathPoint(params[0], params[1], FXPT_MOVETO);
               nParams = 0;
@@ skipping 18 matching lines @@
               AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
               AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
               AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
               nParams = 0;
               break;
             case kPathOperatorClosePath:
               Handle_ClosePath();
               nParams = 0;
               break;
             default:
-              bProcessed = FALSE;
+              bProcessed = false;
               break;
           }
         } else if (len == 2) {
           if (m_pSyntax->GetWordBuf()[0] == kPathOperatorRectangle[0] &&
               m_pSyntax->GetWordBuf()[1] == kPathOperatorRectangle[1]) {
             AddPathRect(params[0], params[1], params[2], params[3]);
             nParams = 0;
           } else {
-            bProcessed = FALSE;
+            bProcessed = false;
           }
         } else {
-          bProcessed = FALSE;
+          bProcessed = false;
         }
         if (bProcessed) {
           last_pos = m_pSyntax->GetPos();
         }
         break;
       }
       case CPDF_StreamParser::Number: {
         if (nParams == 6)
           break;
 
         int value;
         bool bInteger = FX_atonum(
             CFX_ByteStringC(m_pSyntax->GetWordBuf(), m_pSyntax->GetWordSize()),
             &value);
         params[nParams++] = bInteger ? (FX_FLOAT)value : *(FX_FLOAT*)&value;
         break;
       }
       default:
-        bProcessed = FALSE;
+        bProcessed = false;
     }
     if (!bProcessed) {
       m_pSyntax->SetPos(last_pos);
       return;
     }
   }
 }