Merge to XFA: Remove the m_V5Type member variable from CPDF_Parser.

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 107 matching lines @@
 bool CPDF_Parser::IsValidObjectNumber(FX_DWORD objnum) const {
   return !m_ObjectInfo.empty() && objnum <= m_ObjectInfo.rbegin()->first;
 }
 
 FX_FILESIZE CPDF_Parser::GetObjectPositionOrZero(FX_DWORD objnum) const {
   auto it = m_ObjectInfo.find(objnum);
   return it != m_ObjectInfo.end() ? it->second.pos : 0;
 }
 
 uint8_t CPDF_Parser::GetObjectType(FX_DWORD objnum) const {
-  return m_V5Type[objnum];
+  ASSERT(IsValidObjectNumber(objnum));
+  auto it = m_ObjectInfo.find(objnum);
+  return it != m_ObjectInfo.end() ? it->second.type : 0;
 }
 
 uint16_t CPDF_Parser::GetObjectGenNum(FX_DWORD objnum) const {
   return m_ObjVersion[objnum];
 }
 
 bool CPDF_Parser::IsObjectFreeOrNull(FX_DWORD objnum) const {
   uint8_t type = GetObjectType(objnum);
   return type == 0 || type == 255;
 }
@@ skipping 31 matching lines @@
   SetEncryptDictionary(nullptr);
   if (m_bOwnFileRead && m_Syntax.m_pFileAccess) {
     m_Syntax.m_pFileAccess->Release();
     m_Syntax.m_pFileAccess = nullptr;
   }
   m_ObjectStreamMap.clear();
   m_ObjCache.clear();
 
   m_SortedOffset.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();
     m_pLinearized = nullptr;
@@ skipping 143 matching lines @@
 
 void CPDF_Parser::ReleaseEncryptHandler() {
   m_Syntax.m_pCryptoHandler.reset();
   m_pSecurityHandler.reset();
 }
 
 FX_FILESIZE CPDF_Parser::GetObjectOffset(FX_DWORD objnum) const {
   if (!IsValidObjectNumber(objnum))
     return 0;
 
-  if (m_V5Type[objnum] == 1)
+  if (GetObjectType(objnum) == 1)
     return GetObjectPositionOrZero(objnum);
 
-  if (m_V5Type[objnum] == 2) {
+  if (GetObjectType(objnum) == 2) {
     FX_FILESIZE pos = GetObjectPositionOrZero(objnum);
     return GetObjectPositionOrZero(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 <= kMaxXRefSize) {
+  if (xrefsize > 0 && xrefsize <= kMaxXRefSize)
     ShrinkObjectMap(xrefsize);
-    m_V5Type.SetSize(xrefsize);
-  }
 
   CFX_FileSizeArray CrossRefList;
   CFX_FileSizeArray XRefStreamList;
   CrossRefList.Add(xrefpos);
   XRefStreamList.Add(GetDirectInteger(m_pTrailer, "XRefStm"));
 
   std::set<FX_FILESIZE> seen_xrefpos;
   seen_xrefpos.insert(xrefpos);
   // When |m_pTrailer| doesn't have Prev entry or Prev entry value is not
   // numerical, GetDirectInteger() returns 0. Loading will end.
@@ skipping 88 matching lines @@
     }
     if (!m_Syntax.ReadBlock(reinterpret_cast<uint8_t*>(buf.data()),
                             dwReadSize)) {
       return FALSE;
     }
     for (int32_t i = 0; i < block_size; i++) {
       FX_DWORD objnum = start_objnum + block * 1024 + i;
       char* pEntry = &buf[i * recordsize];
       if (pEntry[17] == 'f') {
         m_ObjectInfo[objnum].pos = 0;
-        m_V5Type.SetAtGrow(objnum, 0);
+        m_ObjectInfo[objnum].type = 0;
       } else {
         int32_t offset = FXSYS_atoi(pEntry);
         if (offset == 0) {
           for (int32_t c = 0; c < 10; c++) {
             if (!std::isdigit(pEntry[c]))
               return FALSE;
           }
         }
         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_ObjectInfo[objnum].pos < m_Syntax.m_FileLen) {
           void* pResult = FXSYS_bsearch(
               &m_ObjectInfo[objnum].pos, m_SortedOffset.GetData(),
               m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), CompareFileSize);
           if (!pResult) {
             m_SortedOffset.Add(m_ObjectInfo[objnum].pos);
           }
         }
-        m_V5Type.SetAtGrow(objnum, 1);
+        m_ObjectInfo[objnum].type = 1;
       }
     }
   }
   m_Syntax.RestorePos(SavedPos + count * recordsize);
   return TRUE;
 }
 
 bool CPDF_Parser::FindPosInOffsets(FX_FILESIZE pos) const {
   return FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                        sizeof(FX_FILESIZE), CompareFileSize);
