Remove FX_BOOL from core

core/fpdfapi/edit/fpdf_edit_create.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 "core/fpdfapi/edit/editint.h"
 
 #include <vector>
 
@@ skipping 42 matching lines @@
       if (pFile->AppendString(" ") < 0) {
         return -1;
       }
       if ((len = pFile->AppendString(pObj->GetString().AsStringC())) < 0) {
         return -1;
       }
       offset += len + 1;
       break;
     case CPDF_Object::STRING: {
       CFX_ByteString str = pObj->GetString();
-      FX_BOOL bHex = pObj->AsString()->IsHex();
+      bool bHex = pObj->AsString()->IsHex();
       if ((len = pFile->AppendString(PDF_EncodeString(str, bHex).AsStringC())) <
           0) {
         return -1;
       }
       offset += len;
       break;
     }
     case CPDF_Object::NAME: {
       if (pFile->AppendString("/") < 0) {
         return -1;
@@ skipping 88 matching lines @@
     case CPDF_Object::STREAM: {
       const CPDF_Stream* p = pObj->AsStream();
       if (PDF_CreatorAppendObject(p->GetDict(), pFile, offset) < 0) {
         return -1;
       }
       if (pFile->AppendString("stream\r\n") < 0) {
         return -1;
       }
       offset += 8;
       CPDF_StreamAcc acc;
-      acc.LoadAllData(p, TRUE);
+      acc.LoadAllData(p, true);
       if (pFile->AppendBlock(acc.GetData(), acc.GetSize()) < 0) {
         return -1;
       }
       offset += acc.GetSize();
       if ((len = pFile->AppendString("\r\nendstream")) < 0) {
         return -1;
       }
       offset += len;
       break;
     }
     default:
-      ASSERT(FALSE);
+      ASSERT(false);
       break;
   }
   return 1;
 }
 
 int32_t PDF_CreatorWriteTrailer(CPDF_Document* pDocument,
                                 CFX_FileBufferArchive* pFile,
                                 CPDF_Array* pIDArray) {
   FX_FILESIZE offset = 0;
   int32_t len = 0;
@@ skipping 183 matching lines @@
     return -1;
   if (pFile->AppendByte(FX_GETBYTEOFFSET0(offset)) < 0)
     return -1;
   if (pFile->AppendByte(0) < 0)
     return -1;
   return 0;
 }
 
 class CPDF_FlateEncoder {
  public:
-  CPDF_FlateEncoder(CPDF_Stream* pStream, FX_BOOL bFlateEncode);
+  CPDF_FlateEncoder(CPDF_Stream* pStream, bool bFlateEncode);
   CPDF_FlateEncoder(const uint8_t* pBuffer,
                     uint32_t size,
                     bool bFlateEncode,
                     bool bXRefStream);
   ~CPDF_FlateEncoder();
 
   void CloneDict();
 
   uint8_t* m_pData;
   uint32_t m_dwSize;
   CPDF_Dictionary* m_pDict;
-  FX_BOOL m_bCloned;
-  FX_BOOL m_bNewData;
+  bool m_bCloned;
+  bool m_bNewData;
   CPDF_StreamAcc m_Acc;
 };
 
 void CPDF_FlateEncoder::CloneDict() {
   if (!m_bCloned) {
     m_pDict = ToDictionary(m_pDict->Clone());
     ASSERT(m_pDict);
-    m_bCloned = TRUE;
+    m_bCloned = true;
   }
 }
 
-CPDF_FlateEncoder::CPDF_FlateEncoder(CPDF_Stream* pStream, FX_BOOL bFlateEncode)
+CPDF_FlateEncoder::CPDF_FlateEncoder(CPDF_Stream* pStream, bool bFlateEncode)
     : m_pData(nullptr),
       m_dwSize(0),
       m_pDict(nullptr),
