FX Bool considered harmful, part 3

core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.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_parser.h"
 #include "../../../include/fxcrt/fx_string.h"
 
 //static
@@ skipping 162 matching lines @@
         case PDFOBJ_NUMBER:
             ((CPDF_Number*)this)->SetString(str);
             return;
         case PDFOBJ_STRING:
             ((CPDF_String*)this)->m_String = str;
             return;
         case PDFOBJ_NAME:
             ((CPDF_Name*)this)->m_Name = str;
             return;
     }
-    ASSERT(FALSE);
+    ASSERT(false);
 }
 int CPDF_Object::GetDirectType() const
 {
     if (m_Type != PDFOBJ_REFERENCE) {
         return m_Type;
     }
     CPDF_Reference* pRef = (CPDF_Reference*)this;
     return pRef->m_pObjList->GetIndirectType(pRef->m_RefObjNum);
 }
-FX_BOOL CPDF_Object::IsIdentical(CPDF_Object* pOther) const
+bool CPDF_Object::IsIdentical(CPDF_Object* pOther) const
 {
     if (this == pOther) {
-        return TRUE;
+        return true;
     }
     if (pOther == NULL) {
-        return FALSE;
+        return false;
     }
     if (pOther->m_Type != m_Type) {
         if (m_Type == PDFOBJ_REFERENCE && GetDirect()) {
             return GetDirect()->IsIdentical(pOther);
         }
         if (pOther->m_Type == PDFOBJ_REFERENCE) {
             return IsIdentical(pOther->GetDirect());
         }
-        return FALSE;
+        return false;
     }
     switch (m_Type) {
         case PDFOBJ_BOOLEAN:
             return (((CPDF_Boolean*)this)->Identical((CPDF_Boolean*)pOther));
         case PDFOBJ_NUMBER:
             return (((CPDF_Number*)this)->Identical((CPDF_Number*)pOther));
         case PDFOBJ_STRING:
             return (((CPDF_String*)this)->Identical((CPDF_String*)pOther));
         case PDFOBJ_NAME:
             return (((CPDF_Name*)this)->Identical((CPDF_Name*)pOther));
         case PDFOBJ_ARRAY:
             return (((CPDF_Array*)this)->Identical((CPDF_Array*)pOther));
         case PDFOBJ_DICTIONARY:
             return (((CPDF_Dictionary*)this)->Identical((CPDF_Dictionary*)pOther));
         case PDFOBJ_NULL:
-            return TRUE;
+            return true;
         case PDFOBJ_STREAM:
             return (((CPDF_Stream*)this)->Identical((CPDF_Stream*)pOther));
         case PDFOBJ_REFERENCE:
             return (((CPDF_Reference*)this)->Identical((CPDF_Reference*)pOther));
     }
-    return FALSE;
+    return false;
 }
 CPDF_Object* CPDF_Object::GetDirect() const
 {
     if (m_Type != PDFOBJ_REFERENCE) {
         return (CPDF_Object*)this;
     }
     CPDF_Reference* pRef = (CPDF_Reference*)(void*)this;
     if (pRef->m_pObjList == NULL) {
         return NULL;
     }
     return pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum);
 }
-CPDF_Object* CPDF_Object::Clone(FX_BOOL bDirect) const
+CPDF_Object* CPDF_Object::Clone(bool bDirect) const
 {
     CFX_MapPtrToPtr visited;
     return CloneInternal(bDirect, &visited);
 }