@@ skipping 38 matching lines @@
       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*>(buf.data()),
                            block_size * recordsize);
         for (int32_t i = 0; i < block_size; i++) {
           FX_DWORD objnum = start_objnum + block * 1024 + i;
           char* pEntry = &buf[i * recordsize];
           if (pEntry[17] == 'f') {
             m_ObjectInfo[objnum].pos = 0;
-            m_V5Type.SetAtGrow(objnum, 0);
+            m_ObjectInfo[objnum].type = 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_ObjectInfo[objnum].pos = offset;
             int32_t version = FXSYS_atoi(pEntry + 11);
             if (version >= 1) {
               m_bVersionUpdated = TRUE;
             }
             m_ObjVersion.SetAtGrow(objnum, version);
             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_ObjectInfo[objnum].type = 1;
           }
         }
       }
     }
     m_Syntax.RestorePos(SavedPos + count * recordsize);
   }
   return !streampos || LoadCrossRefV5(&streampos, FALSE);
 }
 
 FX_BOOL CPDF_Parser::LoadAllCrossRefV5(FX_FILESIZE xrefpos) {
@@ skipping 11 matching lines @@
       return FALSE;
     }
   }
   m_ObjectStreamMap.clear();
   m_bXRefStream = TRUE;
   return TRUE;
 }
 
 FX_BOOL CPDF_Parser::RebuildCrossRef() {
   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;
   FX_DWORD gennum = 0;
@@ skipping 195 matching lines @@
                   if (pObject) {
                     FX_DWORD oldgen = m_ObjVersion.GetAt(objnum);
                     m_ObjectInfo[objnum].pos = obj_pos;
                     m_ObjVersion.SetAt(objnum, (int16_t)gennum);
                     if (oldgen != gennum) {
                       m_bVersionUpdated = TRUE;
                     }
                   }
                 } else {
                   m_ObjectInfo[objnum].pos = obj_pos;
-                  m_V5Type.SetAtGrow(objnum, 1);
+                  m_ObjectInfo[objnum].type = 1;
                   m_ObjVersion.SetAtGrow(objnum, (int16_t)gennum);
                 }
                 if (pObject) {
                   pObject->Release();
                 }
               }
               --i;
               status = 0;
               break;
           }
@@ skipping 173 matching lines @@
 
   *pos = pStream->GetDict()->GetIntegerBy("Prev");
   int32_t size = pStream->GetDict()->GetIntegerBy("Size");
   if (size < 0) {
     pStream->Release();
     return FALSE;
   }
   if (bMainXRef) {
     m_pTrailer = ToDictionary(pStream->GetDict()->Clone());
     ShrinkObjectMap(size);
-    if (m_V5Type.SetSize(size)) {
-      FXSYS_memset(m_V5Type.GetData(), 0, size);
-    }
+    for (auto it : m_ObjectInfo)
+      it.second.type = 0;
   } else {
     m_Trailers.Add(ToDictionary(pStream->GetDict()->Clone()));
   }
   std::vector<std::pair<int32_t, int32_t> > arrIndex;
   CPDF_Array* pArray = pStream->GetDict()->GetArrayBy("Index");
   if (pArray) {
     FX_DWORD nPairSize = pArray->GetCount() / 2;
     for (FX_DWORD i = 0; i < nPairSize; i++) {
       CPDF_Object* pStartNumObj = pArray->GetElement(i * 2);
       CPDF_Object* pCountObj = pArray->GetElement(i * 2 + 1);
@@ skipping 42 matching lines @@
     FX_SAFE_DWORD dwCaculatedSize = segindex;
     dwCaculatedSize += count;
     dwCaculatedSize *= totalWidth;
     if (!dwCaculatedSize.IsValid() ||
         dwCaculatedSize.ValueOrDie() > dwTotalSize) {
       continue;
     }
     const uint8_t* segstart = pData + segindex * totalWidth;
     FX_SAFE_DWORD dwMaxObjNum = startnum;
     dwMaxObjNum += count;
-    FX_DWORD dwV5Size =
-        pdfium::base::checked_cast<FX_DWORD, int32_t>(m_V5Type.GetSize());
+    FX_DWORD dwV5Size = m_ObjectInfo.empty() ? 0 : GetLastObjNum() + 1;
     if (!dwMaxObjNum.IsValid() || dwMaxObjNum.ValueOrDie() > dwV5Size) {
       continue;
     }
     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) {
+      if (GetObjectType(startnum + j) == 255) {
         FX_FILESIZE offset =
             GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
         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]) {
+      if (GetObjectType(startnum + j)) {
         continue;
       }
-      m_V5Type[startnum + j] = type;
+      m_ObjectInfo[startnum + j].type = type;
       if (type == 0) {
         m_ObjectInfo[startnum + j].pos = 0;
       } else {
         FX_FILESIZE offset =
             GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
         m_ObjectInfo[startnum + j].pos = offset;
         if (type == 1) {
           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()) {
+          if (offset < 0 || !IsValidObjectNumber(offset)) {
             pStream->Release();
             return FALSE;
           }
-          m_V5Type[offset] = 255;
+          m_ObjectInfo[offset].type = 255;
         }
       }
     }
     segindex += count;
   }
   pStream->Release();
   return TRUE;
 }
 CPDF_Array* CPDF_Parser::GetIDArray() {
   CPDF_Object* pID = m_pTrailer ? m_pTrailer->GetElement("ID") : NULL;
@@ skipping 13 matching lines @@
 }
 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 (!IsValidObjectNumber(objnum))
     return TRUE;