-      m_bCloned(FALSE),
-      m_bNewData(FALSE) {
-  m_Acc.LoadAllData(pStream, TRUE);
+      m_bCloned(false),
+      m_bNewData(false) {
+  m_Acc.LoadAllData(pStream, true);
   if ((pStream && pStream->GetDict() &&
        pStream->GetDict()->KeyExist("Filter")) ||
       !bFlateEncode) {
     if (pStream->GetDict()->KeyExist("Filter") && !bFlateEncode) {
       CPDF_StreamAcc destAcc;
       destAcc.LoadAllData(pStream);
       m_dwSize = destAcc.GetSize();
       m_pData = (uint8_t*)destAcc.DetachData();
       m_pDict = ToDictionary(pStream->GetDict()->Clone());
       m_pDict->RemoveFor("Filter");
-      m_bNewData = TRUE;
-      m_bCloned = TRUE;
+      m_bNewData = true;
+      m_bCloned = true;
     } else {
       m_pData = (uint8_t*)m_Acc.GetData();
       m_dwSize = m_Acc.GetSize();
       m_pDict = pStream->GetDict();
     }
     return;
   }
 
-  m_bNewData = TRUE;
-  m_bCloned = TRUE;
+  m_bNewData = true;
+  m_bCloned = true;
   // TODO(thestig): Move to Init() and check return value.
   ::FlateEncode(m_Acc.GetData(), m_Acc.GetSize(), &m_pData, &m_dwSize);
   m_pDict = ToDictionary(pStream->GetDict()->Clone());
   m_pDict->SetIntegerFor("Length", m_dwSize);
   m_pDict->SetNameFor("Filter", "FlateDecode");
   m_pDict->RemoveFor("DecodeParms");
 }
 
 CPDF_FlateEncoder::CPDF_FlateEncoder(const uint8_t* pBuffer,
                                      uint32_t size,
                                      bool bFlateEncode,
                                      bool bXRefStream)
     : m_pData(nullptr),
       m_dwSize(0),
       m_pDict(nullptr),
-      m_bCloned(FALSE),
-      m_bNewData(FALSE) {
+      m_bCloned(false),
+      m_bNewData(false) {
   if (!bFlateEncode) {
     m_pData = (uint8_t*)pBuffer;
     m_dwSize = size;
     return;
   }
-  m_bNewData = TRUE;
+  m_bNewData = true;
   // TODO(thestig): Move to Init() and check return value.
   if (bXRefStream)
     ::PngEncode(pBuffer, size, &m_pData, &m_dwSize);
   else
     ::FlateEncode(pBuffer, size, &m_pData, &m_dwSize);
 }
 
 CPDF_FlateEncoder::~CPDF_FlateEncoder() {
   if (m_bCloned && m_pDict)
     m_pDict->Release();
   if (m_bNewData)
     FX_Free(m_pData);
 }
 
 class CPDF_Encryptor {
  public:
   CPDF_Encryptor(CPDF_CryptoHandler* pHandler,
                  int objnum,
                  uint8_t* src_data,
                  uint32_t src_size);
   ~CPDF_Encryptor();
 
   uint8_t* m_pData;
   uint32_t m_dwSize;
-  FX_BOOL m_bNewBuf;
+  bool m_bNewBuf;
 };
 
 CPDF_Encryptor::CPDF_Encryptor(CPDF_CryptoHandler* pHandler,
                                int objnum,
                                uint8_t* src_data,
                                uint32_t src_size)
-    : m_pData(nullptr), m_dwSize(0), m_bNewBuf(FALSE) {
+    : m_pData(nullptr), m_dwSize(0), m_bNewBuf(false) {
   if (src_size == 0)
     return;
 
   if (!pHandler) {
     m_pData = (uint8_t*)src_data;
     m_dwSize = src_size;
     return;
   }
   m_dwSize = pHandler->EncryptGetSize(objnum, 0, src_data, src_size);
   m_pData = FX_Alloc(uint8_t, m_dwSize);
   pHandler->EncryptContent(objnum, 0, src_data, src_size, m_pData, m_dwSize);
-  m_bNewBuf = TRUE;
+  m_bNewBuf = true;
 }
 
 CPDF_Encryptor::~CPDF_Encryptor() {
   if (m_bNewBuf)
     FX_Free(m_pData);
 }
 
 }  // namespace
 
 CPDF_ObjectStream::CPDF_ObjectStream() : m_dwObjNum(0), m_index(0) {}
@@ skipping 85 matching lines @@
   }
   offset += len;
   return ObjOffset;
 }
 
 CPDF_XRefStream::CPDF_XRefStream()
     : m_PrevOffset(0), m_dwTempObjNum(0), m_iSeg(0) {}
 
 CPDF_XRefStream::~CPDF_XRefStream() {}
 
