Convert CPDF_Parser::m_CrossRef to a std::map.

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 "parser_int.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_page.h"
 #include "core/include/fpdfapi/fpdf_parser.h"
 #include "core/include/fxcrt/fx_ext.h"
 #include "core/include/fxcrt/fx_safe_types.h"
 #include "core/src/fpdfapi/fpdf_page/pageint.h"
 #include "third_party/base/nonstd_unique_ptr.h"
 #include "third_party/base/stl_util.h"
 
 namespace {
 
+const int32_t kMaxRef = 1048576;

[Wei Li, 2015/12/21 18:06:46]

Maybe still write as 1<<20 or put in the comment to help readers know how you
get this number.

[Lei Zhang, 2015/12/21 19:40:04]

Actually, do you think we should leave this constant at this value or bump it
up? In theory, can't a valid PDF file have a xref section with a size that's
bigger than this? e.g.

xref
0 1
NNNNNNNNNN GGGGG n
1 0
NNNNNNNNNN GGGGG n
...

Each subsection is ~29 bytes, and there's 65536 possible object numbers = ~1.9
million bytes.

[Wei Li, 2015/12/21 21:45:04]

Isn't the theoretical bound of max ref num 10<<10 since it can have 10 digits?
But considering the size of a pdf file, this estimate seems not bad. I am fine
with either way as long as we have a comment here that we can check later.

+
 struct SearchTagRecord {
   const char* m_pTag;
   FX_DWORD m_Len;
   FX_DWORD m_Offset;
 };
 
 int CompareFileSize(const void* p1, const void* p2) {
   return *(FX_FILESIZE*)p1 - *(FX_FILESIZE*)p2;
 }
 
@@ skipping 75 matching lines @@
   m_pLinearized = NULL;
   m_dwFirstPageNo = 0;
   m_dwXrefStartObjNum = 0;
   m_bOwnFileRead = TRUE;
   m_FileVersion = 0;
   m_bForceUseSecurityHandler = FALSE;
 }
 CPDF_Parser::~CPDF_Parser() {
   CloseParser(FALSE);
 }
