Remove struct PARSE_OPTIONS.

core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.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/include/fpdfapi/fpdf_parser.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 278 matching lines @@
   ReleaseEncryptHandler();
   SetEncryptDictionary(NULL);
   if (!m_pTrailer) {
     return PDFPARSE_ERROR_FORMAT;
   }
   CPDF_Object* pEncryptObj = m_pTrailer->GetElement("Encrypt");
   if (pEncryptObj) {
     if (CPDF_Dictionary* pEncryptDict = pEncryptObj->AsDictionary()) {
       SetEncryptDictionary(pEncryptDict);
     } else if (CPDF_Reference* pRef = pEncryptObj->AsReference()) {
-      pEncryptObj =
-          m_pDocument->GetIndirectObject(pRef->GetRefObjNum(), nullptr);
+      pEncryptObj = m_pDocument->GetIndirectObject(pRef->GetRefObjNum());
       if (pEncryptObj)
         SetEncryptDictionary(pEncryptObj->GetDict());
     }
   }
   if (m_bForceUseSecurityHandler) {
     FX_DWORD err = PDFPARSE_ERROR_HANDLER;
     if (!m_pSecurityHandler) {
       return PDFPARSE_ERROR_HANDLER;
     }
     if (!m_pSecurityHandler->OnInit(this, m_pEncryptDict)) {
@@ skipping 471 matching lines @@
                 last_obj = start_pos;
                 void* pResult =
                     FXSYS_bsearch(&obj_pos, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
                                   CompareFileSize);
                 if (!pResult) {
                   m_SortedOffset.Add(obj_pos);
                 }
                 FX_FILESIZE obj_end = 0;
                 CPDF_Object* pObject = ParseIndirectObjectAtByStrict(
-                    m_pDocument, obj_pos, objnum, NULL, &obj_end);
+                    m_pDocument, obj_pos, objnum, &obj_end);
                 if (CPDF_Stream* pStream = ToStream(pObject)) {
                   if (CPDF_Dictionary* pDict = pStream->GetDict()) {
                     if ((pDict->KeyExist("Type")) &&
                         (pDict->GetString("Type") == "XRef" &&
                          pDict->KeyExist("Size"))) {
                       CPDF_Object* pRoot = pDict->GetElement("Root");
                       if (pRoot && pRoot->GetDict() &&
                           pRoot->GetDict()->GetElement("Pages")) {
                         if (m_pTrailer)
                           m_pTrailer->Release();
@@ skipping 39 matching lines @@
               --i;
               status = 0;
               break;
           }
           break;
         case 7:
           if (inside_index == 7) {
             if (PDFCharIsWhitespace(byte) || PDFCharIsDelimiter(byte)) {
               last_trailer = pos + i - 7;
               m_Syntax.RestorePos(pos + i - m_Syntax.m_HeaderOffset);
-              CPDF_Object* pObj =
-                  m_Syntax.GetObject(m_pDocument, 0, 0, nullptr, true);
+              CPDF_Object* pObj = m_Syntax.GetObject(m_pDocument, 0, 0, true);
               if (pObj) {
                 if (!pObj->IsDictionary() && !pObj->AsStream()) {
                   pObj->Release();
                 } else {
                   CPDF_Stream* pStream = pObj->AsStream();
                   if (CPDF_Dictionary* pTrailer =
                           pStream ? pStream->GetDict() : pObj->AsDictionary()) {
                     if (m_pTrailer) {
                       CPDF_Object* pRoot = pTrailer->GetElement("Root");
                       CPDF_Reference* pRef = ToReference(pRoot);
@@ skipping 127 matching lines @@
   void* pResult =
       FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                     sizeof(FX_FILESIZE), CompareFileSize);
   if (!pResult) {
     m_SortedOffset.Add(offset);
   }
   return m_pTrailer && !m_ObjectInfo.empty();
 }
 
 FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE* pos, FX_BOOL bMainXRef) {
-  CPDF_Object* pObject = ParseIndirectObjectAt(m_pDocument, *pos, 0, nullptr);
+  CPDF_Object* pObject = ParseIndirectObjectAt(m_pDocument, *pos, 0);
   if (!pObject)
     return FALSE;
   if (m_pDocument) {
     FX_BOOL bInserted = FALSE;
     CPDF_Dictionary* pDict = m_pDocument->GetRoot();
     if (!pDict || pDict->GetObjNum() != pObject->m_ObjNum) {
       bInserted = m_pDocument->InsertIndirectObject(pObject->m_ObjNum, pObject);
     } else {
       if (pObject->IsStream())
         pObject->Release();
@@ skipping 179 matching lines @@
   m_Syntax.RestorePos(pos);
   const char kFormStream[] = "/Form\0stream";
   const CFX_ByteStringC kFormStreamStr(kFormStream, sizeof(kFormStream) - 1);
   bForm = m_Syntax.SearchMultiWord(kFormStreamStr, TRUE, size) == 0;
   m_Syntax.RestorePos(SavedPos);
   return TRUE;
 }
 
 CPDF_Object* CPDF_Parser::ParseIndirectObject(
     CPDF_IndirectObjectHolder* pObjList,
-    FX_DWORD objnum,
-    PARSE_CONTEXT* pContext) {
+    FX_DWORD objnum) {
   if (!IsValidObjectNumber(objnum))
     return nullptr;
 
   // Prevent circular parsing the same object.
   if (pdfium::ContainsKey(m_ParsingObjNums, objnum))
     return nullptr;
   ScopedSetInsertion<FX_DWORD> local_insert(&m_ParsingObjNums, objnum);
 
   if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) {
     FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
     if (pos <= 0)
       return nullptr;
-    return ParseIndirectObjectAt(pObjList, pos, objnum, pContext);
+    return ParseIndirectObjectAt(pObjList, pos, objnum);
   }
   if (m_V5Type[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));
   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) {
       FX_DWORD thisnum = syntax.GetDirectNum();
       FX_DWORD thisoff = syntax.GetDirectNum();
       m_ObjCache[pObjStream][thisnum] = thisoff;
     }
   }
 
   const auto it = m_ObjCache[pObjStream].find(objnum);
   if (it == m_ObjCache[pObjStream].end())
     return nullptr;
 
   syntax.RestorePos(offset + it->second);
-  return syntax.GetObject(pObjList, 0, 0, pContext, true);
+  return syntax.GetObject(pObjList, 0, 0, true);
 }
 
 CPDF_StreamAcc* CPDF_Parser::GetObjectStream(FX_DWORD objnum) {
   auto it = m_ObjectStreamMap.find(objnum);
   if (it != m_ObjectStreamMap.end())
     return it->second.get();
 
-  const CPDF_Stream* pStream = ToStream(
-      m_pDocument ? m_pDocument->GetIndirectObject(objnum, nullptr) : nullptr);
+  if (!m_pDocument)
+    return nullptr;
+
+  const CPDF_Stream* pStream = ToStream(m_pDocument->GetIndirectObject(objnum));
   if (!pStream)
     return nullptr;
 
   CPDF_StreamAcc* pStreamAcc = new CPDF_StreamAcc;
   pStreamAcc->LoadAllData(pStream);
   m_ObjectStreamMap[objnum].reset(pStreamAcc);
   return pStreamAcc;
 }
 
 FX_FILESIZE CPDF_Parser::GetObjectSize(FX_DWORD objnum) const {
@@ skipping 127 matching lines @@
   size = (FX_DWORD)(nextoff - pos);
   pBuffer = FX_Alloc(uint8_t, size);
   m_Syntax.RestorePos(pos);
   m_Syntax.ReadBlock(pBuffer, size);
   m_Syntax.RestorePos(SavedPos);
 }
 
 CPDF_Object* CPDF_Parser::ParseIndirectObjectAt(
     CPDF_IndirectObjectHolder* pObjList,
     FX_FILESIZE pos,
-    FX_DWORD objnum,
-    PARSE_CONTEXT* pContext) {
+    FX_DWORD objnum) {
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   m_Syntax.RestorePos(pos);
   bool bIsNumber;
   CFX_ByteString word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   FX_FILESIZE objOffset = m_Syntax.SavePos();
   objOffset -= word.GetLength();
   FX_DWORD parser_objnum = FXSYS_atoi(word);
   if (objnum && parser_objnum != objnum) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   FX_DWORD parser_gennum = FXSYS_atoi(word);
   if (m_Syntax.GetKeyword() != "obj") {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
-  CPDF_Object* pObj =
-      m_Syntax.GetObject(pObjList, objnum, parser_gennum, pContext, true);
+  CPDF_Object* pObj = m_Syntax.GetObject(pObjList, objnum, parser_gennum, true);
   m_Syntax.SavePos();
   CFX_ByteString bsWord = m_Syntax.GetKeyword();
   if (bsWord == "endobj") {
     m_Syntax.SavePos();
   }
   m_Syntax.RestorePos(SavedPos);
   if (pObj) {
     if (!objnum)
       pObj->m_ObjNum = parser_objnum;
     pObj->m_GenNum = parser_gennum;
   }
   return pObj;
 }
 CPDF_Object* CPDF_Parser::ParseIndirectObjectAtByStrict(
     CPDF_IndirectObjectHolder* pObjList,
     FX_FILESIZE pos,
     FX_DWORD objnum,
-    PARSE_CONTEXT* pContext,
     FX_FILESIZE* pResultPos) {
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   m_Syntax.RestorePos(pos);
   bool bIsNumber;
   CFX_ByteString word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   FX_DWORD parser_objnum = FXSYS_atoi(word);
   if (objnum && parser_objnum != objnum) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   FX_DWORD gennum = FXSYS_atoi(word);
   if (m_Syntax.GetKeyword() != "obj") {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
-  CPDF_Object* pObj =
-      m_Syntax.GetObjectByStrict(pObjList, objnum, gennum, pContext);
+  CPDF_Object* pObj = m_Syntax.GetObjectByStrict(pObjList, objnum, gennum);
   if (pResultPos) {
     *pResultPos = m_Syntax.m_Pos;
   }
   m_Syntax.RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() {
   if (m_Syntax.GetKeyword() != "trailer")
     return nullptr;
 
   std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
-      m_Syntax.GetObject(m_pDocument, 0, 0, nullptr, true));
+      m_Syntax.GetObject(m_pDocument, 0, 0, true));
   if (!ToDictionary(pObj.get()))
     return nullptr;
   return pObj.release()->AsDictionary();
 }
 
 FX_DWORD CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision) {
   if (!m_pSecurityHandler) {
     return (FX_DWORD)-1;
   }
   FX_DWORD dwPermission = m_pSecurityHandler->GetPermissions();
@@ skipping 32 matching lines @@
   FX_DWORD objnum = FXSYS_atoi(word);
   word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     return FALSE;
   }
   FX_DWORD gennum = FXSYS_atoi(word);
   if (m_Syntax.GetKeyword() != "obj") {
     m_Syntax.RestorePos(SavedPos);
     return FALSE;
   }
-  m_pLinearized = m_Syntax.GetObject(nullptr, objnum, gennum, nullptr, true);
+  m_pLinearized = m_Syntax.GetObject(nullptr, objnum, gennum, true);
   if (!m_pLinearized) {
     return FALSE;
   }
 
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
   if (pDict && pDict->GetElement("Linearized")) {
     m_Syntax.GetNextWord(nullptr);
 
     CPDF_Object* pLen = pDict->GetElement("L");
     if (!pLen) {
@@ skipping 479 matching lines @@
   return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
 }
 
 CFX_ByteString CPDF_SyntaxParser::GetKeyword() {
   return GetNextWord(nullptr);
 }
 
 CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjectHolder* pObjList,
                                           FX_DWORD objnum,
                                           FX_DWORD gennum,
-                                          PARSE_CONTEXT* pContext,
                                           FX_BOOL bDecrypt) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth) {
     return nullptr;
   }
   FX_FILESIZE SavedPos = m_Pos;
   bool bIsNumber;
   CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0) {
     return nullptr;
@@ skipping 26 matching lines @@
   }
   if (word == "<") {
     CFX_ByteString str = ReadHexString();
     if (m_pCryptoHandler && bDecrypt) {
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
     }
     return new CPDF_String(str, TRUE);
   }
   if (word == "[") {
     CPDF_Array* pArray = new CPDF_Array;
-    while (CPDF_Object* pObj =
-               GetObject(pObjList, objnum, gennum, nullptr, true)) {
+    while (CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, true)) {
       pArray->Add(pObj);
     }
     return pArray;
   }
   if (word[0] == '/') {
     return new CPDF_Name(
         PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1)));
   }
   if (word == "<<") {
-    if (pContext)
-      pContext->m_DictStart = SavedPos;
-
     int32_t nKeys = 0;
     FX_FILESIZE dwSignValuePos = 0;
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         new CPDF_Dictionary);
     while (1) {
       CFX_ByteString key = GetNextWord(nullptr);
       if (key.IsEmpty())
         return nullptr;
 
       FX_FILESIZE SavedPos = m_Pos - key.GetLength();
       if (key == ">>")
         break;
 
       if (key == "endobj") {
         m_Pos = SavedPos;
         break;
       }
       if (key[0] != '/')
         continue;
 
       ++nKeys;
       key = PDF_NameDecode(key);
       if (key.IsEmpty())
         continue;
 
       if (key == "/Contents")
         dwSignValuePos = m_Pos;
 
-      CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, nullptr, true);
+      CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, true);
       if (!pObj)
         continue;
 
       CFX_ByteStringC keyNoSlash(key.c_str() + 1, key.GetLength() - 1);
       pDict->SetAt(keyNoSlash, pObj);
     }
 
     // Only when this is a signature dictionary and has contents, we reset the
     // contents to the un-decrypted form.
     if (IsSignatureDict(pDict.get()) && dwSignValuePos) {
       CFX_AutoRestorer<FX_FILESIZE> save_pos(&m_Pos);
       m_Pos = dwSignValuePos;
-      CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, nullptr, FALSE);
-      pDict->SetAt("Contents", pObj);
-    }
-    if (pContext) {
-      pContext->m_DictEnd = m_Pos;
+      pDict->SetAt("Contents", GetObject(pObjList, objnum, gennum, false));
     }
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(nullptr);
     if (nextword != "stream") {
       m_Pos = SavedPos;
       return pDict.release();
     }