-FX_BOOL CPDF_XRefStream::Start() {
+bool CPDF_XRefStream::Start() {
   m_IndexArray.clear();
   m_Buffer.Clear();
   m_iSeg = 0;
-  return TRUE;
+  return true;
 }
 int32_t CPDF_XRefStream::CompressIndirectObject(uint32_t dwObjNum,
                                                 const CPDF_Object* pObj,
                                                 CPDF_Creator* pCreator) {
   if (!pCreator)
     return 0;
 
   m_ObjStream.CompressIndirectObject(dwObjNum, pObj);
   if (pdfium::CollectionSize<int32_t>(m_ObjStream.m_Items) <
           pCreator->m_ObjectStreamSize &&
@@ skipping 11 matching lines @@
 
   m_ObjStream.CompressIndirectObject(dwObjNum, pBuffer, dwSize);
   if (pdfium::CollectionSize<int32_t>(m_ObjStream.m_Items) <
           pCreator->m_ObjectStreamSize &&
       m_ObjStream.m_Buffer.GetLength() < PDF_OBJECTSTREAM_MAXLENGTH) {
     return 1;
   }
   return EndObjectStream(pCreator);
 }
 
-int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator* pCreator, FX_BOOL bEOF) {
+int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator* pCreator, bool bEOF) {
   FX_FILESIZE objOffset = 0;
   if (bEOF) {
     objOffset = m_ObjStream.End(pCreator);
     if (objOffset < 0) {
       return -1;
     }
   }
   uint32_t& dwObjStmNum = m_ObjStream.m_dwObjNum;
   if (!dwObjStmNum) {
     dwObjStmNum = ++pCreator->m_dwLastObjNum;
@@ skipping 45 matching lines @@
     AppendIndex1(m_Buffer, objOffset);
     m_IndexArray.push_back({dwObjStmNum, 1});
     iSeg += 1;
   }
   m_iSeg = iSeg;
   if (bEOF) {
     m_ObjStream.Start();
   }
   return 1;
 }
-FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator,
-                                            FX_BOOL bEOF) {
+bool CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, bool bEOF) {
   FX_FILESIZE offset_tmp = pCreator->m_Offset;
   uint32_t objnum = ++pCreator->m_dwLastObjNum;
   CFX_FileBufferArchive* pFile = &pCreator->m_File;
-  FX_BOOL bIncremental = (pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
+  bool bIncremental = (pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
   if (bIncremental) {
     AddObjectNumberToIndexArray(objnum);
   } else {
     for (; m_dwTempObjNum < pCreator->m_dwLastObjNum; m_dwTempObjNum++) {
       FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjNum);
       if (offset) {
         AppendIndex1(m_Buffer, *offset);
       } else {
         AppendIndex0(m_Buffer, false);
       }
     }
   }
   AppendIndex1(m_Buffer, offset_tmp);
   FX_FILESIZE& offset = pCreator->m_Offset;
   int32_t len = pFile->AppendDWord(objnum);
   if (len < 0) {
-    return FALSE;
+    return false;
   }
   offset += len;
   if ((len = pFile->AppendString(" 0 obj\r\n<</Type /XRef/W[1 4 2]/Index[")) <
       0) {
-    return FALSE;
+    return false;
   }
   offset += len;
   if (!bIncremental) {
     if ((len = pFile->AppendDWord(0)) < 0) {
-      return FALSE;
+      return false;
     }
     if ((len = pFile->AppendString(" ")) < 0) {
-      return FALSE;
+      return false;
     }
     offset += len + 1;
     if ((len = pFile->AppendDWord(objnum + 1)) < 0) {
-      return FALSE;
+      return false;
     }
     offset += len;
   } else {
     for (const auto& pair : m_IndexArray) {
       if ((len = pFile->AppendDWord(pair.objnum)) < 0) {
-        return FALSE;
+        return false;
       }
       if (pFile->AppendString(" ") < 0) {
-        return FALSE;
+        return false;
       }
       offset += len + 1;
       if ((len = pFile->AppendDWord(pair.count)) < 0) {
-        return FALSE;
+        return false;
       }
       if (pFile->AppendString(" ") < 0) {
-        return FALSE;
+        return false;
       }
       offset += len + 1;
     }
   }
   if (pFile->AppendString("]/Size ") < 0) {
-    return FALSE;
+    return false;
   }
   if ((len = pFile->AppendDWord(objnum + 1)) < 0) {
-    return FALSE;
+    return false;
   }
   offset += len + 7;
   if (m_PrevOffset > 0) {
     if (pFile->AppendString("/Prev ") < 0) {
-      return FALSE;
+      return false;
     }
     FX_CHAR offset_buf[20];
     FXSYS_memset(offset_buf, 0, sizeof(offset_buf));
     FXSYS_i64toa(m_PrevOffset, offset_buf, 10);
     int32_t offset_len = (int32_t)FXSYS_strlen(offset_buf);
     if (pFile->AppendBlock(offset_buf, offset_len) < 0) {
-      return FALSE;
+      return false;
     }
     offset += offset_len + 6;
   }
-  CPDF_FlateEncoder encoder(m_Buffer.GetBuffer(), m_Buffer.GetLength(), TRUE,
-                            TRUE);
+  CPDF_FlateEncoder encoder(m_Buffer.GetBuffer(), m_Buffer.GetLength(), true,
+                            true);
   if (pFile->AppendString("/Filter /FlateDecode") < 0)
-    return FALSE;
+    return false;
 
   offset += 20;
   if ((len = pFile->AppendString("/DecodeParms<</Columns 7/Predictor 12>>")) <
       0) {
-    return FALSE;
+    return false;
   }
 
   offset += len;
   if (pFile->AppendString("/Length ") < 0)
-    return FALSE;
+    return false;
 
   if ((len = pFile->AppendDWord(encoder.m_dwSize)) < 0)
-    return FALSE;
+    return false;
 
   offset += len + 8;
   if (bEOF) {
     if ((len = PDF_CreatorWriteTrailer(pCreator->m_pDocument, pFile,
                                        pCreator->m_pIDArray.get())) < 0) {
-      return FALSE;
+      return false;
     }
     offset += len;
     if (pCreator->m_pEncryptDict) {
       uint32_t dwEncryptObjNum = pCreator->m_pEncryptDict->GetObjNum();
       if (dwEncryptObjNum == 0) {
         dwEncryptObjNum = pCreator->m_dwEncryptObjNum;
       }
       if ((len = PDF_CreatorWriteEncrypt(pCreator->m_pEncryptDict,
                                          dwEncryptObjNum, pFile)) < 0) {
-        return FALSE;
+        return false;
       }
       offset += len;
     }
   }
   if ((len = pFile->AppendString(">>stream\r\n")) < 0) {
-    return FALSE;
+    return false;
   }
   offset += len;
   if (pFile->AppendBlock(encoder.m_pData, encoder.m_dwSize) < 0) {
-    return FALSE;
+    return false;
   }
   if ((len = pFile->AppendString("\r\nendstream\r\nendobj\r\n")) < 0) {
-    return FALSE;
+    return false;
   }
   offset += encoder.m_dwSize + len;
   m_PrevOffset = offset_tmp;
-  return TRUE;
+  return true;
 }
-FX_BOOL CPDF_XRefStream::End(CPDF_Creator* pCreator, FX_BOOL bEOF) {
+bool CPDF_XRefStream::End(CPDF_Creator* pCreator, bool bEOF) {
   if (EndObjectStream(pCreator, bEOF) < 0) {
-    return FALSE;
+    return false;
   }
   return GenerateXRefStream(pCreator, bEOF);
 }
-FX_BOOL CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator) {
+bool CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator) {
   if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) {
     AppendIndex0(m_Buffer, true);
     for (uint32_t i = 1; i < pCreator->m_dwLastObjNum + 1; i++) {
       FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(i);
       if (offset) {
         AppendIndex1(m_Buffer, *offset);
       } else {
         AppendIndex0(m_Buffer, false);
       }
     }
   } else {
     for (const auto& pair : m_IndexArray) {
       for (uint32_t j = pair.objnum; j < pair.objnum + pair.count; ++j)
         AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[j]);
     }
   }