-FX_DWORD CPDF_Parser::GetLastObjNum() {
-  FX_DWORD dwSize = m_CrossRef.GetSize();
-  return dwSize ? dwSize - 1 : 0;
+
+FX_DWORD CPDF_Parser::GetLastObjNum() const {
+  return m_ObjectInfo.empty() ? 0 : m_ObjectInfo.rbegin()->first;
 }
+
+bool CPDF_Parser::IsValidObjectNumber(FX_DWORD objnum) const {
+  return !m_ObjectInfo.empty() && objnum <= m_ObjectInfo.rbegin()->first;
+}
+
 void CPDF_Parser::SetEncryptDictionary(CPDF_Dictionary* pDict) {
   m_pEncryptDict = pDict;
 }
 void CPDF_Parser::CloseParser(FX_BOOL bReParse) {
   m_bVersionUpdated = FALSE;
   if (!bReParse) {
     delete m_pDocument;
     m_pDocument = NULL;
   }
   if (m_pTrailer) {
@@ skipping 10 matching lines @@
   while (pos) {
     void* objnum;
     CPDF_StreamAcc* pStream;
     m_ObjectStreamMap.GetNextAssoc(pos, objnum, (void*&)pStream);
     delete pStream;
   }
   m_ObjectStreamMap.RemoveAll();
   m_ObjCache.clear();
 
   m_SortedOffset.RemoveAll();
-  m_CrossRef.RemoveAll();
+  m_ObjectInfo.clear();
   m_V5Type.RemoveAll();
   m_ObjVersion.RemoveAll();
   int32_t iLen = m_Trailers.GetSize();
   for (int32_t i = 0; i < iLen; ++i) {
     if (CPDF_Dictionary* trailer = m_Trailers.GetAt(i))
       trailer->Release();
   }
   m_Trailers.RemoveAll();
   if (m_pLinearized) {
     m_pLinearized->Release();
@@ skipping 160 matching lines @@
   }
   return PDFPARSE_ERROR_SUCCESS;
 }
 void CPDF_Parser::ReleaseEncryptHandler() {
   m_Syntax.m_pCryptoHandler.reset();
   if (!m_bForceUseSecurityHandler) {
     m_pSecurityHandler.reset();
   }
 }
 FX_FILESIZE CPDF_Parser::GetObjectOffset(FX_DWORD objnum) {
-  if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) {
+  if (!IsValidObjectNumber(objnum))
     return 0;
-  }
-  if (m_V5Type[objnum] == 1) {
-    return m_CrossRef[objnum];
-  }
+
+  if (m_V5Type[objnum] == 1)
+    return m_ObjectInfo[objnum].pos;
+
   if (m_V5Type[objnum] == 2) {
-    return m_CrossRef[(int32_t)m_CrossRef[objnum]];
+    FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
+    return m_ObjectInfo[pos].pos;
   }
   return 0;
 }
 
 FX_BOOL CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos) {
   if (!LoadCrossRefV4(xrefpos, 0, TRUE)) {
     return FALSE;
   }
   m_pTrailer = LoadTrailerV4();
   if (!m_pTrailer) {
     return FALSE;
   }
   int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
-  if (xrefsize <= 0 || xrefsize > (1 << 20)) {
+  if (xrefsize <= 0 || xrefsize > kMaxRef) {
     return FALSE;
   }
-  m_CrossRef.SetSize(xrefsize);
+  m_ObjectInfo[0].pos = 0;
   m_V5Type.SetSize(xrefsize);
   CFX_FileSizeArray CrossRefList, XRefStreamList;
   CrossRefList.Add(xrefpos);
   XRefStreamList.Add(GetDirectInteger(m_pTrailer, "XRefStm"));
   if (!CheckDirectType(m_pTrailer, "Prev", PDFOBJ_NUMBER)) {
     return FALSE;
   }
   FX_FILESIZE newxrefpos = GetDirectInteger(m_pTrailer, "Prev");
   if (newxrefpos == xrefpos) {
     return FALSE;
@@ skipping 82 matching lines @@
     if ((FX_FILESIZE)(dwStartPos + dwReadSize) > m_Syntax.m_FileLen) {
       return FALSE;
     }
     if (!m_Syntax.ReadBlock(reinterpret_cast<uint8_t*>(pBuf), dwReadSize)) {
       return FALSE;
     }
     for (int32_t i = 0; i < block_size; i++) {
       FX_DWORD objnum = start_objnum + block * 1024 + i;
       char* pEntry = pBuf + i * recordsize;
       if (pEntry[17] == 'f') {
-        m_CrossRef.SetAtGrow(objnum, 0);
+        m_ObjectInfo[objnum].pos = 0;
         m_V5Type.SetAtGrow(objnum, 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;
           }
         }
-        m_CrossRef.SetAtGrow(objnum, offset);
+        m_ObjectInfo[objnum].pos = offset;
         int32_t version = FXSYS_atoi(pEntry + 11);
         if (version >= 1) {
           m_bVersionUpdated = TRUE;
         }
         m_ObjVersion.SetAtGrow(objnum, version);
-        if (m_CrossRef[objnum] < m_Syntax.m_FileLen) {
+        if (m_ObjectInfo[objnum].pos < m_Syntax.m_FileLen) {
           void* pResult = FXSYS_bsearch(
-              &m_CrossRef[objnum], m_SortedOffset.GetData(),
+              &m_ObjectInfo[objnum].pos, m_SortedOffset.GetData(),
               m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), CompareFileSize);
           if (!pResult) {
-            m_SortedOffset.Add(m_CrossRef[objnum]);
+            m_SortedOffset.Add(m_ObjectInfo[objnum].pos);
           }
         }
         m_V5Type.SetAtGrow(objnum, 1);
       }
     }
   }
   m_Syntax.RestorePos(SavedPos + count * recordsize);
   return TRUE;
 }
 
@@ skipping 20 matching lines @@
     FX_BOOL bIsNumber;
     CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
     if (word.IsEmpty())
       return false;
 
     if (!bIsNumber) {
       m_Syntax.RestorePos(SavedPos);
       break;
     }
     FX_DWORD start_objnum = FXSYS_atoi(word);
