Remove FX_BOOL from fpdfsdk.

fpdfsdk/fpdfppo.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 "public/fpdf_ppo.h"
 
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
 #include "core/fpdfapi/parser/cpdf_reference.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/cpdf_string.h"
 #include "fpdfsdk/fsdk_define.h"
 #include "third_party/base/stl_util.h"
 
 class CPDF_PageOrganizer {
  public:
   using ObjectNumberMap = std::map<uint32_t, uint32_t>;
   CPDF_PageOrganizer();
   ~CPDF_PageOrganizer();
 
-  FX_BOOL PDFDocInit(CPDF_Document* pDestPDFDoc, CPDF_Document* pSrcPDFDoc);
-  FX_BOOL ExportPage(CPDF_Document* pSrcPDFDoc,
-                     std::vector<uint16_t>* pPageNums,
-                     CPDF_Document* pDestPDFDoc,
-                     int nIndex);
+  bool PDFDocInit(CPDF_Document* pDestPDFDoc, CPDF_Document* pSrcPDFDoc);
+  bool ExportPage(CPDF_Document* pSrcPDFDoc,
+                  std::vector<uint16_t>* pPageNums,
+                  CPDF_Document* pDestPDFDoc,
+                  int nIndex);
   CPDF_Object* PageDictGetInheritableTag(CPDF_Dictionary* pDict,
                                          const CFX_ByteString& bsSrctag);
-  FX_BOOL UpdateReference(CPDF_Object* pObj,
-                          CPDF_Document* pDoc,
-                          ObjectNumberMap* pObjNumberMap);
+  bool UpdateReference(CPDF_Object* pObj,
+                       CPDF_Document* pDoc,
+                       ObjectNumberMap* pObjNumberMap);
   uint32_t GetNewObjId(CPDF_Document* pDoc,
                        ObjectNumberMap* pObjNumberMap,
                        CPDF_Reference* pRef);
 };
 
 CPDF_PageOrganizer::CPDF_PageOrganizer() {}
 
 CPDF_PageOrganizer::~CPDF_PageOrganizer() {}
 