-  if (m_V5Type[objnum] == 0)
+  if (GetObjectType(objnum) == 0)
     return TRUE;
-  if (m_V5Type[objnum] == 2)
+  if (GetObjectType(objnum) == 2)
     return TRUE;
   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) {
@@ skipping 13 matching lines @@
     CPDF_IndirectObjectHolder* pObjList,
     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) {
+  if (GetObjectType(objnum) == 1 || GetObjectType(objnum) == 255) {
     FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
     if (pos <= 0)
       return nullptr;
     return ParseIndirectObjectAt(pObjList, pos, objnum);
   }
-  if (m_V5Type[objnum] != 2)
+  if (GetObjectType(objnum) != 2)
     return nullptr;
 
   CPDF_StreamAcc* pObjStream = GetObjectStream(m_ObjectInfo[objnum].pos);
   if (!pObjStream)
     return nullptr;
 
   ScopedFileStream file(FX_CreateMemoryStream(
       (uint8_t*)pObjStream->GetData(), (size_t)pObjStream->GetSize(), FALSE));
   CPDF_SyntaxParser syntax;
   syntax.InitParser(file.get(), 0);
@@ skipping 31 matching lines @@
   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 {
   if (!IsValidObjectNumber(objnum))
     return 0;
 
-  if (m_V5Type[objnum] == 2)
+  if (GetObjectType(objnum) == 2)
     objnum = GetObjectPositionOrZero(objnum);
 
-  if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) {
+  if (GetObjectType(objnum) == 1 || GetObjectType(objnum) == 255) {
     FX_FILESIZE offset = GetObjectPositionOrZero(objnum);
     if (offset == 0)
       return 0;
 
     FX_FILESIZE* pResult = static_cast<FX_FILESIZE*>(FXSYS_bsearch(
         &offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
         sizeof(FX_FILESIZE), CompareFileSize));
     if (!pResult)
       return 0;
 
     if (pResult - m_SortedOffset.GetData() == m_SortedOffset.GetSize() - 1)
       return 0;
 
     return pResult[1] - offset;
   }
   return 0;
 }
 
 void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum,
                                     uint8_t*& pBuffer,
                                     FX_DWORD& size) {
   pBuffer = NULL;
   size = 0;
   if (!IsValidObjectNumber(objnum))
     return;
 
-  if (m_V5Type[objnum] == 2) {
+  if (GetObjectType(objnum) == 2) {
     CPDF_StreamAcc* pObjStream = GetObjectStream(m_ObjectInfo[objnum].pos);
     if (!pObjStream)
       return;
 
     int32_t offset = GetStreamFirst(pObjStream);
     const uint8_t* pData = pObjStream->GetData();
     FX_DWORD totalsize = pObjStream->GetSize();
     ScopedFileStream file(
         FX_CreateMemoryStream((uint8_t*)pData, (size_t)totalsize, FALSE));
     CPDF_SyntaxParser syntax;
@@ skipping 11 matching lines @@
         FX_DWORD nextoff = syntax.GetDirectNum();
         size = nextoff - thisoff;
       }
       pBuffer = FX_Alloc(uint8_t, size);
       FXSYS_memcpy(pBuffer, pData + thisoff + offset, size);
       return;
     }
     return;
   }
 
-  if (m_V5Type[objnum] != 1)
+  if (GetObjectType(objnum) != 1)
     return;
 
   FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
   if (pos == 0) {
     return;
   }
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   m_Syntax.RestorePos(pos);
   bool bIsNumber;
   CFX_ByteString word = m_Syntax.GetNextWord(&bIsNumber);
@@ skipping 236 matching lines @@
     bXRefRebuilt = TRUE;
     m_LastXRefOffset = 0;
   }
   if (bLoadV4) {
     m_pTrailer = LoadTrailerV4();
     if (!m_pTrailer) {
       return SUCCESS;
     }
 
     int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
-    if (xrefsize > 0) {
+    if (xrefsize > 0)
       ShrinkObjectMap(xrefsize);
-      m_V5Type.SetSize(xrefsize);
-    }
   }
   Error eRet = SetEncryptHandler();
   if (eRet != SUCCESS) {
     return eRet;
   }
   m_pDocument->LoadAsynDoc(m_pLinearized->GetDict());
   if (!m_pDocument->GetRoot() || m_pDocument->GetPageCount() == 0) {
     if (bXRefRebuilt) {
       return FORMAT_ERROR;
     }
@@ skipping 3268 matching lines @@
   if (!m_pLinearizedDict)
     return -1;
   CPDF_Array* pRange = m_pLinearizedDict->GetArrayBy("H");
   if (!pRange)
     return -1;
   CPDF_Object* pStreamLen = pRange->GetElementValue(1);
   if (!pStreamLen)
     return -1;
   return pStreamLen->GetInteger();
 }