Remove FX_BOOL from core

core/fpdfapi/parser/cpdf_parser.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/parser/cpdf_parser.h"
 
 #include <vector>
 
@@ skipping 126 matching lines @@
 
   if (!pdfium::ContainsKey(m_ObjectInfo, objnum - 1))
     m_ObjectInfo[objnum - 1].pos = 0;
 }
 
 CPDF_Parser::Error CPDF_Parser::StartParse(IFX_SeekableReadStream* pFileAccess,
                                            CPDF_Document* pDocument) {
   ASSERT(!m_bHasParsed);
   m_bHasParsed = true;
 
-  m_bXRefStream = FALSE;
+  m_bXRefStream = false;
   m_LastXRefOffset = 0;
   m_bOwnFileRead = true;
 
   int32_t offset = GetHeaderOffset(pFileAccess);
   if (offset == -1) {
     if (pFileAccess)
       pFileAccess->Release();
     return FORMAT_ERROR;
   }
   m_pSyntax->InitParser(pFileAccess, offset);
 
   uint8_t ch;
   if (!m_pSyntax->GetCharAt(5, ch))
     return FORMAT_ERROR;
   if (std::isdigit(ch))
     m_FileVersion = FXSYS_toDecimalDigit(static_cast<FX_WCHAR>(ch)) * 10;
 
   if (!m_pSyntax->GetCharAt(7, ch))
     return FORMAT_ERROR;
   if (std::isdigit(ch))
     m_FileVersion += FXSYS_toDecimalDigit(static_cast<FX_WCHAR>(ch));
 
   if (m_pSyntax->m_FileLen < m_pSyntax->m_HeaderOffset + 9)
     return FORMAT_ERROR;
 
   m_pSyntax->RestorePos(m_pSyntax->m_FileLen - m_pSyntax->m_HeaderOffset - 9);
   m_pDocument = pDocument;
 
-  FX_BOOL bXRefRebuilt = FALSE;
-  if (m_pSyntax->SearchWord("startxref", TRUE, FALSE, 4096)) {
+  bool bXRefRebuilt = false;
+  if (m_pSyntax->SearchWord("startxref", true, false, 4096)) {
     m_SortedOffset.insert(m_pSyntax->SavePos());
     m_pSyntax->GetKeyword();
 
     bool bNumber;
     CFX_ByteString xrefpos_str = m_pSyntax->GetNextWord(&bNumber);
     if (!bNumber)
       return FORMAT_ERROR;
 
     m_LastXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str.c_str());
     if (!LoadAllCrossRefV4(m_LastXRefOffset) &&
         !LoadAllCrossRefV5(m_LastXRefOffset)) {
       if (!RebuildCrossRef())
         return FORMAT_ERROR;
 
-      bXRefRebuilt = TRUE;
+      bXRefRebuilt = true;
       m_LastXRefOffset = 0;
     }
   } else {
     if (!RebuildCrossRef())
       return FORMAT_ERROR;
 
-    bXRefRebuilt = TRUE;
+    bXRefRebuilt = true;
   }
   Error eRet = SetEncryptHandler();
   if (eRet != SUCCESS)
     return eRet;
 
   m_pDocument->LoadDoc();
   if (!m_pDocument->GetRoot() || m_pDocument->GetPageCount() == 0) {
     if (bXRefRebuilt)
       return FORMAT_ERROR;
 
@@ skipping 106 matching lines @@
       // If the object number read doesn't match the one stored,
       // something is wrong with the cross reference table.
       return false;
     } else {
       return true;
     }
   }
   return true;
 }
 