-    if (start_objnum >= (1 << 20))
+    if (start_objnum >= kMaxRef)
       return false;
 
     FX_DWORD count = m_Syntax.GetDirectNum();
     m_Syntax.ToNextWord();
     SavedPos = m_Syntax.SavePos();
     const int32_t recordsize = 20;
     m_dwXrefStartObjNum = start_objnum;
     if (!bSkip) {
       std::vector<char> buf(1024 * recordsize + 1);
       char* pBuf = pdfium::vector_as_array(&buf);
       pBuf[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;
         m_Syntax.ReadBlock(reinterpret_cast<uint8_t*>(pBuf),
                            block_size * recordsize);
         for (int32_t i = 0; i < block_size; i++) {
           FX_DWORD objnum = start_objnum + block * 1024 + i;
           char* pEntry = pBuf + i * recordsize;
           if (pEntry[17] == 'f') {
-            m_CrossRef.SetAtGrow(objnum, 0);
+            m_ObjectInfo[objnum].pos = 0;
             m_V5Type.SetAtGrow(objnum, 0);
           } else {
             FX_FILESIZE offset = (FX_FILESIZE)FXSYS_atoi64(pEntry);
             if (offset == 0) {
               for (int32_t c = 0; c < 10; c++) {
                 if (!std::isdigit(pEntry[c]))
                   return false;
               }
             }
-            m_CrossRef.SetAtGrow(objnum, offset);
+            m_ObjectInfo[objnum].pos = offset;
             int32_t version = FXSYS_atoi(pEntry + 11);
             if (version >= 1) {
               m_bVersionUpdated = TRUE;
             }
             m_ObjVersion.SetAtGrow(objnum, version);
-            if (m_CrossRef[objnum] < m_Syntax.m_FileLen &&
-                !FindPosInOffsets(m_CrossRef[objnum])) {
-              m_SortedOffset.Add(m_CrossRef[objnum]);
+            if (m_ObjectInfo[objnum].pos < m_Syntax.m_FileLen &&
+                !FindPosInOffsets(m_ObjectInfo[objnum].pos)) {
+              m_SortedOffset.Add(m_ObjectInfo[objnum].pos);
             }
             m_V5Type.SetAtGrow(objnum, 1);
           }
         }
       }
     }
     m_Syntax.RestorePos(SavedPos + count * recordsize);
   }
   return !streampos || LoadCrossRefV5(&streampos, FALSE);
 }
@@ skipping 12 matching lines @@
     if (seen_xrefpos.find(xrefpos) != seen_xrefpos.end()) {
       return FALSE;
     }
   }
   m_ObjectStreamMap.InitHashTable(101, FALSE);
   m_bXRefStream = TRUE;
   return TRUE;
 }
 
 FX_BOOL CPDF_Parser::RebuildCrossRef() {
-  m_CrossRef.RemoveAll();
+  m_ObjectInfo.clear();
   m_V5Type.RemoveAll();
   m_SortedOffset.RemoveAll();
   m_ObjVersion.RemoveAll();
   if (m_pTrailer) {
     m_pTrailer->Release();
     m_pTrailer = NULL;
   }
   int32_t status = 0;
   int32_t inside_index = 0;
   FX_DWORD objnum = 0, gennum = 0;
@@ skipping 181 matching lines @@
                 } else {
                   offset += 3;
                 }
                 FX_FILESIZE nLen = obj_end - obj_pos - offset;
                 if ((FX_DWORD)nLen > size - i) {
                   pos = obj_end + m_Syntax.m_HeaderOffset;
                   bOverFlow = TRUE;
                 } else {
                   i += (FX_DWORD)nLen;
                 }