-    return ReadStream(pDict.release(), pContext, objnum, gennum);
+    return ReadStream(pDict.release(), objnum, gennum);
   }
   if (word == ">>") {
     m_Pos = SavedPos;
   }
   return nullptr;
 }
 
 CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(
     CPDF_IndirectObjectHolder* pObjList,
     FX_DWORD objnum,
-    FX_DWORD gennum,
-    PARSE_CONTEXT* pContext) {
+    FX_DWORD gennum) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth) {
     return nullptr;
   }
   FX_FILESIZE SavedPos = m_Pos;
   bool bIsNumber;
   CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0) {
     return nullptr;
   }
@@ skipping 23 matching lines @@
   }
   if (word == "<") {
     CFX_ByteString str = ReadHexString();
     if (m_pCryptoHandler)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
     return new CPDF_String(str, TRUE);
   }
   if (word == "[") {
     std::unique_ptr<CPDF_Array, ReleaseDeleter<CPDF_Array>> pArray(
         new CPDF_Array);
-    while (CPDF_Object* pObj =
-               GetObject(pObjList, objnum, gennum, nullptr, true)) {
+    while (CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, true)) {
       pArray->Add(pObj);
     }
     return m_WordBuffer[0] == ']' ? pArray.release() : nullptr;
   }
   if (word[0] == '/') {
     return new CPDF_Name(
         PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1)));
   }
   if (word == "<<") {
-    if (pContext)
-      pContext->m_DictStart = SavedPos;
-
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         new CPDF_Dictionary);
     while (1) {
       FX_FILESIZE SavedPos = m_Pos;
       CFX_ByteString key = GetNextWord(nullptr);
       if (key.IsEmpty())
         return nullptr;
 
       if (key == ">>")
         break;
 
       if (key == "endobj") {
         m_Pos = SavedPos;
         break;
       }
       if (key[0] != '/')
         continue;
 
       key = PDF_NameDecode(key);
       std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> obj(
-          GetObject(pObjList, objnum, gennum, nullptr, true));
+          GetObject(pObjList, objnum, gennum, true));
       if (!obj) {
         uint8_t ch;
         while (GetNextChar(ch) && ch != 0x0A && ch != 0x0D) {
         }
         return nullptr;
       }
       if (key.GetLength() > 1) {
         pDict->SetAt(CFX_ByteStringC(key.c_str() + 1, key.GetLength() - 1),
                      obj.release());
       }
     }