-FX_BOOL CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos) {
-  if (!LoadCrossRefV4(xrefpos, 0, TRUE))
-    return FALSE;
+bool CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos) {
+  if (!LoadCrossRefV4(xrefpos, 0, true))
+    return false;
 
   m_pTrailer = LoadTrailerV4();
   if (!m_pTrailer)
-    return FALSE;
+    return false;
 
   int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
   if (xrefsize > 0 && xrefsize <= kMaxXRefSize)
     ShrinkObjectMap(xrefsize);
 
   std::vector<FX_FILESIZE> CrossRefList;
   std::vector<FX_FILESIZE> XRefStreamList;
   std::set<FX_FILESIZE> seen_xrefpos;
 
   CrossRefList.push_back(xrefpos);
   XRefStreamList.push_back(GetDirectInteger(m_pTrailer, "XRefStm"));
   seen_xrefpos.insert(xrefpos);
 
   // When |m_pTrailer| doesn't have Prev entry or Prev entry value is not
   // numerical, GetDirectInteger() returns 0. Loading will end.
   xrefpos = GetDirectInteger(m_pTrailer, "Prev");
   while (xrefpos) {
     // Check for circular references.
     if (pdfium::ContainsKey(seen_xrefpos, xrefpos))
-      return FALSE;
+      return false;
 
     seen_xrefpos.insert(xrefpos);
 
     // SLOW ...
     CrossRefList.insert(CrossRefList.begin(), xrefpos);
-    LoadCrossRefV4(xrefpos, 0, TRUE);
+    LoadCrossRefV4(xrefpos, 0, true);
 
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         LoadTrailerV4());
     if (!pDict)
-      return FALSE;
+      return false;
 
     xrefpos = GetDirectInteger(pDict.get(), "Prev");
 
     // SLOW ...
     XRefStreamList.insert(XRefStreamList.begin(),
                           pDict->GetIntegerFor("XRefStm"));
     m_Trailers.push_back(pDict.release());
   }
 
   for (size_t i = 0; i < CrossRefList.size(); ++i) {
-    if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE))
-      return FALSE;
+    if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], false))
+      return false;
     if (i == 0 && !VerifyCrossRefV4())
-      return FALSE;
+      return false;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos,
-                                                 uint32_t dwObjCount) {
+bool CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos,
+                                              uint32_t dwObjCount) {
   if (!LoadLinearizedCrossRefV4(xrefpos, dwObjCount))
-    return FALSE;
+    return false;
 
   m_pTrailer = LoadTrailerV4();
   if (!m_pTrailer)
-    return FALSE;
+    return false;
 
   int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
   if (xrefsize == 0)
-    return FALSE;
+    return false;
 
   std::vector<FX_FILESIZE> CrossRefList;
   std::vector<FX_FILESIZE> XRefStreamList;
   std::set<FX_FILESIZE> seen_xrefpos;
 
   CrossRefList.push_back(xrefpos);
   XRefStreamList.push_back(GetDirectInteger(m_pTrailer, "XRefStm"));
   seen_xrefpos.insert(xrefpos);
 
   xrefpos = GetDirectInteger(m_pTrailer, "Prev");
   while (xrefpos) {
     // Check for circular references.
     if (pdfium::ContainsKey(seen_xrefpos, xrefpos))
-      return FALSE;
+      return false;
 
     seen_xrefpos.insert(xrefpos);
 
     // SLOW ...
     CrossRefList.insert(CrossRefList.begin(), xrefpos);
-    LoadCrossRefV4(xrefpos, 0, TRUE);
+    LoadCrossRefV4(xrefpos, 0, true);
 
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         LoadTrailerV4());
     if (!pDict)
-      return FALSE;
+      return false;
 
     xrefpos = GetDirectInteger(pDict.get(), "Prev");
 
     // SLOW ...
     XRefStreamList.insert(XRefStreamList.begin(),
                           pDict->GetIntegerFor("XRefStm"));
     m_Trailers.push_back(pDict.release());
   }
 
   for (size_t i = 1; i < CrossRefList.size(); ++i) {
-    if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE))
-      return FALSE;
+    if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], false))
+      return false;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos,
-                                              uint32_t dwObjCount) {
+bool CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos,
+                                           uint32_t dwObjCount) {
   FX_FILESIZE dwStartPos = pos - m_pSyntax->m_HeaderOffset;
 
   m_pSyntax->RestorePos(dwStartPos);
   m_SortedOffset.insert(pos);
 
   uint32_t start_objnum = 0;
   uint32_t count = dwObjCount;
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
 
   const int32_t recordsize = 20;
   std::vector<char> buf(1024 * recordsize + 1);
   buf[1024 * recordsize] = '\0';
 
   int32_t nBlocks = count / 1024 + 1;
   for (int32_t block = 0; block < nBlocks; block++) {
     int32_t block_size = block == nBlocks - 1 ? count % 1024 : 1024;
     uint32_t dwReadSize = block_size * recordsize;
     if ((FX_FILESIZE)(dwStartPos + dwReadSize) > m_pSyntax->m_FileLen)
-      return FALSE;
+      return false;
 
     if (!m_pSyntax->ReadBlock(reinterpret_cast<uint8_t*>(buf.data()),
                               dwReadSize)) {
-      return FALSE;
+      return false;
     }
 
     for (int32_t i = 0; i < block_size; i++) {
       uint32_t objnum = start_objnum + block * 1024 + i;
       char* pEntry = &buf[i * recordsize];
       if (pEntry[17] == 'f') {
         m_ObjectInfo[objnum].pos = 0;
         m_ObjectInfo[objnum].type = 0;
       } else {
         int32_t offset = FXSYS_atoi(pEntry);
         if (offset == 0) {
           for (int32_t c = 0; c < 10; c++) {
             if (!std::isdigit(pEntry[c]))
-              return FALSE;
+              return false;
           }
         }
 
         m_ObjectInfo[objnum].pos = offset;
         int32_t version = FXSYS_atoi(pEntry + 11);
         if (version >= 1)
           m_bVersionUpdated = true;
 
         m_ObjectInfo[objnum].gennum = version;
         if (m_ObjectInfo[objnum].pos < m_pSyntax->m_FileLen)
           m_SortedOffset.insert(m_ObjectInfo[objnum].pos);
 
         m_ObjectInfo[objnum].type = 1;
       }
     }
   }
   m_pSyntax->RestorePos(SavedPos + count * recordsize);
-  return TRUE;
+  return true;
 }
 
 bool CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos,
                                  FX_FILESIZE streampos,