-                if (m_CrossRef.GetSize() > (int32_t)objnum &&
-                    m_CrossRef[objnum]) {
+                if (!m_ObjectInfo.empty() && IsValidObjectNumber(objnum) &&
+                    m_ObjectInfo[objnum].pos) {
                   if (pObject) {
                     FX_DWORD oldgen = m_ObjVersion.GetAt(objnum);
-                    m_CrossRef[objnum] = obj_pos;
+                    m_ObjectInfo[objnum].pos = obj_pos;
                     m_ObjVersion.SetAt(objnum, (int16_t)gennum);
                     if (oldgen != gennum) {
                       m_bVersionUpdated = TRUE;
                     }
                   }
                 } else {
-                  m_CrossRef.SetAtGrow(objnum, obj_pos);
+                  m_ObjectInfo[objnum].pos = obj_pos;
                   m_V5Type.SetAtGrow(objnum, 1);
                   m_ObjVersion.SetAtGrow(objnum, (int16_t)gennum);
                 }
                 if (pObject) {
                   pObject->Release();
                 }
               }
               --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, 0);
               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);
                       if (!pRoot ||
-                          (pRef &&
-                           (FX_DWORD)m_CrossRef.GetSize() >
-                               pRef->GetRefObjNum() &&
-                           m_CrossRef.GetAt(pRef->GetRefObjNum()) != 0)) {
+                          (pRef && IsValidObjectNumber(pRef->GetRefObjNum()) &&
+                           m_ObjectInfo[pRef->GetRefObjNum()].pos != 0)) {
                         FX_POSITION pos = pTrailer->GetStartPos();
                         while (pos) {
                           CFX_ByteString key;
                           CPDF_Object* pElement =
                               pTrailer->GetNextElement(pos, key);
                           FX_DWORD dwObjNum =
                               pElement ? pElement->GetObjNum() : 0;
                           if (dwObjNum) {
                             m_pTrailer->SetAtReference(key, m_pDocument,
                                                        dwObjNum);
@@ skipping 105 matching lines @@
     last_trailer = m_Syntax.m_FileLen;
   }
   FX_FILESIZE offset = last_trailer - m_Syntax.m_HeaderOffset;
   void* pResult =
       FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                     sizeof(FX_FILESIZE), CompareFileSize);
   if (!pResult) {
     m_SortedOffset.Add(offset);
   }
   FX_Free(buffer);
-  return m_pTrailer && m_CrossRef.GetSize() > 0;
+  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);
   if (!pObject)
     return FALSE;
   if (m_pDocument) {
     FX_BOOL bInserted = FALSE;
     CPDF_Dictionary* pDict = m_pDocument->GetRoot();
     if (!pDict || pDict->GetObjNum() != pObject->m_ObjNum) {
@@ skipping 11 matching lines @@
     return FALSE;
 
   *pos = pStream->GetDict()->GetInteger("Prev");
   int32_t size = pStream->GetDict()->GetInteger("Size");
   if (size < 0) {
     pStream->Release();
     return FALSE;
   }
   if (bMainXRef) {
     m_pTrailer = ToDictionary(pStream->GetDict()->Clone());
-    m_CrossRef.SetSize(size);
+    m_ObjectInfo[0].pos = 0;
     if (m_V5Type.SetSize(size)) {
       FXSYS_memset(m_V5Type.GetData(), 0, size);
     }
   } else {
     m_Trailers.Add(ToDictionary(pStream->GetDict()->Clone()));
   }
   std::vector<std::pair<int32_t, int32_t> > arrIndex;
   CPDF_Array* pArray = pStream->GetDict()->GetArray("Index");
   if (pArray) {
     FX_DWORD nPairSize = pArray->GetCount() / 2;
@@ skipping 59 matching lines @@
     }
     for (FX_DWORD j = 0; j < count; j++) {
       int32_t type = 1;
       const uint8_t* entrystart = segstart + j * totalWidth;
       if (WidthArray[0]) {
         type = GetVarInt(entrystart, WidthArray[0]);
       }
       if (m_V5Type[startnum + j] == 255) {
         FX_FILESIZE offset =
             GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
-        m_CrossRef[startnum + j] = offset;
+        m_ObjectInfo[startnum + j].pos = offset;
         void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                       m_SortedOffset.GetSize(),
                                       sizeof(FX_FILESIZE), CompareFileSize);
         if (!pResult) {
           m_SortedOffset.Add(offset);
         }
         continue;
       }
       if (m_V5Type[startnum + j]) {
         continue;
       }
       m_V5Type[startnum + j] = type;
       if (type == 0) {
-        m_CrossRef[startnum + j] = 0;
+        m_ObjectInfo[startnum + j].pos = 0;
       } else {
         FX_FILESIZE offset =
             GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
-        m_CrossRef[startnum + j] = offset;
+        m_ObjectInfo[startnum + j].pos = offset;
         if (type == 1) {
           void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                         m_SortedOffset.GetSize(),
                                         sizeof(FX_FILESIZE), CompareFileSize);
           if (!pResult) {
             m_SortedOffset.Add(offset);
           }
         } else {
           if (offset < 0 || offset >= m_V5Type.GetSize()) {
             pStream->Release();
@@ skipping 24 matching lines @@
       ToReference(m_pTrailer ? m_pTrailer->GetElement("Root") : nullptr);
   return pRef ? pRef->GetRefObjNum() : 0;
 }
 FX_DWORD CPDF_Parser::GetInfoObjNum() {
   CPDF_Reference* pRef =
       ToReference(m_pTrailer ? m_pTrailer->GetElement("Info") : nullptr);
   return pRef ? pRef->GetRefObjNum() : 0;
 }
 FX_BOOL CPDF_Parser::IsFormStream(FX_DWORD objnum, FX_BOOL& bForm) {
   bForm = FALSE;
-  if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) {
+  if (!IsValidObjectNumber(objnum))
     return TRUE;
-  }
-  if (m_V5Type[objnum] == 0) {
+  if (m_V5Type[objnum] == 0)
     return TRUE;
-  }
-  if (m_V5Type[objnum] == 2) {
+  if (m_V5Type[objnum] == 2)
     return TRUE;
-  }
-  FX_FILESIZE pos = m_CrossRef[objnum];
+  FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
   void* pResult =
       FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                     sizeof(FX_FILESIZE), CompareFileSize);
   if (!pResult) {
     return TRUE;
   }
   if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() ==
       m_SortedOffset.GetSize() - 1) {
     return FALSE;
   }
   FX_FILESIZE size = ((FX_FILESIZE*)pResult)[1] - pos;
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   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_IndirectObjects* pObjList,
                                               FX_DWORD objnum,
                                               PARSE_CONTEXT* pContext) {
-  if (objnum >= (FX_DWORD)m_CrossRef.GetSize())
+  if (!IsValidObjectNumber(objnum))
     return nullptr;
 
   if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) {
-    FX_FILESIZE pos = m_CrossRef[objnum];
+    FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
     if (pos <= 0)
       return nullptr;
     return ParseIndirectObjectAt(pObjList, pos, objnum, pContext);
   }
   if (m_V5Type[objnum] != 2)
     return nullptr;
 
