FX_BOOL considered harmful.

core/src/fpdfapi/fpdf_page/fpdf_page_doc.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_module.h"
 #include "../../../include/fdrm/fx_crypt.h"
 #include "../fpdf_font/font_int.h"
@@ skipping 60 matching lines @@
 {
     m_pPageModule.reset(new CPDF_PageModule);
 }
 
 void CPDF_PageModule::ReleaseDoc(CPDF_Document* pDoc)
 {
     delete pDoc->GetPageData();
 }
 void CPDF_PageModule::ClearDoc(CPDF_Document* pDoc)
 {
-    pDoc->GetPageData()->Clear(FALSE);
+    pDoc->GetPageData()->Clear(false);
 }
 void CPDF_PageModule::NotifyCJKAvailable()
 {
     m_FontGlobals.m_CMapManager.ReloadAll();
 }
 
 CPDF_Font* CPDF_Document::LoadFont(CPDF_Dictionary* pFontDict)
 {
     ASSERT(pFontDict);
-    return GetValidatePageData()->GetFont(pFontDict, FALSE);
+    return GetValidatePageData()->GetFont(pFontDict, false);
 }
 
 CPDF_StreamAcc* CPDF_Document::LoadFontFile(CPDF_Stream* pStream)
 {
     return GetValidatePageData()->GetFontFileStreamAcc(pStream);
 }
 
 CPDF_ColorSpace* _CSFromName(const CFX_ByteString& name);
 CPDF_ColorSpace* CPDF_Document::LoadColorSpace(CPDF_Object* pCSObj, CPDF_Dictionary* pResources)
 {
     return GetValidatePageData()->GetColorSpace(pCSObj, pResources);
 }
-CPDF_Pattern* CPDF_Document::LoadPattern(CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* matrix)
+CPDF_Pattern* CPDF_Document::LoadPattern(CPDF_Object* pPatternObj, bool bShading, const CFX_AffineMatrix* matrix)
 {
     return GetValidatePageData()->GetPattern(pPatternObj, bShading, matrix);
 }
 CPDF_IccProfile* CPDF_Document::LoadIccProfile(CPDF_Stream* pStream)
 {
     return GetValidatePageData()->GetIccProfile(pStream);
 }
 CPDF_Image* CPDF_Document::LoadImageF(CPDF_Object* pObj)
 {
     if (!pObj) {
         return NULL;
     }
     FXSYS_assert(pObj->GetObjNum());
     return GetValidatePageData()->GetImage(pObj);
 }
 void CPDF_Document::RemoveColorSpaceFromPageData(CPDF_Object* pCSObj)
 {
     if (!pCSObj) {
         return;
     }
     GetPageData()->ReleaseColorSpace(pCSObj);
 }
 CPDF_DocPageData::CPDF_DocPageData(CPDF_Document* pPDFDoc)
     : m_pPDFDoc(pPDFDoc),
-      m_bForceClear(FALSE)
+      m_bForceClear(false)
 {
 }
 
 CPDF_DocPageData::~CPDF_DocPageData()
 {
-    Clear(FALSE);
-    Clear(TRUE);
+    Clear(false);
+    Clear(true);
 
     for (auto& it : m_PatternMap)
         delete it.second;
     m_PatternMap.clear();
 
     for (auto& it : m_FontMap)
         delete it.second;
     m_FontMap.clear();
 
     for (auto& it : m_ColorSpaceMap)
         delete it.second;
     m_ColorSpaceMap.clear();
 }
 