-CPDF_Object* CPDF_Object::CloneInternal(FX_BOOL bDirect, CFX_MapPtrToPtr* visited) const
+CPDF_Object* CPDF_Object::CloneInternal(bool bDirect, CFX_MapPtrToPtr* visited) const
 {
     switch (m_Type) {
         case PDFOBJ_BOOLEAN:
             return new CPDF_Boolean(((CPDF_Boolean*)this)->m_bValue);
         case PDFOBJ_NUMBER:
             return new CPDF_Number(((CPDF_Number*)this)->m_bInteger, &((CPDF_Number*)this)->m_Integer);
         case PDFOBJ_STRING:
             return new CPDF_String(((CPDF_String*)this)->m_String, ((CPDF_String*)this)->IsHex());
         case PDFOBJ_NAME:
             return new CPDF_Name(((CPDF_Name*)this)->m_Name);
@@ skipping 18 matching lines @@
                     pCopy->m_Map.SetAt(key, value->CloneInternal(bDirect, visited));
                 }
                 return pCopy;
             }
         case PDFOBJ_NULL: {
                 return new CPDF_Null;
             }
         case PDFOBJ_STREAM: {
                 CPDF_Stream* pThis = (CPDF_Stream*)this;
                 CPDF_StreamAcc acc;
-                acc.LoadAllData(pThis, TRUE);
+                acc.LoadAllData(pThis, true);
                 FX_DWORD streamSize = acc.GetSize();
                 CPDF_Dictionary* pDict = pThis->GetDict();
                 if (pDict)
                     pDict = (CPDF_Dictionary*)((CPDF_Object*)pDict)->CloneInternal(bDirect, visited);
                 return new CPDF_Stream(acc.DetachData(), streamSize, pDict);
             }
         case PDFOBJ_REFERENCE: {
                 CPDF_Reference* pRef = (CPDF_Reference*)this;
                 FX_DWORD obj_num = pRef->m_RefObjNum;
                 if (bDirect && !visited->GetValueAt((void*)(uintptr_t)obj_num)) {
                     visited->SetAt((void*)(uintptr_t)obj_num, (void*)1);
                     if (!pRef->GetDirect())
                         return nullptr;
 
-                    return pRef->GetDirect()->CloneInternal(TRUE, visited);
+                    return pRef->GetDirect()->CloneInternal(true, visited);
                 }
                 return new CPDF_Reference(pRef->m_pObjList, obj_num);
             }
     }
     return NULL;
 }
 CPDF_Object* CPDF_Object::CloneRef(CPDF_IndirectObjects* pDoc) const
 {
     if (m_ObjNum) {
         return new CPDF_Reference(pDoc, m_ObjNum);
     }
     return Clone();
 }
 CFX_WideString CPDF_Object::GetUnicodeText(CFX_CharMap* pCharMap) const
 {
     if (m_Type == PDFOBJ_STRING) {
         return PDF_DecodeText(((CPDF_String*)this)->m_String, pCharMap);
     }
     if (m_Type == PDFOBJ_STREAM) {
         CPDF_StreamAcc stream;
-        stream.LoadAllData((CPDF_Stream*)this, FALSE);
+        stream.LoadAllData((CPDF_Stream*)this, false);
         CFX_WideString result = PDF_DecodeText(stream.GetData(), stream.GetSize(), pCharMap);
         return result;
     }
     if (m_Type == PDFOBJ_NAME) {
         return PDF_DecodeText(((CPDF_Name*)this)->m_Name, pCharMap);
     }
     return CFX_WideString();
 }
 void CPDF_Object::SetUnicodeText(const FX_WCHAR* pUnicodes, int len)
 {
     if (m_Type == PDFOBJ_STRING) {
         ((CPDF_String*)this)->m_String = PDF_EncodeText(pUnicodes, len);
     } else if (m_Type == PDFOBJ_STREAM) {
         CFX_ByteString result = PDF_EncodeText(pUnicodes, len);
-        ((CPDF_Stream*)this)->SetData((uint8_t*)result.c_str(), result.GetLength(), FALSE, FALSE);
+        ((CPDF_Stream*)this)->SetData((uint8_t*)result.c_str(), result.GetLength(), false, false);
     }
 }
 
 CPDF_Number::CPDF_Number(int value)
