Revert "FX_BOOL considered harmful, part 2."

core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.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 "../../../include/fpdfapi/fpdf_page.h"
 #include "../../../include/fpdfapi/fpdf_pageobj.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_render.h"
@@ skipping 79 matching lines @@
         m_pTypeList = FX_Alloc(uint8_t, alloc_size);
     }
     if (text_count) {
         m_TextCount = text_count;
         m_pTextList = FX_Alloc(CPDF_TextObject*, text_count);
     }
 }
 CPDF_Rect CPDF_ClipPath::GetClipBox() const
 {
     CPDF_Rect rect;
-    bool bStarted = false;
+    FX_BOOL bStarted = FALSE;
     int count = GetPathCount();
     if (count) {
         rect = GetPath(0).GetBoundingBox();
         for (int i = 1; i < count; i ++) {
             CPDF_Rect path_rect = GetPath(i).GetBoundingBox();
             rect.Intersect(path_rect);
         }
-        bStarted = true;
+        bStarted = TRUE;
     }
     count = GetTextCount();
     if (count) {
         CPDF_Rect layer_rect;
-        bool bLayerStarted = false;
+        FX_BOOL bLayerStarted = FALSE;
         for (int i = 0; i < count; i ++) {
             CPDF_TextObject* pTextObj = GetText(i);
             if (pTextObj == NULL) {
                 if (!bStarted) {
                     rect = layer_rect;
-                    bStarted = true;
+                    bStarted = TRUE;
                 } else {
                     rect.Intersect(layer_rect);
                 }
-                bLayerStarted = false;
+                bLayerStarted = FALSE;
             } else {
                 if (!bLayerStarted) {
                     layer_rect = pTextObj->GetBBox(NULL);
-                    bLayerStarted = true;
+                    bLayerStarted = TRUE;
                 } else {
                     layer_rect.Union(pTextObj->GetBBox(NULL));
                 }
             }
         }
     }
     return rect;
 }