-void CPDF_DocPageData::Clear(FX_BOOL bForceRelease)
+void CPDF_DocPageData::Clear(bool bForceRelease)
 {
     m_bForceClear = bForceRelease;
 
     for (auto& it : m_PatternMap) {
         CPDF_CountedPattern* ptData = it.second;
         if (!ptData->get())
             continue;
 
         if (bForceRelease || ptData->use_count() < 2) {
             ptData->get()->SetForceClear(bForceRelease);
@@ skipping 66 matching lines @@
             continue;
 
         if (bForceRelease || imageData->use_count() < 2) {
             delete imageData->get();
             delete imageData;
             m_ImageMap.erase(curr_it);
         }
     }
 }
 
-CPDF_Font* CPDF_DocPageData::GetFont(CPDF_Dictionary* pFontDict, FX_BOOL findOnly)
+CPDF_Font* CPDF_DocPageData::GetFont(CPDF_Dictionary* pFontDict, bool findOnly)
 {
     if (!pFontDict) {
         return NULL;
     }
     if (findOnly) {
         auto it = m_FontMap.find(pFontDict);
         if (it != m_FontMap.end() && it->second->get()) {
             return it->second->AddRef();
         }
         return nullptr;
@@ skipping 176 matching lines @@
     CPDF_CountedColorSpace* csData = it->second;
     if (csData->get()) {
         csData->RemoveRef();
         if (csData->use_count() == 0) {
             csData->get()->ReleaseCS();
             csData->reset(nullptr);
         }
     }
 }
 
-CPDF_Pattern* CPDF_DocPageData::GetPattern(CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* matrix)
+CPDF_Pattern* CPDF_DocPageData::GetPattern(CPDF_Object* pPatternObj, bool bShading, const CFX_AffineMatrix* matrix)
 {
     if (!pPatternObj)
         return nullptr;
 
     CPDF_CountedPattern* ptData = nullptr;
     auto it = m_PatternMap.find(pPatternObj);
     if (it != m_PatternMap.end()) {
         ptData = it->second;
         if (ptData->get()) {
             return ptData->AddRef();
         }
     }
     CPDF_Pattern* pPattern = nullptr;
     if (bShading) {
         pPattern = new CPDF_ShadingPattern(m_pPDFDoc, pPatternObj, bShading, matrix);
     } else {
         CPDF_Dictionary* pDict = pPatternObj ? pPatternObj->GetDict() : nullptr;
         if (pDict) {
             int type = pDict->GetInteger(FX_BSTRC("PatternType"));
             if (type == 1) {
                 pPattern = new CPDF_TilingPattern(m_pPDFDoc, pPatternObj, matrix);
             } else if (type == 2) {
-                pPattern = new CPDF_ShadingPattern(m_pPDFDoc, pPatternObj, FALSE, matrix);
+                pPattern = new CPDF_ShadingPattern(m_pPDFDoc, pPatternObj, false, matrix);
             }
         }
     }
     if (!pPattern)
         return nullptr;
 
     if (!ptData) {
         ptData = new CPDF_CountedPattern(pPattern);
         m_PatternMap[pPatternObj] = ptData;
     } else {
@@ skipping 25 matching lines @@
     if (!pImageStream)
         return nullptr;
 
     const FX_DWORD dwImageObjNum = pImageStream->GetObjNum();
     auto it = m_ImageMap.find(dwImageObjNum);
     if (it != m_ImageMap.end()) {
         return it->second->AddRef();
     }
 
     CPDF_Image* pImage = new CPDF_Image(m_pPDFDoc);
-    pImage->LoadImageF((CPDF_Stream*)pImageStream, FALSE);
+    pImage->LoadImageF((CPDF_Stream*)pImageStream, false);
 
     CPDF_CountedImage* imageData = new CPDF_CountedImage(pImage);
     m_ImageMap[dwImageObjNum] = imageData;
     return imageData->AddRef();
 }
 
 void CPDF_DocPageData::ReleaseImage(CPDF_Object* pImageStream)
 {
     if (!pImageStream || !pImageStream->GetObjNum())
         return;
@@ skipping 18 matching lines @@
 {
     if (!pIccProfileStream)
         return NULL;
 
     auto it = m_IccProfileMap.find(pIccProfileStream);
     if (it != m_IccProfileMap.end()) {
         return it->second->AddRef();
     }
 
     CPDF_StreamAcc stream;
-    stream.LoadAllData(pIccProfileStream, FALSE);
+    stream.LoadAllData(pIccProfileStream, false);
     uint8_t digest[20];
     CPDF_Stream* pCopiedStream = nullptr;
     CRYPT_SHA1Generate(stream.GetData(), stream.GetSize(), digest);
     if (m_HashProfileMap.Lookup(CFX_ByteStringC(digest, 20), (void*&)pCopiedStream)) {
         auto it_copied_stream = m_IccProfileMap.find(pCopiedStream);
         return it_copied_stream->second->AddRef();
     }
     CPDF_IccProfile* pProfile = new CPDF_IccProfile(stream.GetData(), stream.GetSize());
     CPDF_CountedIccProfile* ipData = new CPDF_CountedIccProfile(pProfile);
     m_IccProfileMap[pIccProfileStream] = ipData;
@@ skipping 29 matching lines @@
         return it->second->AddRef();
 
     CPDF_Dictionary* pFontDict = pFontStream->GetDict();
     int32_t org_size = pFontDict->GetInteger(FX_BSTRC("Length1")) +
                        pFontDict->GetInteger(FX_BSTRC("Length2")) +
                        pFontDict->GetInteger(FX_BSTRC("Length3"));
     if (org_size < 0)
         org_size = 0;
 
     CPDF_StreamAcc* pFontFile = new CPDF_StreamAcc;
-    pFontFile->LoadAllData(pFontStream, FALSE, org_size);
+    pFontFile->LoadAllData(pFontStream, false, org_size);
 
     CPDF_CountedStreamAcc* ftData = new CPDF_CountedStreamAcc(pFontFile);
     m_FontFileMap[pFontStream] = ftData;
     return ftData->AddRef();
 }
 
-void CPDF_DocPageData::ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream, FX_BOOL bForce)
+void CPDF_DocPageData::ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream, bool bForce)
 {
     if (!pFontStream)
         return;
 
     auto it = m_FontFileMap.find(pFontStream);
     if (it == m_FontFileMap.end())
         return;
 
     CPDF_CountedStreamAcc* findData = it->second;
     if (!findData)
@@ skipping 17 matching lines @@
 }
 
 CPDF_CountedPattern* CPDF_DocPageData::FindPatternPtr(CPDF_Object* pPatternObj) const
 {
     if (!pPatternObj)
         return nullptr;
 
     auto it = m_PatternMap.find(pPatternObj);
     return it != m_PatternMap.end() ? it->second : nullptr;
 }