-                                 FX_BOOL bSkip) {
+                                 bool bSkip) {
   m_pSyntax->RestorePos(pos);
   if (m_pSyntax->GetKeyword() != "xref")
     return false;
 
   m_SortedOffset.insert(pos);
   if (streampos)
     m_SortedOffset.insert(streampos);
 
   while (1) {
     FX_FILESIZE SavedPos = m_pSyntax->SavePos();
@@ skipping 51 matching lines @@
             if (m_ObjectInfo[objnum].pos < m_pSyntax->m_FileLen)
               m_SortedOffset.insert(m_ObjectInfo[objnum].pos);
 
             m_ObjectInfo[objnum].type = 1;
           }
         }
       }
     }
     m_pSyntax->RestorePos(SavedPos + count * recordsize);
   }
-  return !streampos || LoadCrossRefV5(&streampos, FALSE);
+  return !streampos || LoadCrossRefV5(&streampos, false);
 }
 
-FX_BOOL CPDF_Parser::LoadAllCrossRefV5(FX_FILESIZE xrefpos) {
-  if (!LoadCrossRefV5(&xrefpos, TRUE))
-    return FALSE;
+bool CPDF_Parser::LoadAllCrossRefV5(FX_FILESIZE xrefpos) {
+  if (!LoadCrossRefV5(&xrefpos, true))
+    return false;
 
   std::set<FX_FILESIZE> seen_xrefpos;
   while (xrefpos) {
     seen_xrefpos.insert(xrefpos);
-    if (!LoadCrossRefV5(&xrefpos, FALSE))
-      return FALSE;
+    if (!LoadCrossRefV5(&xrefpos, false))
+      return false;
 
     // Check for circular references.
     if (pdfium::ContainsKey(seen_xrefpos, xrefpos))
-      return FALSE;
+      return false;
   }
   m_ObjectStreamMap.clear();
-  m_bXRefStream = TRUE;
-  return TRUE;
+  m_bXRefStream = true;
+  return true;
 }
 
-FX_BOOL CPDF_Parser::RebuildCrossRef() {
+bool CPDF_Parser::RebuildCrossRef() {
   m_ObjectInfo.clear();
   m_SortedOffset.clear();
   if (m_pTrailer) {
     m_pTrailer->Release();
     m_pTrailer = nullptr;
   }
 
   ParserState state = ParserState::kDefault;
 
   int32_t inside_index = 0;
@@ skipping 346 matching lines @@
 
   if (last_xref != -1 && last_xref > last_obj)
     last_trailer = last_xref;
   else if (last_trailer == -1 || last_xref < last_obj)
     last_trailer = m_pSyntax->m_FileLen;
 
   m_SortedOffset.insert(last_trailer - m_pSyntax->m_HeaderOffset);
   return m_pTrailer && !m_ObjectInfo.empty();
 }
 
-FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE* pos, FX_BOOL bMainXRef) {
+bool CPDF_Parser::LoadCrossRefV5(FX_FILESIZE* pos, bool bMainXRef) {
   std::unique_ptr<CPDF_Object> pObject(
       ParseIndirectObjectAt(m_pDocument, *pos, 0));
   if (!pObject)
-    return FALSE;
+    return false;
 
   CPDF_Object* pUnownedObject = pObject.get();
 
   if (m_pDocument) {
     CPDF_Dictionary* pRootDict = m_pDocument->GetRoot();
     if (pRootDict && pRootDict->GetObjNum() == pObject->m_ObjNum)
-      return FALSE;
+      return false;
     // Takes ownership of object (std::move someday).
     uint32_t objnum = pObject->m_ObjNum;
     if (!m_pDocument->ReplaceIndirectObjectIfHigherGeneration(
             objnum, pObject.release())) {
-      return FALSE;
+      return false;
     }
   }
 
   CPDF_Stream* pStream = pUnownedObject->AsStream();
   if (!pStream)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pDict = pStream->GetDict();
   *pos = pDict->GetIntegerFor("Prev");
   int32_t size = pDict->GetIntegerFor("Size");
   if (size < 0)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pNewTrailer = ToDictionary(pDict->Clone());
   if (bMainXRef) {
     m_pTrailer = pNewTrailer;
     ShrinkObjectMap(size);
     for (auto& it : m_ObjectInfo)
       it.second.type = 0;
   } else {
     m_Trailers.push_back(pNewTrailer);
   }
@@ skipping 12 matching lines @@
           arrIndex.push_back(std::make_pair(nStartNum, nCount));
       }
     }
   }
 
   if (arrIndex.size() == 0)
     arrIndex.push_back(std::make_pair(0, size));
 
   pArray = pDict->GetArrayFor("W");
   if (!pArray)