-  return GenerateXRefStream(pCreator, FALSE);
+  return GenerateXRefStream(pCreator, false);
 }
 void CPDF_XRefStream::AddObjectNumberToIndexArray(uint32_t objnum) {
   if (m_IndexArray.empty()) {
     m_IndexArray.push_back({objnum, 1});
     return;
   }
   uint32_t next_objnum = m_IndexArray.back().objnum + m_IndexArray.back().count;
   if (objnum == next_objnum)
     m_IndexArray.back().count += 1;
   else
     m_IndexArray.push_back({objnum, 1});
 }
 
 CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc)
     : m_pDocument(pDoc),
       m_pParser(pDoc->GetParser()),
-      m_bSecurityChanged(FALSE),
+      m_bSecurityChanged(false),
       m_pEncryptDict(m_pParser ? m_pParser->GetEncryptDict() : nullptr),
       m_dwEncryptObjNum(0),
-      m_bEncryptCloned(FALSE),
+      m_bEncryptCloned(false),
       m_pCryptoHandler(m_pParser ? m_pParser->GetCryptoHandler() : nullptr),
-      m_bLocalCryptoHandler(FALSE),
+      m_bLocalCryptoHandler(false),
       m_pMetadata(nullptr),
       m_ObjectStreamSize(200),
       m_dwLastObjNum(m_pDocument->GetLastObjNum()),
       m_Offset(0),
       m_iStage(-1),
       m_dwFlags(0),
       m_Pos(nullptr),
       m_XrefStart(0),
       m_pIDArray(nullptr),
       m_FileVersion(0) {}