-  CPDF_StreamAcc* pObjStream = GetObjectStream((FX_DWORD)m_CrossRef[objnum]);
+  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.
@@ skipping 22 matching lines @@
       ToStream(m_pDocument ? m_pDocument->GetIndirectObject(objnum) : nullptr);
   if (!pStream)
     return nullptr;
 
   pStreamAcc = new CPDF_StreamAcc;
   pStreamAcc->LoadAllData(pStream);
   m_ObjectStreamMap.SetAt((void*)(uintptr_t)objnum, pStreamAcc);
   return pStreamAcc;
 }
 FX_FILESIZE CPDF_Parser::GetObjectSize(FX_DWORD objnum) {
-  if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) {
+  if (!IsValidObjectNumber(objnum))
     return 0;
-  }
+
   if (m_V5Type[objnum] == 2) {
-    objnum = (FX_DWORD)m_CrossRef[objnum];
+    objnum = m_ObjectInfo[objnum].pos;
   }
   if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) {
-    FX_FILESIZE offset = m_CrossRef[objnum];
+    FX_FILESIZE offset = m_ObjectInfo[objnum].pos;
     if (offset == 0) {
       return 0;
     }
     void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
                                   CompareFileSize);
     if (!pResult) {
       return 0;
     }
     if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() ==
         m_SortedOffset.GetSize() - 1) {
       return 0;
     }
     return ((FX_FILESIZE*)pResult)[1] - offset;
   }
   return 0;
 }
 void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum,
                                     uint8_t*& pBuffer,
                                     FX_DWORD& size) {
   pBuffer = NULL;
   size = 0;
-  if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) {
+  if (!IsValidObjectNumber(objnum))
     return;
-  }
+
   if (m_V5Type[objnum] == 2) {
-    CPDF_StreamAcc* pObjStream = GetObjectStream((FX_DWORD)m_CrossRef[objnum]);
+    CPDF_StreamAcc* pObjStream = GetObjectStream(m_ObjectInfo[objnum].pos);
     if (!pObjStream)
       return;
 
     int32_t offset = GetStreamFirst(pObjStream);
     const uint8_t* pData = pObjStream->GetData();
     FX_DWORD totalsize = pObjStream->GetSize();
     ScopedFileStream file(
         FX_CreateMemoryStream((uint8_t*)pData, (size_t)totalsize, FALSE));
     CPDF_SyntaxParser syntax;
     syntax.InitParser(file.get(), 0);
@@ skipping 13 matching lines @@
       pBuffer = FX_Alloc(uint8_t, size);
       FXSYS_memcpy(pBuffer, pData + thisoff + offset, size);
       return;
     }
     return;
   }
 
   if (m_V5Type[objnum] != 1)
     return;
 