-    return FALSE;
+    return false;
 
   CFX_ArrayTemplate<uint32_t> WidthArray;
   FX_SAFE_UINT32 dwAccWidth = 0;
   for (size_t i = 0; i < pArray->GetCount(); ++i) {
     WidthArray.Add(pArray->GetIntegerAt(i));
     dwAccWidth += WidthArray[i];
   }
 
   if (!dwAccWidth.IsValid() || WidthArray.GetSize() < 3)
-    return FALSE;
+    return false;
 
   uint32_t totalWidth = dwAccWidth.ValueOrDie();
   CPDF_StreamAcc acc;
   acc.LoadAllData(pStream);
 
   const uint8_t* pData = acc.GetData();
   uint32_t dwTotalSize = acc.GetSize();
   uint32_t segindex = 0;
   for (uint32_t i = 0; i < arrIndex.size(); i++) {
     int32_t startnum = arrIndex[i].first;
@@ skipping 40 matching lines @@
       if (type == 0) {
         m_ObjectInfo[startnum + j].pos = 0;
       } else {
         FX_FILESIZE offset =
             GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
         m_ObjectInfo[startnum + j].pos = offset;
         if (type == 1) {
           m_SortedOffset.insert(offset);
         } else {
           if (offset < 0 || !IsValidObjectNumber(offset))
-            return FALSE;
+            return false;
           m_ObjectInfo[offset].type = 255;
         }
       }
     }
     segindex += count;
   }