@@ skipping 143 matching lines @@
 }
 int32_t CPDF_Creator::WriteIndirectObj(const CPDF_Object* pObj) {
   int32_t iRet = WriteIndirectObjectToStream(pObj);
   if (iRet < 1) {
     return iRet;
   }
   return WriteIndirectObj(pObj->GetObjNum(), pObj);
 }
 int32_t CPDF_Creator::WriteDirectObj(uint32_t objnum,
                                      const CPDF_Object* pObj,
-                                     FX_BOOL bEncrypt) {
+                                     bool bEncrypt) {
   int32_t len = 0;
   if (!pObj) {
     if (m_File.AppendString(" null") < 0) {
       return -1;
     }
     m_Offset += 5;
     return 1;
   }
   switch (pObj->GetType()) {
     case CPDF_Object::NULLOBJ:
       if (m_File.AppendString(" null") < 0) {
         return -1;
       }
       m_Offset += 5;
       break;
     case CPDF_Object::BOOLEAN:
     case CPDF_Object::NUMBER:
       if (m_File.AppendString(" ") < 0) {
         return -1;
       }
       if ((len = m_File.AppendString(pObj->GetString().AsStringC())) < 0) {
         return -1;
       }
       m_Offset += len + 1;
       break;
     case CPDF_Object::STRING: {
       CFX_ByteString str = pObj->GetString();
-      FX_BOOL bHex = pObj->AsString()->IsHex();
+      bool bHex = pObj->AsString()->IsHex();
       if (!m_pCryptoHandler || !bEncrypt) {
         CFX_ByteString content = PDF_EncodeString(str, bHex);
         if ((len = m_File.AppendString(content.AsStringC())) < 0) {
           return -1;
         }
         m_Offset += len;
         break;
       }
       CPDF_Encryptor encryptor(m_pCryptoHandler, objnum, (uint8_t*)str.c_str(),
                                str.GetLength());
       CFX_ByteString content = PDF_EncodeString(
           CFX_ByteString((const FX_CHAR*)encryptor.m_pData, encryptor.m_dwSize),
           bHex);
       if ((len = m_File.AppendString(content.AsStringC())) < 0) {
         return -1;
       }
       m_Offset += len;
       break;
     }
     case CPDF_Object::STREAM: {
       CPDF_FlateEncoder encoder(const_cast<CPDF_Stream*>(pObj->AsStream()),
-                                TRUE);
+                                true);
       CPDF_Encryptor encryptor(m_pCryptoHandler, objnum, encoder.m_pData,
                                encoder.m_dwSize);
       if ((uint32_t)encoder.m_pDict->GetIntegerFor("Length") !=
           encryptor.m_dwSize) {
         encoder.CloneDict();
         encoder.m_pDict->SetIntegerFor("Length", encryptor.m_dwSize);
       }
       if (WriteDirectObj(objnum, encoder.m_pDict) < 0) {
         return -1;
       }
@@ skipping 66 matching lines @@
     case CPDF_Object::DICTIONARY: {
       if (!m_pCryptoHandler || pObj == m_pEncryptDict)
         return PDF_CreatorAppendObject(pObj, &m_File, m_Offset);
       if (m_File.AppendString("<<") < 0)
         return -1;
 
       m_Offset += 2;
       const CPDF_Dictionary* p = pObj->AsDictionary();
       bool bSignDict = p->IsSignatureDict();
       for (const auto& it : *p) {
-        FX_BOOL bSignValue = FALSE;
+        bool bSignValue = false;
         const CFX_ByteString& key = it.first;
         CPDF_Object* pValue = it.second;
         if (m_File.AppendString("/") < 0) {
           return -1;
         }
         if ((len = m_File.AppendString(PDF_NameEncode(key).AsStringC())) < 0) {
           return -1;
         }
         m_Offset += len + 1;
         if (bSignDict && key == "Contents") {
-          bSignValue = TRUE;
+          bSignValue = true;
         }
         if (!pValue->IsInline()) {
           if (m_File.AppendString(" ") < 0) {
             return -1;
           }
           if ((len = m_File.AppendDWord(pValue->GetObjNum())) < 0) {
             return -1;
           }
           if (m_File.AppendString(" 0 R ") < 0) {
             return -1;
@@ skipping 12 matching lines @@
       break;
     }
   }
   return 1;
 }
 int32_t CPDF_Creator::WriteOldIndirectObject(uint32_t objnum) {
   if (m_pParser->IsObjectFreeOrNull(objnum))
     return 0;
 
   m_ObjectOffset[objnum] = m_Offset;
-  FX_BOOL bExistInMap = !!m_pDocument->GetIndirectObject(objnum);
+  bool bExistInMap = !!m_pDocument->GetIndirectObject(objnum);
   const uint8_t object_type = m_pParser->GetObjectType(objnum);
   bool bObjStm = (object_type == 2) && m_pEncryptDict && !m_pXRefStream;
   if (m_pParser->IsVersionUpdated() || m_bSecurityChanged || bExistInMap ||
       bObjStm) {
     CPDF_Object* pObj = m_pDocument->GetOrParseIndirectObject(objnum);
     if (!pObj) {
       m_ObjectOffset[objnum] = 0;
       return 0;
     }
     if (WriteIndirectObj(pObj)) {
@@ skipping 60 matching lines @@
     if (!iRet)
       continue;
 
     if (pPause && pPause->NeedToPauseNow()) {
       m_Pos = (void*)(uintptr_t)(objnum + 1);
       return 1;
     }
   }
   return 0;
 }
-int32_t CPDF_Creator::WriteNewObjs(FX_BOOL bIncremental, IFX_Pause* pPause) {
+int32_t CPDF_Creator::WriteNewObjs(bool bIncremental, IFX_Pause* pPause) {
   int32_t iCount = m_NewObjNumArray.GetSize();
   int32_t index = (int32_t)(uintptr_t)m_Pos;
   while (index < iCount) {
     uint32_t objnum = m_NewObjNumArray.ElementAt(index);
     CPDF_Object* pObj = m_pDocument->GetIndirectObject(objnum);
     if (!pObj) {
       ++index;
       continue;
     }
     m_ObjectOffset[objnum] = m_Offset;
@@ skipping 25 matching lines @@
     j = dwStart;
     while (j <= dwEnd && !m_pParser->IsObjectFreeOrNull(j))
       j++;
 
     m_ObjectOffset.Add(dwStart, j - dwStart);
     dwStart = j;
   }
 }
 
 void CPDF_Creator::InitNewObjNumOffsets() {
-  FX_BOOL bIncremental = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
-  FX_BOOL bNoOriginal = (m_dwFlags & FPDFCREATE_NO_ORIGINAL) != 0;
+  bool bIncremental = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
+  bool bNoOriginal = (m_dwFlags & FPDFCREATE_NO_ORIGINAL) != 0;
   for (const auto& pair : *m_pDocument) {
     const uint32_t objnum = pair.first;
     const CPDF_Object* pObj = pair.second.get();
     if (bIncremental || pObj->GetObjNum() == CPDF_Object::kInvalidObjNum)
       continue;
     if (m_pParser && m_pParser->IsValidObjectNumber(objnum) &&
         m_pParser->GetObjectType(objnum)) {
       continue;
     }
     AppendNewObjNum(objnum);
   }
 
   int32_t iCount = m_NewObjNumArray.GetSize();
   if (iCount == 0)
     return;
 
   int32_t i = 0;
   uint32_t dwStartObjNum = 0;
-  FX_BOOL bCrossRefValid = m_pParser && m_pParser->GetLastXRefOffset() > 0;
+  bool bCrossRefValid = m_pParser && m_pParser->GetLastXRefOffset() > 0;
   while (i < iCount) {
     dwStartObjNum = m_NewObjNumArray.ElementAt(i);
     if ((bIncremental && (bNoOriginal || bCrossRefValid)) ||
         !m_ObjectOffset.GetPtrAt(dwStartObjNum)) {
       break;
     }
     i++;
   }
   if (i >= iCount)
     return;
@@ skipping 183 matching lines @@
     m_iStage = 80;
   }
   return m_iStage;
 }
 int32_t CPDF_Creator::WriteDoc_Stage3(IFX_Pause* pPause) {
   ASSERT(m_iStage >= 80 || m_iStage < 90);
   uint32_t dwLastObjNum = m_dwLastObjNum;
   if (m_iStage == 80) {
     m_XrefStart = m_Offset;
     if (m_dwFlags & FPDFCREATE_OBJECTSTREAM) {
-      m_pXRefStream->End(this, TRUE);
+      m_pXRefStream->End(this, true);
       m_XrefStart = m_pXRefStream->m_PrevOffset;
       m_iStage = 90;
     } else if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 ||
                !m_pParser->IsXRefStream()) {
       if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 ||
           m_pParser->GetLastXRefOffset() == 0) {
         CFX_ByteString str;
         str = m_ObjectOffset.GetPtrAt(1)
                   ? "xref\r\n"
                   : "xref\r\n0 1\r\n0000000000 65535 f\r\n";
@@ skipping 90 matching lines @@
       }
     }
     m_iStage = 90;
   }
   return m_iStage;
 }
 
 int32_t CPDF_Creator::WriteDoc_Stage4(IFX_Pause* pPause) {
   ASSERT(m_iStage >= 90);
   if ((m_dwFlags & FPDFCREATE_OBJECTSTREAM) == 0) {
-    FX_BOOL bXRefStream =
+    bool bXRefStream =
         (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pParser->IsXRefStream();
     if (!bXRefStream) {
       if (m_File.AppendString("trailer\r\n<<") < 0) {
         return -1;
       }
     } else {
       if (m_File.AppendDWord(m_pDocument->GetLastObjNum() + 1) < 0) {
         return -1;
       }
       if (m_File.AppendString(" 0 obj <<") < 0) {
@@ skipping 208 matching lines @@
   m_Offset = 0;
   m_dwLastObjNum = m_pDocument->GetLastObjNum();
   m_ObjectOffset.Clear();
   m_NewObjNumArray.RemoveAll();
   InitID();
   if (flags & FPDFCREATE_PROGRESSIVE)
     return true;
   return Continue(nullptr) > -1;
 }
 
-void CPDF_Creator::InitID(FX_BOOL bDefault) {
+void CPDF_Creator::InitID(bool bDefault) {
   CPDF_Array* pOldIDArray = m_pParser ? m_pParser->GetIDArray() : nullptr;
-  FX_BOOL bNewId = !m_pIDArray;
+  bool bNewId = !m_pIDArray;
   if (bNewId) {
     m_pIDArray.reset(new CPDF_Array);
     CPDF_Object* pID1 = pOldIDArray ? pOldIDArray->GetObjectAt(0) : nullptr;
     if (pID1) {
       m_pIDArray->Add(pID1->Clone());
     } else {
       std::vector<uint8_t> buffer =
           PDF_GenerateFileID((uint32_t)(uintptr_t)this, m_dwLastObjNum);
       CFX_ByteString bsBuffer(buffer.data(), buffer.size());
-      m_pIDArray->Add(new CPDF_String(bsBuffer, TRUE));
+      m_pIDArray->Add(new CPDF_String(bsBuffer, true));
     }
   }
   if (!bDefault) {
     return;
   }
   if (pOldIDArray) {
     CPDF_Object* pID2 = pOldIDArray->GetObjectAt(1);
     if ((m_dwFlags & FPDFCREATE_INCREMENTAL) && m_pEncryptDict && pID2) {
       m_pIDArray->Add(pID2->Clone());
       return;
     }
     std::vector<uint8_t> buffer =
         PDF_GenerateFileID((uint32_t)(uintptr_t)this, m_dwLastObjNum);
     CFX_ByteString bsBuffer(buffer.data(), buffer.size());
-    m_pIDArray->Add(new CPDF_String(bsBuffer, TRUE));
+    m_pIDArray->Add(new CPDF_String(bsBuffer, true));
     return;
   }
   m_pIDArray->Add(m_pIDArray->GetObjectAt(0)->Clone());
   if (m_pEncryptDict && !pOldIDArray && m_pParser && bNewId) {
     if (m_pEncryptDict->GetStringFor("Filter") == "Standard") {
       CFX_ByteString user_pass = m_pParser->GetPassword();
       uint32_t flag = PDF_ENCRYPT_CONTENT;
 
       CPDF_SecurityHandler handler;
       handler.OnCreate(m_pEncryptDict, m_pIDArray.get(), user_pass.raw_str(),
                        user_pass.GetLength(), flag);
       if (m_bLocalCryptoHandler)
         delete m_pCryptoHandler;
       m_pCryptoHandler = new CPDF_CryptoHandler;
       m_pCryptoHandler->Init(m_pEncryptDict, &handler);
-      m_bLocalCryptoHandler = TRUE;
-      m_bSecurityChanged = TRUE;
+      m_bLocalCryptoHandler = true;
+      m_bSecurityChanged = true;
     }
   }
 }
 int32_t CPDF_Creator::Continue(IFX_Pause* pPause) {
   if (m_iStage < 0) {
     return m_iStage;
   }
   int32_t iRet = 0;
   while (m_iStage < 100) {
     if (m_iStage < 20) {
       iRet = WriteDoc_Stage1(pPause);
     } else if (m_iStage < 30) {
       iRet = WriteDoc_Stage2(pPause);
     } else if (m_iStage < 90) {
       iRet = WriteDoc_Stage3(pPause);
     } else {
       iRet = WriteDoc_Stage4(pPause);
     }
     if (iRet < m_iStage) {
       break;
     }
   }
   if (iRet < 1 || m_iStage == 100) {
     m_iStage = -1;
     Clear();
     return iRet > 99 ? 0 : (iRet < 1 ? -1 : iRet);
   }
   return m_iStage;
 }
-FX_BOOL CPDF_Creator::SetFileVersion(int32_t fileVersion) {
+bool CPDF_Creator::SetFileVersion(int32_t fileVersion) {
   if (fileVersion < 10 || fileVersion > 17) {
-    return FALSE;
+    return false;
   }
   m_FileVersion = fileVersion;
-  return TRUE;
+  return true;
 }
 void CPDF_Creator::RemoveSecurity() {
   ResetStandardSecurity();
-  m_bSecurityChanged = TRUE;
+  m_bSecurityChanged = true;
   m_pEncryptDict = nullptr;
   m_pCryptoHandler = nullptr;
 }
 void CPDF_Creator::ResetStandardSecurity() {
   if (!m_bLocalCryptoHandler)
     return;
 
   delete m_pCryptoHandler;
   m_pCryptoHandler = nullptr;
-  m_bLocalCryptoHandler = FALSE;
+  m_bLocalCryptoHandler = false;
 }