-void CPDF_ClipPath::AppendPath(CPDF_Path path, int type, bool bAutoMerge)
+void CPDF_ClipPath::AppendPath(CPDF_Path path, int type, FX_BOOL bAutoMerge)
 {
     CPDF_ClipPathData* pData = GetModify();
     if (pData->m_PathCount && bAutoMerge) {
         CPDF_Path old_path = pData->m_pPathList[pData->m_PathCount - 1];
         if (old_path.IsRect()) {
             CPDF_Rect old_rect(old_path.GetPointX(0), old_path.GetPointY(0),
                                old_path.GetPointX(2), old_path.GetPointY(2));
             CPDF_Rect new_rect = path.GetBoundingBox();
             if (old_rect.Contains(new_rect)) {
                 pData->m_PathCount --;
@@ skipping 102 matching lines @@
     }
     color.SetValue(pValue);
     int R, G, B;
     rgb = color.GetRGB(R, G, B) ? FXSYS_RGB(R, G, B) : (FX_DWORD) - 1;
 }
 void CPDF_ColorState::SetFillPattern(CPDF_Pattern* pPattern, FX_FLOAT* pValue, int nValues)
 {
     CPDF_ColorStateData* pData = GetModify();
     pData->m_FillColor.SetValue(pPattern, pValue, nValues);
     int R, G, B;
-    bool ret = pData->m_FillColor.GetRGB(R, G, B);
+    FX_BOOL ret = pData->m_FillColor.GetRGB(R, G, B);
     if (pPattern->m_PatternType == 1 && ((CPDF_TilingPattern*)pPattern)->m_bColored && !ret) {
         pData->m_FillRGB = 0x00BFBFBF;
         return;
     }
     pData->m_FillRGB = ret ? FXSYS_RGB(R, G, B) : (FX_DWORD) - 1;
 }
 void CPDF_ColorState::SetStrokePattern(CPDF_Pattern* pPattern, FX_FLOAT* pValue, int nValues)
 {
     CPDF_ColorStateData* pData = GetModify();
     pData->m_StrokeColor.SetValue(pPattern, pValue, nValues);
     int R, G, B;
-    bool ret = pData->m_StrokeColor.GetRGB(R, G, B);
+    FX_BOOL ret = pData->m_StrokeColor.GetRGB(R, G, B);
     if (pPattern->m_PatternType == 1 && ((CPDF_TilingPattern*)pPattern)->m_bColored && !ret) {
         pData->m_StrokeRGB = 0x00BFBFBF;
         return;
     }
     pData->m_StrokeRGB = pData->m_StrokeColor.GetRGB(R, G, B) ? FXSYS_RGB(R, G, B) : (FX_DWORD) - 1;
 }
 CPDF_TextStateData::CPDF_TextStateData()
 {
     m_pFont = NULL;
     m_pDocument = NULL;
     m_FontSize = 1.0f;
     m_WordSpace = 0;
     m_CharSpace = 0;
     m_TextMode = 0;
     m_Matrix[0] = m_Matrix[3] = 1.0f;
     m_Matrix[1] = m_Matrix[2] = 0;
     m_CTM[0] = m_CTM[3] = 1.0f;
     m_CTM[1] = m_CTM[2] = 0;
 }
 CPDF_TextStateData::CPDF_TextStateData(const CPDF_TextStateData& src)
 {
     if (this == &src) {
         return;
     }
     FXSYS_memcpy(this, &src, sizeof(CPDF_TextStateData));
     if (m_pDocument && m_pFont) {
-        m_pFont = m_pDocument->GetPageData()->GetFont(m_pFont->GetFontDict(), false);
+        m_pFont = m_pDocument->GetPageData()->GetFont(m_pFont->GetFontDict(), FALSE);
     }
 }
 CPDF_TextStateData::~CPDF_TextStateData()
 {
     if (m_pDocument && m_pFont) {
         CPDF_DocPageData *pPageData = m_pDocument->GetPageData();
         if (pPageData && !pPageData->IsForceClear()) {
             pPageData->ReleaseFont(m_pFont->GetFontDict());
         }
     }
@@ skipping 229 matching lines @@
                 break;
             case FXBSTR_ID('B', 'M', 0, 0):     {
                     CFX_ByteString mode;
                     if (pObject->GetType() == PDFOBJ_ARRAY) {
                         mode = ((CPDF_Array*)pObject)->GetString(0);
                     } else {
                         mode = pObject->GetString();
                     }
                     pGeneralState->SetBlendMode(mode);
                     if (pGeneralState->m_BlendType > FXDIB_BLEND_MULTIPLY) {
-                        pParser->GetObjectList()->m_bBackgroundAlphaNeeded = true;
+                        pParser->GetObjectList()->m_bBackgroundAlphaNeeded = TRUE;
                     }
                     break;
                 }
             case FXBSTR_ID('S', 'M', 'a', 's'):
                 if (pObject && pObject->GetType() == PDFOBJ_DICTIONARY) {
                     pGeneralState->m_pSoftMask = pObject;
                     FXSYS_memcpy(pGeneralState->m_SMaskMatrix, &pParser->GetCurStates()->m_CTM, sizeof(CPDF_Matrix));
                 } else {
                     pGeneralState->m_pSoftMask = NULL;
                 }
@@ skipping 65 matching lines @@
     } else {
         m_pParam = src.m_pParam;
     }
 }
 CPDF_ContentMarkItem::~CPDF_ContentMarkItem()
 {
     if (m_ParamType == DirectDict && m_pParam) {
         ((CPDF_Dictionary*)m_pParam)->Release();
     }
 }
-bool    CPDF_ContentMarkItem::HasMCID() const
+FX_BOOL CPDF_ContentMarkItem::HasMCID() const
 {
     if (m_pParam && (m_ParamType == DirectDict || m_ParamType == PropertiesDict)) {
         return ((CPDF_Dictionary *)m_pParam)->KeyExist(FX_BSTRC("MCID"));
     }
-    return false;
+    return FALSE;
 }
 CPDF_ContentMarkData::CPDF_ContentMarkData(const CPDF_ContentMarkData& src)
 {
     for (int i = 0; i < src.m_Marks.GetSize(); i ++) {
         m_Marks.Add(src.m_Marks[i]);
     }
 }
 int CPDF_ContentMarkData::GetMCID() const
 {
     CPDF_ContentMarkItem::ParamType type = CPDF_ContentMarkItem::None;
     for (int i = 0; i < m_Marks.GetSize(); i ++) {
         type = m_Marks[i].GetParamType();
         if (type == CPDF_ContentMarkItem::PropertiesDict || type == CPDF_ContentMarkItem::DirectDict) {
             CPDF_Dictionary *pDict = (CPDF_Dictionary *)m_Marks[i].GetParam();
             if (pDict->KeyExist(FX_BSTRC("MCID"))) {
                 return pDict->GetInteger(FX_BSTRC("MCID"));
             }
         }
     }
     return -1;
 }
-void CPDF_ContentMarkData::AddMark(const CFX_ByteString& name, CPDF_Dictionary* pDict, bool bDirect)
+void CPDF_ContentMarkData::AddMark(const CFX_ByteString& name, CPDF_Dictionary* pDict, FX_BOOL bDirect)
 {
     CPDF_ContentMarkItem& item = m_Marks.Add();
     item.SetName(name);
     if (pDict == NULL) {
         return;
     }
     item.SetParam(bDirect ? CPDF_ContentMarkItem::DirectDict : CPDF_ContentMarkItem::PropertiesDict,
                   bDirect ? pDict->Clone() : pDict);
 }
 void CPDF_ContentMarkData::DeleteLastMark()
 {
     int size = m_Marks.GetSize();
     if (size == 0) {
         return;
     }
     m_Marks.RemoveAt(size - 1);
 }
-bool CPDF_ContentMark::HasMark(const CFX_ByteStringC& mark) const
+FX_BOOL CPDF_ContentMark::HasMark(const CFX_ByteStringC& mark) const
 {
     if (m_pObject == NULL) {
-        return false;
+        return FALSE;
     }
     for (int i = 0; i < m_pObject->CountItems(); i ++) {
         CPDF_ContentMarkItem& item = m_pObject->GetItem(i);
         if (item.GetName() == mark) {
-            return true;
+            return TRUE;
         }
     }
-    return false;
+    return FALSE;
 }
-bool CPDF_ContentMark::LookupMark(const CFX_ByteStringC& mark, CPDF_Dictionary*& pDict) const
+FX_BOOL CPDF_ContentMark::LookupMark(const CFX_ByteStringC& mark, CPDF_Dictionary*& pDict) const
 {
     if (m_pObject == NULL) {
-        return false;
+        return FALSE;
     }
     for (int i = 0; i < m_pObject->CountItems(); i ++) {
         CPDF_ContentMarkItem& item = m_pObject->GetItem(i);
         if (item.GetName() == mark) {
             pDict = NULL;
             if (item.GetParamType() == CPDF_ContentMarkItem::PropertiesDict ||
                     item.GetParamType() == CPDF_ContentMarkItem::DirectDict) {
                 pDict = (CPDF_Dictionary*)item.GetParam();
             }
-            return true;
+            return TRUE;
         }
     }
-    return false;
+    return FALSE;
 }