-  return TRUE;
+  return true;
 }
 
 CPDF_Array* CPDF_Parser::GetIDArray() {
   CPDF_Object* pID = m_pTrailer ? m_pTrailer->GetObjectFor("ID") : nullptr;
   if (!pID)
     return nullptr;
 
   if (CPDF_Reference* pRef = pID->AsReference()) {
     pID = ParseIndirectObject(nullptr, pRef->GetRefObjNum());
     m_pTrailer->SetFor("ID", pID);
@@ skipping 31 matching lines @@
     return ParseIndirectObjectAt(pObjList, pos, objnum);
   }
   if (GetObjectType(objnum) != 2)
     return nullptr;
 
   CPDF_StreamAcc* pObjStream = GetObjectStream(m_ObjectInfo[objnum].pos);
   if (!pObjStream)
     return nullptr;
 
   ScopedFileStream file(FX_CreateMemoryStream(
-      (uint8_t*)pObjStream->GetData(), (size_t)pObjStream->GetSize(), FALSE));
+      (uint8_t*)pObjStream->GetData(), (size_t)pObjStream->GetSize(), false));
   CPDF_SyntaxParser syntax;
   syntax.InitParser(file.get(), 0);
   const int32_t offset = GetStreamFirst(pObjStream);
 
   // Read object numbers from |pObjStream| into a cache.
   if (!pdfium::ContainsKey(m_ObjCache, pObjStream)) {
     for (int32_t i = GetStreamNCount(pObjStream); i > 0; --i) {
       uint32_t thisnum = syntax.GetDirectNum();
       uint32_t thisoff = syntax.GetDirectNum();
       m_ObjCache[pObjStream][thisnum] = thisoff;
@@ skipping 58 matching lines @@
 
   if (GetObjectType(objnum) == 2) {
     CPDF_StreamAcc* pObjStream = GetObjectStream(m_ObjectInfo[objnum].pos);
     if (!pObjStream)
       return;
 
     int32_t offset = GetStreamFirst(pObjStream);
     const uint8_t* pData = pObjStream->GetData();
     uint32_t totalsize = pObjStream->GetSize();
     ScopedFileStream file(
-        FX_CreateMemoryStream((uint8_t*)pData, (size_t)totalsize, FALSE));
+        FX_CreateMemoryStream((uint8_t*)pData, (size_t)totalsize, false));
 
     CPDF_SyntaxParser syntax;
     syntax.InitParser(file.get(), 0);
     for (int i = GetStreamNCount(pObjStream); i > 0; --i) {
       uint32_t thisnum = syntax.GetDirectNum();
       uint32_t thisoff = syntax.GetDirectNum();
       if (thisnum != objnum)
         continue;
 
       if (i == 1) {
@@ skipping 45 matching lines @@
     return;
   }
 
   auto it = m_SortedOffset.find(pos);
   if (it == m_SortedOffset.end() || ++it == m_SortedOffset.end()) {
     m_pSyntax->RestorePos(SavedPos);
     return;
   }
 
   FX_FILESIZE nextoff = *it;
-  FX_BOOL bNextOffValid = FALSE;
+  bool bNextOffValid = false;
   if (nextoff != pos) {
     m_pSyntax->RestorePos(nextoff);
     word = m_pSyntax->GetNextWord(&bIsNumber);
     if (word == "xref") {
-      bNextOffValid = TRUE;
+      bNextOffValid = true;
     } else if (bIsNumber) {
       word = m_pSyntax->GetNextWord(&bIsNumber);
       if (bIsNumber && m_pSyntax->GetKeyword() == "obj") {
-        bNextOffValid = TRUE;
+        bNextOffValid = true;
       }
     }
   }
 
   if (!bNextOffValid) {
     m_pSyntax->RestorePos(pos);
     while (1) {
       if (m_pSyntax->GetKeyword() == "endobj")
         break;
 
@@ skipping 118 matching lines @@
 
   uint32_t dwPermission = m_pSecurityHandler->GetPermissions();
   if (m_pEncryptDict && m_pEncryptDict->GetStringFor("Filter") == "Standard") {
     // See PDF Reference 1.7, page 123, table 3.20.
     dwPermission &= 0xFFFFFFFC;
     dwPermission |= 0xFFFFF0C0;
   }
   return dwPermission;
 }
 
-FX_BOOL CPDF_Parser::IsLinearizedFile(IFX_SeekableReadStream* pFileAccess,
-                                      uint32_t offset) {
+bool CPDF_Parser::IsLinearizedFile(IFX_SeekableReadStream* pFileAccess,
+                                   uint32_t offset) {
   m_pSyntax->InitParser(pFileAccess, offset);
   m_pSyntax->RestorePos(m_pSyntax->m_HeaderOffset + 9);
 
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
   bool bIsNumber;
   CFX_ByteString word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber)
-    return FALSE;
+    return false;
 
   uint32_t objnum = FXSYS_atoui(word.c_str());
   word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber)
-    return FALSE;
+    return false;
 
   uint32_t gennum = FXSYS_atoui(word.c_str());
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
-    return FALSE;
+    return false;
   }
 
   m_pLinearized = m_pSyntax->GetObject(nullptr, objnum, gennum, true);
   if (!m_pLinearized)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
   if (pDict && pDict->GetObjectFor("Linearized")) {
     m_pSyntax->GetNextWord(nullptr);
 
     CPDF_Object* pLen = pDict->GetObjectFor("L");
     if (!pLen) {
       m_pLinearized->Release();
       m_pLinearized = nullptr;
-      return FALSE;
+      return false;
     }
 
     if (pLen->GetInteger() != (int)pFileAccess->GetSize())
-      return FALSE;
+      return false;
 
     if (CPDF_Number* pNo = ToNumber(pDict->GetObjectFor("P")))
       m_dwFirstPageNo = pNo->GetInteger();
 
     if (CPDF_Number* pTable = ToNumber(pDict->GetObjectFor("T")))
       m_LastXRefOffset = pTable->GetInteger();
 
-    return TRUE;
+    return true;
   }
   m_pLinearized->Release();
   m_pLinearized = nullptr;
-  return FALSE;
+  return false;
 }
 
 CPDF_Parser::Error CPDF_Parser::StartLinearizedParse(
     IFX_SeekableReadStream* pFileAccess,
     CPDF_Document* pDocument) {
   ASSERT(!m_bHasParsed);
 
-  m_bXRefStream = FALSE;
+  m_bXRefStream = false;
   m_LastXRefOffset = 0;
   m_bOwnFileRead = true;
 
   int32_t offset = GetHeaderOffset(pFileAccess);
   if (offset == -1)
     return FORMAT_ERROR;
 
   if (!IsLinearizedFile(pFileAccess, offset)) {
     m_pSyntax->m_pFileAccess = nullptr;
     return StartParse(pFileAccess, std::move(pDocument));
   }
   m_bHasParsed = true;
   m_pDocument = pDocument;
 
   FX_FILESIZE dwFirstXRefOffset = m_pSyntax->SavePos();
 
-  FX_BOOL bXRefRebuilt = FALSE;
-  FX_BOOL bLoadV4 = LoadCrossRefV4(dwFirstXRefOffset, 0, FALSE);
-  if (!bLoadV4 && !LoadCrossRefV5(&dwFirstXRefOffset, TRUE)) {
+  bool bXRefRebuilt = false;
+  bool bLoadV4 = LoadCrossRefV4(dwFirstXRefOffset, 0, false);
+  if (!bLoadV4 && !LoadCrossRefV5(&dwFirstXRefOffset, true)) {
     if (!RebuildCrossRef())
       return FORMAT_ERROR;
 
-    bXRefRebuilt = TRUE;
+    bXRefRebuilt = true;
     m_LastXRefOffset = 0;
   }
 
   if (bLoadV4) {
     m_pTrailer = LoadTrailerV4();
     if (!m_pTrailer)
       return SUCCESS;
 
     int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
     if (xrefsize > 0)
@@ skipping 33 matching lines @@
   }
 
   if (m_pSecurityHandler && m_pSecurityHandler->IsMetadataEncrypted()) {
     if (CPDF_Reference* pMetadata =
             ToReference(m_pDocument->GetRoot()->GetObjectFor("Metadata")))
       m_pSyntax->m_MetadataObjnum = pMetadata->GetRefObjNum();
   }
   return SUCCESS;
 }
 
-FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV5(FX_FILESIZE xrefpos) {
-  if (!LoadCrossRefV5(&xrefpos, FALSE))
-    return FALSE;
+bool CPDF_Parser::LoadLinearizedAllCrossRefV5(FX_FILESIZE xrefpos) {
+  if (!LoadCrossRefV5(&xrefpos, false))
+    return false;
 
   std::set<FX_FILESIZE> seen_xrefpos;
   while (xrefpos) {
     seen_xrefpos.insert(xrefpos);
-    if (!LoadCrossRefV5(&xrefpos, FALSE))
-      return FALSE;
+    if (!LoadCrossRefV5(&xrefpos, false))
+      return false;
 
     // Check for circular references.
     if (pdfium::ContainsKey(seen_xrefpos, xrefpos))
-      return FALSE;
+      return false;
   }
   m_ObjectStreamMap.clear();
-  m_bXRefStream = TRUE;
-  return TRUE;
+  m_bXRefStream = true;
+  return true;
 }
 
 CPDF_Parser::Error CPDF_Parser::LoadLinearizedMainXRefTable() {
   uint32_t dwSaveMetadataObjnum = m_pSyntax->m_MetadataObjnum;
   m_pSyntax->m_MetadataObjnum = 0;
   if (m_pTrailer) {
     m_pTrailer->Release();
     m_pTrailer = nullptr;
   }
 
@@ skipping 16 matching lines @@
   if (!LoadLinearizedAllCrossRefV4(m_LastXRefOffset, m_dwXrefStartObjNum) &&
       !LoadLinearizedAllCrossRefV5(m_LastXRefOffset)) {
     m_LastXRefOffset = 0;
     m_pSyntax->m_MetadataObjnum = dwSaveMetadataObjnum;
     return FORMAT_ERROR;
   }
 
   m_pSyntax->m_MetadataObjnum = dwSaveMetadataObjnum;
   return SUCCESS;
 }