-    if (pContext) {
-      pContext->m_DictEnd = m_Pos;
-    }
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(nullptr);
     if (nextword != "stream") {
       m_Pos = SavedPos;
       return pDict.release();
     }
 
-    return ReadStream(pDict.release(), pContext, objnum, gennum);
+    return ReadStream(pDict.release(), objnum, gennum);
   }
   if (word == ">>") {
     m_Pos = SavedPos;
   }
   return nullptr;
 }
 
 unsigned int CPDF_SyntaxParser::ReadEOLMarkers(FX_FILESIZE pos) {
   unsigned char byte1 = 0;
   unsigned char byte2 = 0;
   GetCharAt(pos, byte1);
   GetCharAt(pos + 1, byte2);
   unsigned int markers = 0;
   if (byte1 == '\r' && byte2 == '\n') {
     markers = 2;
   } else if (byte1 == '\r' || byte1 == '\n') {
     markers = 1;
   }
   return markers;
 }
 CPDF_Stream* CPDF_SyntaxParser::ReadStream(CPDF_Dictionary* pDict,
-                                           PARSE_CONTEXT* pContext,
                                            FX_DWORD objnum,
                                            FX_DWORD gennum) {
   CPDF_Object* pLenObj = pDict->GetElement("Length");
   FX_FILESIZE len = -1;
   CPDF_Reference* pLenObjRef = ToReference(pLenObj);
 
   bool differingObjNum = !pLenObjRef || (pLenObjRef->GetObjList() &&
                                          pLenObjRef->GetRefObjNum() != objnum);
   if (pLenObj && differingObjNum)
     len = pLenObj->GetInteger();
 
   // Locate the start of stream.
   ToNextLine();
   FX_FILESIZE streamStartPos = m_Pos;
-  if (pContext) {
-    pContext->m_DataStart = streamStartPos;
-  }
-
   const CFX_ByteStringC kEndStreamStr("endstream");
   const CFX_ByteStringC kEndObjStr("endobj");
   CPDF_CryptoHandler* pCryptoHandler =
       objnum == (FX_DWORD)m_MetadataObjnum ? nullptr : m_pCryptoHandler.get();
   if (!pCryptoHandler) {
     FX_BOOL bSearchForKeyword = TRUE;
     if (len >= 0) {
       pdfium::base::CheckedNumeric<FX_FILESIZE> pos = m_Pos;
       pos += len;
       if (pos.IsValid() && pos.ValueOrDie() < m_FileLen) {
@@ skipping 89 matching lines @@
       void* context = pCryptoHandler->DecryptStart(objnum, gennum);
       pCryptoHandler->DecryptStream(context, pData, len, dest_buf);
       pCryptoHandler->DecryptFinish(context, dest_buf);
       FX_Free(pData);
       pData = dest_buf.GetBuffer();
       len = dest_buf.GetSize();
       dest_buf.DetachBuffer();
     }
   }
   CPDF_Stream* pStream = new CPDF_Stream(pData, len, pDict);
-  if (pContext) {
-    pContext->m_DataEnd = pContext->m_DataStart + len;
-  }
   streamStartPos = m_Pos;
   FXSYS_memset(m_WordBuffer, 0, kEndObjStr.GetLength() + 1);
   GetNextWordInternal(nullptr);
   int numMarkers = ReadEOLMarkers(m_Pos);
   if (m_WordSize == kEndObjStr.GetLength() && numMarkers != 0 &&
       FXSYS_memcmp(m_WordBuffer, kEndObjStr.GetPtr(), kEndObjStr.GetLength()) ==
           0) {
     m_Pos = streamStartPos;
   }
   return pStream;
@@ skipping 573 matching lines @@
         FX_DWORD size = GetObjectSize(dwNum, offset);
         if (size == 0 || offset < 0 || offset >= m_dwFileLen) {
           break;
         }
         if (!IsDataAvail(offset, size, pHints)) {
           ret_array.Add(pObj);
           count++;
         } else if (!pdfium::ContainsKey(m_ObjectSet, dwNum)) {
           m_ObjectSet.insert(dwNum);
           CPDF_Object* pReferred =
-              m_pDocument->GetIndirectObject(pRef->GetRefObjNum(), nullptr);
+              m_pDocument->GetIndirectObject(pRef->GetRefObjNum());
           if (pReferred) {
             new_obj_array.Add(pReferred);
           }
         }
       } break;
     }
   }
   if (count > 0) {
     int32_t iSize = new_obj_array.GetSize();
     for (i = 0; i < iSize; ++i) {
@@ skipping 178 matching lines @@
     pParser = (CPDF_Parser*)(m_pDocument->GetParser());
   } else {
     size = (FX_DWORD)m_parser.GetObjectSize(objnum);
     offset = m_parser.GetObjectOffset(objnum);
     pParser = &m_parser;
   }
   if (!IsDataAvail(offset, size, pHints)) {
     return nullptr;
   }
   if (pParser) {
-    pRet = pParser->ParseIndirectObject(NULL, objnum, NULL);
+    pRet = pParser->ParseIndirectObject(nullptr, objnum);
   }
-
   if (!pRet && pExistInFile) {
     *pExistInFile = FALSE;
   }
-
   return pRet;
 }
 
 FX_BOOL CPDF_DataAvail::CheckInfo(IFX_DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   CPDF_Object* pInfo = GetObject(m_dwInfoObjNum, pHints, &bExist);
   if (!bExist) {
     if (m_bHaveAcroForm) {
       m_docStatus = PDF_DATAAVAIL_ACROFORM;
     } else {
@@ skipping 356 matching lines @@
   word = m_syntaxParser.GetNextWord(&bIsNumber);
   if (!bIsNumber)
     return nullptr;
 
   FX_DWORD gennum = FXSYS_atoi(word);
   if (m_syntaxParser.GetKeyword() != "obj") {
     m_syntaxParser.RestorePos(SavedPos);
     return nullptr;
   }
   CPDF_Object* pObj =
-      m_syntaxParser.GetObject(pObjList, parser_objnum, gennum, nullptr, true);
+      m_syntaxParser.GetObject(pObjList, parser_objnum, gennum, true);
   m_syntaxParser.RestorePos(SavedPos);
   return pObj;
 }
 IPDF_DataAvail::DocLinearizationStatus CPDF_DataAvail::IsLinearizedPDF() {
   FX_DWORD req_size = 1024;
   if (!m_pFileAvail->IsDataAvail(0, req_size)) {
     return LinearizationUnknown;
   }
   if (!m_pFileRead) {
     return NotLinearized;
@@ skipping 97 matching lines @@
     uint8_t* pBuf = buf.GetBuffer();
     m_pFileRead->ReadBlock(pBuf, m_dwCurrentXRefSteam, iSize);
     ScopedFileStream file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
     m_parser.m_Syntax.InitParser(file.get(), 0);
     bool bNumber;
     CFX_ByteString objnum = m_parser.m_Syntax.GetNextWord(&bNumber);
     if (!bNumber)
       return -1;
 
     FX_DWORD objNum = FXSYS_atoi(objnum);
-    CPDF_Object* pObj = m_parser.ParseIndirectObjectAt(NULL, 0, objNum, NULL);
+    CPDF_Object* pObj = m_parser.ParseIndirectObjectAt(nullptr, 0, objNum);
     if (!pObj) {
       m_Pos += m_parser.m_Syntax.SavePos();
       return 0;
     }
     CPDF_Dictionary* pDict = pObj->GetDict();
     CPDF_Name* pName = ToName(pDict ? pDict->GetElement("Type") : nullptr);
     if (pName) {
       if (pName->GetString() == "XRef") {
         m_Pos += m_parser.m_Syntax.SavePos();
         xref_offset = pObj->GetDict()->GetInteger("Prev");
@@ skipping 209 matching lines @@
     if (!pBuf) {
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return FALSE;
     }
     if (!m_pFileRead->ReadBlock(pBuf, m_dwTrailerOffset, iSize)) {
       return FALSE;
     }
     ScopedFileStream file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
     m_syntaxParser.InitParser(file.get(), 0);
     std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pTrailer(
-        m_syntaxParser.GetObject(nullptr, 0, 0, nullptr, true));
+        m_syntaxParser.GetObject(nullptr, 0, 0, true));
     if (!pTrailer) {
       m_Pos += m_syntaxParser.SavePos();
       pHints->AddSegment(m_Pos, iTrailerSize);
       return FALSE;
     }
     if (!pTrailer->IsDictionary())
       return FALSE;
 
     CPDF_Dictionary* pTrailerDict = pTrailer->GetDict();
     CPDF_Object* pEncrypt = pTrailerDict->GetElement("Encrypt");
@@ skipping 970 matching lines @@
   if (!m_pLinearizedDict)
     return -1;
   CPDF_Array* pRange = m_pLinearizedDict->GetArray("H");
   if (!pRange)
     return -1;
   CPDF_Object* pStreamLen = pRange->GetElementValue(1);
   if (!pStreamLen)
     return -1;
   return pStreamLen->GetInteger();
 }