-  FX_FILESIZE pos = m_CrossRef[objnum];
+  FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
   if (pos == 0) {
     return;
   }
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   m_Syntax.RestorePos(pos);
   FX_BOOL bIsNumber;
   CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return;
@@ skipping 253 matching lines @@
     bXRefRebuilt = TRUE;
     m_LastXRefOffset = 0;
   }
   if (bLoadV4) {
     m_pTrailer = LoadTrailerV4();
     if (!m_pTrailer) {
       return FALSE;
     }
     int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
     if (xrefsize > 0) {
-      m_CrossRef.SetSize(xrefsize);
+      m_ObjectInfo[0].pos = 0;
       m_V5Type.SetSize(xrefsize);
     }
   }
   FX_DWORD dwRet = SetEncryptHandler();
   if (dwRet != PDFPARSE_ERROR_SUCCESS) {
     return dwRet;
   }
   m_pDocument->LoadAsynDoc(m_pLinearized->GetDict());
   if (!m_pDocument->GetRoot() || m_pDocument->GetPageCount() == 0) {
     if (bXRefRebuilt) {
@@ skipping 1374 matching lines @@
   int iSize = m_arrayAcroforms.GetSize();
   for (int i = 0; i < iSize; ++i) {
     m_arrayAcroforms.GetAt(i)->Release();
   }
 }
 void CPDF_DataAvail::SetDocument(CPDF_Document* pDoc) {
   m_pDocument = pDoc;
 }
 FX_DWORD CPDF_DataAvail::GetObjectSize(FX_DWORD objnum, FX_FILESIZE& offset) {
   CPDF_Parser* pParser = (CPDF_Parser*)(m_pDocument->GetParser());
-  if (!pParser) {
+  if (!pParser || !pParser->IsValidObjectNumber(objnum))
     return 0;
-  }
-  if (objnum >= (FX_DWORD)pParser->m_CrossRef.GetSize()) {
-    return 0;
-  }
+
   if (pParser->m_V5Type[objnum] == 2) {
-    objnum = (FX_DWORD)pParser->m_CrossRef[objnum];
-  }
-  if (pParser->m_V5Type[objnum] == 1 || pParser->m_V5Type[objnum] == 255) {
-    offset = pParser->m_CrossRef[objnum];
+    objnum = pParser->m_ObjectInfo[objnum].pos;
+  } else if (pParser->m_V5Type[objnum] == 1 ||
+             pParser->m_V5Type[objnum] == 255) {
+    offset = pParser->m_ObjectInfo[objnum].pos;
     if (offset == 0) {
       return 0;
     }
     void* pResult = FXSYS_bsearch(&offset, pParser->m_SortedOffset.GetData(),
                                   pParser->m_SortedOffset.GetSize(),
                                   sizeof(FX_FILESIZE), CompareFileSize);
     if (!pResult) {
       return 0;
     }
     if ((FX_FILESIZE*)pResult -
@@ skipping 1993 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();
 }