-FX_BOOL CPDF_PageOrganizer::PDFDocInit(CPDF_Document* pDestPDFDoc,
-                                       CPDF_Document* pSrcPDFDoc) {
+bool CPDF_PageOrganizer::PDFDocInit(CPDF_Document* pDestPDFDoc,
+                                    CPDF_Document* pSrcPDFDoc) {
   if (!pDestPDFDoc || !pSrcPDFDoc)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pNewRoot = pDestPDFDoc->GetRoot();
   if (!pNewRoot)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* DInfoDict = pDestPDFDoc->GetInfo();
   if (!DInfoDict)
-    return FALSE;
+    return false;
 
   CFX_ByteString producerstr;
   producerstr.Format("PDFium");
-  DInfoDict->SetFor("Producer", new CPDF_String(producerstr, FALSE));
+  DInfoDict->SetFor("Producer", new CPDF_String(producerstr, false));
 
   CFX_ByteString cbRootType = pNewRoot->GetStringFor("Type", "");
   if (cbRootType.IsEmpty())
     pNewRoot->SetFor("Type", new CPDF_Name("Catalog"));
 
   CPDF_Object* pElement = pNewRoot->GetObjectFor("Pages");
   CPDF_Dictionary* pNewPages =
       pElement ? ToDictionary(pElement->GetDirect()) : nullptr;
   if (!pNewPages) {
     pNewPages = new CPDF_Dictionary(pDestPDFDoc->GetByteStringPool());
     pNewRoot->SetReferenceFor("Pages", pDestPDFDoc,
                               pDestPDFDoc->AddIndirectObject(pNewPages));
   }
 
   CFX_ByteString cbPageType = pNewPages->GetStringFor("Type", "");
   if (cbPageType == "") {
     pNewPages->SetFor("Type", new CPDF_Name("Pages"));
   }
 
   if (!pNewPages->GetArrayFor("Kids")) {
     pNewPages->SetIntegerFor("Count", 0);
     pNewPages->SetReferenceFor("Kids", pDestPDFDoc,
                                pDestPDFDoc->AddIndirectObject(new CPDF_Array));
   }
 
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_PageOrganizer::ExportPage(CPDF_Document* pSrcPDFDoc,
-                                       std::vector<uint16_t>* pPageNums,
-                                       CPDF_Document* pDestPDFDoc,
-                                       int nIndex) {
+bool CPDF_PageOrganizer::ExportPage(CPDF_Document* pSrcPDFDoc,
+                                    std::vector<uint16_t>* pPageNums,
+                                    CPDF_Document* pDestPDFDoc,
+                                    int nIndex) {
   int curpage = nIndex;
   std::unique_ptr<ObjectNumberMap> pObjNumberMap(new ObjectNumberMap);
   int nSize = pdfium::CollectionSize<int>(*pPageNums);
   for (int i = 0; i < nSize; ++i) {
     CPDF_Dictionary* pCurPageDict = pDestPDFDoc->CreateNewPage(curpage);
     CPDF_Dictionary* pSrcPageDict = pSrcPDFDoc->GetPage(pPageNums->at(i) - 1);
     if (!pSrcPageDict || !pCurPageDict)
-      return FALSE;
+      return false;
 
     // Clone the page dictionary
     for (const auto& it : *pSrcPageDict) {
       const CFX_ByteString& cbSrcKeyStr = it.first;
       CPDF_Object* pObj = it.second;
       if (cbSrcKeyStr.Compare(("Type")) && cbSrcKeyStr.Compare(("Parent"))) {
         if (pCurPageDict->KeyExist(cbSrcKeyStr))
           pCurPageDict->RemoveFor(cbSrcKeyStr);
         pCurPageDict->SetFor(cbSrcKeyStr, pObj->Clone());
       }
@@ skipping 20 matching lines @@
           pCurPageDict->SetFor("MediaBox", pArray);
         }
       } else {
         pCurPageDict->SetFor("MediaBox", pInheritable->Clone());
       }
     }
     // 2 Resources //required
     if (!pCurPageDict->KeyExist("Resources")) {
       pInheritable = PageDictGetInheritableTag(pSrcPageDict, "Resources");
       if (!pInheritable)
-        return FALSE;
+        return false;
       pCurPageDict->SetFor("Resources", pInheritable->Clone());
     }
     // 3 CropBox  //Optional
     if (!pCurPageDict->KeyExist("CropBox")) {
       pInheritable = PageDictGetInheritableTag(pSrcPageDict, "CropBox");
       if (pInheritable)
         pCurPageDict->SetFor("CropBox", pInheritable->Clone());
     }
     // 4 Rotate  //Optional
     if (!pCurPageDict->KeyExist("Rotate")) {
       pInheritable = PageDictGetInheritableTag(pSrcPageDict, "Rotate");
       if (pInheritable)
         pCurPageDict->SetFor("Rotate", pInheritable->Clone());
     }
 
     // Update the reference
     uint32_t dwOldPageObj = pSrcPageDict->GetObjNum();
     uint32_t dwNewPageObj = pCurPageDict->GetObjNum();
 
     (*pObjNumberMap)[dwOldPageObj] = dwNewPageObj;
 
     UpdateReference(pCurPageDict, pDestPDFDoc, pObjNumberMap.get());
     ++curpage;
   }
 
-  return TRUE;
+  return true;
 }
 
 CPDF_Object* CPDF_PageOrganizer::PageDictGetInheritableTag(
     CPDF_Dictionary* pDict,
     const CFX_ByteString& bsSrcTag) {
   if (!pDict || bsSrcTag.IsEmpty())
     return nullptr;
   if (!pDict->KeyExist("Parent") || !pDict->KeyExist("Type"))
     return nullptr;
 
@@ skipping 14 matching lines @@
   while (pp) {
     if (pp->KeyExist(bsSrcTag))
       return pp->GetObjectFor(bsSrcTag);
     if (!pp->KeyExist("Parent"))
       break;
     pp = ToDictionary(pp->GetObjectFor("Parent")->GetDirect());
   }
   return nullptr;
 }
 
-FX_BOOL CPDF_PageOrganizer::UpdateReference(CPDF_Object* pObj,
-                                            CPDF_Document* pDoc,
-                                            ObjectNumberMap* pObjNumberMap) {
+bool CPDF_PageOrganizer::UpdateReference(CPDF_Object* pObj,
+                                         CPDF_Document* pDoc,
+                                         ObjectNumberMap* pObjNumberMap) {
   switch (pObj->GetType()) {
     case CPDF_Object::REFERENCE: {
       CPDF_Reference* pReference = pObj->AsReference();
       uint32_t newobjnum = GetNewObjId(pDoc, pObjNumberMap, pReference);
       if (newobjnum == 0)
-        return FALSE;
+        return false;
       pReference->SetRef(pDoc, newobjnum);
       break;
     }
     case CPDF_Object::DICTIONARY: {
       CPDF_Dictionary* pDict = pObj->AsDictionary();
       auto it = pDict->begin();
       while (it != pDict->end()) {
         const CFX_ByteString& key = it->first;
         CPDF_Object* pNextObj = it->second;
         ++it;
         if (key == "Parent" || key == "Prev" || key == "First")
           continue;
         if (!pNextObj)
-          return FALSE;
+          return false;
         if (!UpdateReference(pNextObj, pDoc, pObjNumberMap))
           pDict->RemoveFor(key);
       }
       break;
     }
     case CPDF_Object::ARRAY: {
       CPDF_Array* pArray = pObj->AsArray();
       for (size_t i = 0; i < pArray->GetCount(); ++i) {
         CPDF_Object* pNextObj = pArray->GetObjectAt(i);
         if (!pNextObj)
-          return FALSE;
+          return false;
         if (!UpdateReference(pNextObj, pDoc, pObjNumberMap))
-          return FALSE;
+          return false;
       }
       break;
     }
     case CPDF_Object::STREAM: {
       CPDF_Stream* pStream = pObj->AsStream();
       CPDF_Dictionary* pDict = pStream->GetDict();
       if (pDict) {
         if (!UpdateReference(pDict, pDoc, pObjNumberMap))
-          return FALSE;
+          return false;
       } else {
-        return FALSE;
+        return false;
       }
       break;
     }
     default:
       break;
   }
 
-  return TRUE;
+  return true;
 }
 
 uint32_t CPDF_PageOrganizer::GetNewObjId(CPDF_Document* pDoc,
                                          ObjectNumberMap* pObjNumberMap,
                                          CPDF_Reference* pRef) {
   if (!pRef)
     return 0;
 
   uint32_t dwObjnum = pRef->GetRefObjNum();
   uint32_t dwNewObjNum = 0;
@@ skipping 35 matching lines @@
 
 FPDF_BOOL ParserPageRangeString(CFX_ByteString rangstring,
                                 std::vector<uint16_t>* pageArray,
                                 int nCount) {
   if (rangstring.GetLength() != 0) {
     rangstring.Remove(' ');
     int nLength = rangstring.GetLength();
     CFX_ByteString cbCompareString("0123456789-,");
     for (int i = 0; i < nLength; ++i) {
       if (cbCompareString.Find(rangstring[i]) == -1)
-        return FALSE;
+        return false;
     }
     CFX_ByteString cbMidRange;
     int nStringFrom = 0;
     int nStringTo = 0;
     while (nStringTo < nLength) {
       nStringTo = rangstring.Find(',', nStringFrom);
       if (nStringTo == -1)
         nStringTo = nLength;
       cbMidRange = rangstring.Mid(nStringFrom, nStringTo - nStringFrom);
       int nMid = cbMidRange.Find('-');
       if (nMid == -1) {
         long lPageNum = atol(cbMidRange.c_str());
         if (lPageNum <= 0 || lPageNum > nCount)
-          return FALSE;
+          return false;
         pageArray->push_back((uint16_t)lPageNum);
       } else {
         int nStartPageNum = atol(cbMidRange.Mid(0, nMid).c_str());
         if (nStartPageNum == 0)
-          return FALSE;
+          return false;
 
         ++nMid;
         int nEnd = cbMidRange.GetLength() - nMid;
         if (nEnd == 0)
-          return FALSE;
+          return false;
 
         int nEndPageNum = atol(cbMidRange.Mid(nMid, nEnd).c_str());
         if (nStartPageNum < 0 || nStartPageNum > nEndPageNum ||
             nEndPageNum > nCount) {
-          return FALSE;
+          return false;
         }
         for (int i = nStartPageNum; i <= nEndPageNum; ++i) {
           pageArray->push_back(i);
         }
       }
       nStringFrom = nStringTo + 1;
     }
   }
-  return TRUE;
+  return true;
 }
 
 DLLEXPORT FPDF_BOOL STDCALL FPDF_ImportPages(FPDF_DOCUMENT dest_doc,
                                              FPDF_DOCUMENT src_doc,
                                              FPDF_BYTESTRING pagerange,
                                              int index) {
   CPDF_Document* pDestDoc = CPDFDocumentFromFPDFDocument(dest_doc);
   if (!dest_doc)
-    return FALSE;
+    return false;
 
   CPDF_Document* pSrcDoc = CPDFDocumentFromFPDFDocument(src_doc);
   if (!pSrcDoc)
-    return FALSE;
+    return false;
 
   std::vector<uint16_t> pageArray;
   int nCount = pSrcDoc->GetPageCount();
   if (pagerange) {
     if (!ParserPageRangeString(pagerange, &pageArray, nCount))
-      return FALSE;
+      return false;
   } else {
     for (int i = 1; i <= nCount; ++i) {
       pageArray.push_back(i);
     }
   }
 
   CPDF_PageOrganizer pageOrg;
   pageOrg.PDFDocInit(pDestDoc, pSrcDoc);
   return pageOrg.ExportPage(pSrcDoc, &pageArray, pDestDoc, index);
 }
 
 DLLEXPORT FPDF_BOOL STDCALL FPDF_CopyViewerPreferences(FPDF_DOCUMENT dest_doc,
                                                        FPDF_DOCUMENT src_doc) {
   CPDF_Document* pDstDoc = CPDFDocumentFromFPDFDocument(dest_doc);
   if (!pDstDoc)
-    return FALSE;
+    return false;
 
   CPDF_Document* pSrcDoc = CPDFDocumentFromFPDFDocument(src_doc);
   if (!pSrcDoc)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pSrcDict = pSrcDoc->GetRoot();
   pSrcDict = pSrcDict->GetDictFor("ViewerPreferences");
   if (!pSrcDict)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pDstDict = pDstDoc->GetRoot();
   if (!pDstDict)
-    return FALSE;
+    return false;
 
   pDstDict->SetFor("ViewerPreferences", pSrcDict->CloneDirectObject());
-  return TRUE;
+  return true;
 }