-    : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(TRUE), m_Integer(value) {
+    : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(true), m_Integer(value) {
 }
 
 CPDF_Number::CPDF_Number(FX_FLOAT value)
-    : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(FALSE), m_Float(value) {
+    : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(false), m_Float(value) {
 }
 
-CPDF_Number::CPDF_Number(FX_BOOL bInteger, void* pData)
+CPDF_Number::CPDF_Number(bool bInteger, void* pData)
     : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(bInteger), m_Integer(*(int*)pData) {
 }
 
 CPDF_Number::CPDF_Number(const CFX_ByteStringC& str) : CPDF_Object(PDFOBJ_NUMBER) {
     FX_atonum(str, m_bInteger, &m_Integer);
 }
 
 void CPDF_Number::SetString(const CFX_ByteStringC& str)
 {
     FX_atonum(str, m_bInteger, &m_Integer);
 }
-FX_BOOL CPDF_Number::Identical(CPDF_Number* pOther) const
+bool CPDF_Number::Identical(CPDF_Number* pOther) const
 {
     return m_bInteger == pOther->m_bInteger && m_Integer == pOther->m_Integer;
 }
 CFX_ByteString CPDF_Number::GetString() const
 {
     return m_bInteger ? CFX_ByteString::FormatInteger(m_Integer, FXFORMAT_SIGNED) : CFX_ByteString::FormatFloat(m_Float);
 }
 void CPDF_Number::SetNumber(FX_FLOAT value)
 {
-    m_bInteger = FALSE;
+    m_bInteger = false;
     m_Float = value;
 }
-CPDF_String::CPDF_String(const CFX_WideString& str) : CPDF_Object(PDFOBJ_STRING), m_bHex(FALSE) {
+CPDF_String::CPDF_String(const CFX_WideString& str) : CPDF_Object(PDFOBJ_STRING), m_bHex(false) {
     m_String = PDF_EncodeText(str);
 }
 CPDF_Array::~CPDF_Array()
 {
     int size = m_Objects.GetSize();
     CPDF_Object** pList = (CPDF_Object**)m_Objects.GetData();
     for (int i = 0; i < size; i ++) {
         if (pList[i])
             pList[i]->Release();
     }
@@ skipping 160 matching lines @@
     ASSERT(m_Type == PDFOBJ_ARRAY);
     CPDF_Number* pNumber = new CPDF_Number;
     pNumber->SetNumber(f);
     Add(pNumber);
 }
 void CPDF_Array::AddReference(CPDF_IndirectObjects* pDoc, FX_DWORD objnum)
 {
     ASSERT(m_Type == PDFOBJ_ARRAY);
     Add(new CPDF_Reference(pDoc, objnum));
 }
-FX_BOOL CPDF_Array::Identical(CPDF_Array* pOther) const
+bool CPDF_Array::Identical(CPDF_Array* pOther) const
 {
     if (m_Objects.GetSize() != pOther->m_Objects.GetSize()) {
-        return FALSE;
+        return false;
     }
     for (int i = 0; i < m_Objects.GetSize(); i ++)
         if (!((CPDF_Object*)m_Objects[i])->IsIdentical((CPDF_Object*)pOther->m_Objects[i])) {
-            return FALSE;
+            return false;
         }
-    return TRUE;
+    return true;
 }
 CPDF_Dictionary::~CPDF_Dictionary()
 {
     FX_POSITION pos = m_Map.GetStartPosition();
     while (pos) {
         void* value = m_Map.GetNextValue(pos);
         if (value)
             ((CPDF_Object*)value)->Release();
     }
 }
@@ skipping 94 matching lines @@
 }
 FX_FLOAT CPDF_Dictionary::GetNumber(const CFX_ByteStringC& key) const
 {
     CPDF_Object* p = NULL;
     m_Map.Lookup(key, (void*&)p);
     if (p) {
         return p->GetNumber();
     }
     return 0;
 }
-FX_BOOL CPDF_Dictionary::GetBoolean(const CFX_ByteStringC& key, FX_BOOL bDefault) const
+bool CPDF_Dictionary::GetBoolean(const CFX_ByteStringC& key, bool bDefault) const
 {
     CPDF_Object* p = NULL;
     m_Map.Lookup(key, (void*&)p);
     if (p && p->GetType() == PDFOBJ_BOOLEAN) {
         return p->GetInteger();
     }
     return bDefault;
 }
 CPDF_Dictionary* CPDF_Dictionary::GetDict(const CFX_ByteStringC& key) const
 {
@@ skipping 36 matching lines @@
 }
 CFX_AffineMatrix CPDF_Dictionary::GetMatrix(const CFX_ByteStringC& key) const
 {
     CFX_AffineMatrix matrix;
     CPDF_Array* pArray = GetArray(key);
     if (pArray) {
         matrix = pArray->GetMatrix();
     }
     return matrix;
 }
-FX_BOOL CPDF_Dictionary::KeyExist(const CFX_ByteStringC& key) const
+bool CPDF_Dictionary::KeyExist(const CFX_ByteStringC& key) const
 {
     void* value;
     return m_Map.Lookup(key, value);
 }
 void CPDF_Dictionary::SetAt(const CFX_ByteStringC& key, CPDF_Object* pObj, CPDF_IndirectObjects* pObjs)
 {
     ASSERT(m_Type == PDFOBJ_DICTIONARY);
     CPDF_Object* p = NULL;
     m_Map.Lookup(key, (void*&)p);
     if (p == pObj) {
@@ skipping 31 matching lines @@
 {
     ASSERT(m_Type == PDFOBJ_DICTIONARY);
     CPDF_Object* p = NULL;
     m_Map.Lookup(oldkey, (void*&)p);
     if (p == NULL) {
         return;
     }
     m_Map.RemoveKey(oldkey);
     m_Map.SetAt(newkey, p);
 }
-FX_BOOL CPDF_Dictionary::Identical(CPDF_Dictionary* pOther) const
+bool CPDF_Dictionary::Identical(CPDF_Dictionary* pOther) const
 {
     if (pOther == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_Map.GetCount() != pOther->m_Map.GetCount()) {
-        return FALSE;
+        return false;
     }
     FX_POSITION pos = m_Map.GetStartPosition();
     while (pos) {
         CFX_ByteString key;
         void* value;
         m_Map.GetNextAssoc(pos, key, value);
         if (!value)
-            return FALSE;
+            return false;
         if (!((CPDF_Object*)value)->IsIdentical(pOther->GetElement(key))) {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
 void CPDF_Dictionary::SetAtInteger(const CFX_ByteStringC& key, int i)
 {
     SetAt(key, new CPDF_Number(i));
 }
 void CPDF_Dictionary::SetAtName(const CFX_ByteStringC& key, const CFX_ByteString& name)
 {
     SetAt(key, new CPDF_Name(name));
 }
 void CPDF_Dictionary::SetAtString(const CFX_ByteStringC& key, const CFX_ByteString& str)
 {
     SetAt(key, new CPDF_String(str));
 }
 void CPDF_Dictionary::SetAtReference(const CFX_ByteStringC& key, CPDF_IndirectObjects* pDoc, FX_DWORD objnum)
 {
     SetAt(key, new CPDF_Reference(pDoc, objnum));
 }
 void CPDF_Dictionary::AddReference(const CFX_ByteStringC& key, CPDF_IndirectObjects* pDoc, FX_DWORD objnum)
 {
     AddValue(key, new CPDF_Reference(pDoc, objnum));
 }
 void CPDF_Dictionary::SetAtNumber(const CFX_ByteStringC& key, FX_FLOAT f)
 {
     CPDF_Number* pNumber = new CPDF_Number;
     pNumber->SetNumber(f);
     SetAt(key, pNumber);
 }
-void CPDF_Dictionary::SetAtBoolean(const CFX_ByteStringC& key, FX_BOOL bValue)
+void CPDF_Dictionary::SetAtBoolean(const CFX_ByteStringC& key, bool bValue)
 {
     SetAt(key, new CPDF_Boolean(bValue));
 }
 void CPDF_Dictionary::SetAtRect(const CFX_ByteStringC& key, const CFX_FloatRect& rect)
 {
     CPDF_Array* pArray = new CPDF_Array;
     pArray->AddNumber(rect.left);
     pArray->AddNumber(rect.bottom);
     pArray->AddNumber(rect.right);
     pArray->AddNumber(rect.top);
@@ skipping 51 matching lines @@
     m_GenNum = (FX_DWORD) - 1;
     m_pDataBuf = FX_Alloc(uint8_t, size);
     if (pData) {
         FXSYS_memcpy(m_pDataBuf, pData, size);
     }
     m_dwSize = size;
     if (m_pDict) {
         m_pDict->SetAtInteger(FX_BSTRC("Length"), size);
     }
 }
-void CPDF_Stream::SetData(const uint8_t* pData, FX_DWORD size, FX_BOOL bCompressed, FX_BOOL bKeepBuf)
+void CPDF_Stream::SetData(const uint8_t* pData, FX_DWORD size, bool bCompressed, bool bKeepBuf)
 {
     if (m_GenNum == (FX_DWORD) - 1) {
         if (m_pDataBuf) {
             FX_Free(m_pDataBuf);
         }
     } else {
         m_GenNum = (FX_DWORD) - 1;
         m_pCryptoHandler = NULL;
     }
     if (bKeepBuf) {
         m_pDataBuf = (uint8_t*)pData;
     } else {
         m_pDataBuf = FX_Alloc(uint8_t, size);
         if (pData) {
             FXSYS_memcpy(m_pDataBuf, pData, size);
         }
     }
     m_dwSize = size;
     if (m_pDict == NULL) {
         m_pDict = new CPDF_Dictionary;
     }
     m_pDict->SetAtInteger(FX_BSTRC("Length"), size);
     if (!bCompressed) {
         m_pDict->RemoveAt(FX_BSTRC("Filter"));
         m_pDict->RemoveAt(FX_BSTRC("DecodeParms"));
     }
 }
-FX_BOOL CPDF_Stream::ReadRawData(FX_FILESIZE offset, uint8_t* buf, FX_DWORD size) const
+bool CPDF_Stream::ReadRawData(FX_FILESIZE offset, uint8_t* buf, FX_DWORD size) const
 {
     if ((m_GenNum != (FX_DWORD) - 1) && m_pFile) {
         return m_pFile->ReadBlock(buf, m_FileOffset + offset, size);
     }
     if (m_pDataBuf) {
         FXSYS_memcpy(buf, m_pDataBuf + offset, size);
     }
-    return TRUE;
+    return true;
 }
 void CPDF_Stream::InitStream(IFX_FileRead *pFile, CPDF_Dictionary* pDict)
 {
     InitStream(pDict);
     m_pFile = pFile;
     m_dwSize = (FX_DWORD)pFile->GetSize();
     if (m_pDict) {
         m_pDict->SetAtInteger(FX_BSTRC("Length"), m_dwSize);
     }
 }
-FX_BOOL CPDF_Stream::Identical(CPDF_Stream* pOther) const
+bool CPDF_Stream::Identical(CPDF_Stream* pOther) const
 {
     if (!m_pDict)
-        return pOther->m_pDict ? FALSE : TRUE;
+        return pOther->m_pDict ? false : true;
 
     if (!m_pDict->Identical(pOther->m_pDict)) {
-        return FALSE;
+        return false;
     }
     if (m_dwSize != pOther->m_dwSize) {
-        return FALSE;
+        return false;
     }
     if (m_GenNum != (FX_DWORD) - 1 && pOther->m_GenNum != (FX_DWORD) - 1) {
         if (m_pFile == pOther->m_pFile && m_pFile == NULL) {
-            return TRUE;
+            return true;
         }
         if (!m_pFile || !pOther->m_pFile) {
-            return FALSE;
+            return false;
         }
         uint8_t srcBuf[1024];
         uint8_t destBuf[1024];
         FX_DWORD size = m_dwSize;
         FX_DWORD srcOffset = m_FileOffset;
         FX_DWORD destOffset = pOther->m_FileOffset;
         if (m_pFile == pOther->m_pFile && srcOffset == destOffset) {
-            return TRUE;
+            return true;
         }
         while (size > 0) {
             FX_DWORD actualSize = size > 1024 ? 1024 : size;
             m_pFile->ReadBlock(srcBuf, srcOffset, actualSize);
             pOther->m_pFile->ReadBlock(destBuf, destOffset, actualSize);
             if (FXSYS_memcmp(srcBuf, destBuf, actualSize) != 0) {
-                return FALSE;
+                return false;
             }
             size -= actualSize;
             srcOffset += actualSize;
             destOffset += actualSize;
         }
-        return TRUE;
+        return true;
     }
     if (m_GenNum != (FX_DWORD) - 1 || pOther->m_GenNum != (FX_DWORD) - 1) {
         IFX_FileRead* pFile = NULL;
         uint8_t* pBuf = NULL;
         FX_DWORD offset = 0;
         if (pOther->m_GenNum != (FX_DWORD) - 1) {
             pFile = pOther->m_pFile;
             pBuf = m_pDataBuf;
             offset = pOther->m_FileOffset;
         } else if (m_GenNum != (FX_DWORD) - 1) {
             pFile = m_pFile;
             pBuf = pOther->m_pDataBuf;
             offset = m_FileOffset;
         }
         if (NULL == pBuf) {
-            return FALSE;
+            return false;
         }
         uint8_t srcBuf[1024];
         FX_DWORD size = m_dwSize;
         while (size > 0) {
             FX_DWORD actualSize = std::min(size, 1024U);
             pFile->ReadBlock(srcBuf, offset, actualSize);
             if (FXSYS_memcmp(srcBuf, pBuf, actualSize) != 0) {
-                return FALSE;
+                return false;
             }
             pBuf += actualSize;
             size -= actualSize;
             offset += actualSize;
         }
-        return TRUE;
+        return true;
     }
     return FXSYS_memcmp(m_pDataBuf, pOther->m_pDataBuf, m_dwSize) == 0;
 }
-CPDF_Stream* CPDF_Stream::Clone(FX_BOOL bDirect, FPDF_LPFCloneStreamCallback lpfCallback, void* pUserData) const
+CPDF_Stream* CPDF_Stream::Clone(bool bDirect, FPDF_LPFCloneStreamCallback lpfCallback, void* pUserData) const
 {
     CPDF_Dictionary *pCloneDict = (CPDF_Dictionary*)m_pDict->Clone(bDirect);
     IFX_FileStream *pFS = NULL;
     if (lpfCallback) {
         pFS = lpfCallback((CPDF_Stream*)this, pUserData);
     }
     if (!pFS) {
         CPDF_StreamAcc acc;
-        acc.LoadAllData(this, TRUE);
+        acc.LoadAllData(this, true);
         FX_DWORD streamSize = acc.GetSize();
         return new CPDF_Stream(acc.DetachData(), streamSize, pCloneDict);
     }
     CPDF_Stream* pObj = new CPDF_Stream(NULL, 0, NULL);
-    CPDF_StreamFilter *pSF = GetStreamFilter(TRUE);
+    CPDF_StreamFilter *pSF = GetStreamFilter(true);
     if (pSF) {
         uint8_t* pBuf = FX_Alloc(uint8_t, 4096);
         FX_DWORD dwRead;
         do {
             dwRead = pSF->ReadBlock(pBuf, 4096);
             if (dwRead) {
                 pFS->WriteBlock(pBuf, dwRead);
             }
         } while (dwRead == 4096);
         pFS->Flush();
         FX_Free(pBuf);
         delete pSF;
     }
     pObj->InitStream((IFX_FileRead*)pFS, pCloneDict);
     return pObj;
 }
-extern FX_BOOL PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
+extern bool PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
                               uint8_t*& dest_buf, FX_DWORD& dest_size, CFX_ByteString& ImageEncoding,
-                              CPDF_Dictionary*& pImageParms, FX_DWORD estimated_size, FX_BOOL bImageAcc);
+                              CPDF_Dictionary*& pImageParms, FX_DWORD estimated_size, bool bImageAcc);
 CPDF_StreamAcc::CPDF_StreamAcc()
 {
-    m_bNewBuf = FALSE;
+    m_bNewBuf = false;
     m_pData = NULL;
     m_dwSize = 0;
     m_pImageParam = NULL;
     m_pStream = NULL;
     m_pSrcData = NULL;
 }
-void CPDF_StreamAcc::LoadAllData(const CPDF_Stream* pStream, FX_BOOL bRawAccess, FX_DWORD estimated_size,
-                                 FX_BOOL bImageAcc)
+void CPDF_StreamAcc::LoadAllData(const CPDF_Stream* pStream, bool bRawAccess, FX_DWORD estimated_size,
+                                 bool bImageAcc)
 {
     if (pStream == NULL || pStream->GetType() != PDFOBJ_STREAM) {
         return;
     }
     m_pStream = pStream;
     if (pStream->IsMemoryBased() &&
             (!pStream->GetDict()->KeyExist(FX_BSTRC("Filter")) || bRawAccess)) {
         m_dwSize = pStream->m_dwSize;
         m_pData = (uint8_t*)pStream->m_pDataBuf;
         return;
@@ skipping 23 matching lines @@
         dwDecryptedSize = dest_buf.GetSize();
         dest_buf.DetachBuffer();
     } else {
         pDecryptedData = pSrcData;
         dwDecryptedSize = dwSrcSize;
     }
     if (!pStream->GetDict()->KeyExist(FX_BSTRC("Filter")) || bRawAccess) {
         m_pData = pDecryptedData;
         m_dwSize = dwDecryptedSize;
     } else {
-        FX_BOOL bRet = PDF_DataDecode(pDecryptedData, dwDecryptedSize, m_pStream->GetDict(),
+        bool bRet = PDF_DataDecode(pDecryptedData, dwDecryptedSize, m_pStream->GetDict(),
                                       m_pData, m_dwSize, m_ImageDecoder, m_pImageParam, estimated_size, bImageAcc);
         if (!bRet) {
             m_pData = pDecryptedData;
             m_dwSize = dwDecryptedSize;
         }
     }
     if (pSrcData != pStream->m_pDataBuf && pSrcData != m_pData) {
         FX_Free(pSrcData);
     }
     if (pDecryptedData != pSrcData && pDecryptedData != m_pData) {
@@ skipping 154 matching lines @@
     pObj->m_ObjNum = objnum;
     m_IndirectObjs.SetAt((void*)(uintptr_t)objnum, pObj);
     if (m_LastObjNum < objnum) {
         m_LastObjNum = objnum;
     }
 }
 FX_DWORD CPDF_IndirectObjects::GetLastObjNum() const
 {
     return m_LastObjNum;
 }