Use unique_ptr return from CPDF_Parser::ParseIndirectObject()

core/fpdfapi/parser/cpdf_parser.cpp

 // Copyright 2016 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/parser/cpdf_parser.h"
 
 #include <vector>
 
@@ skipping 36 matching lines @@
 }  // namespace
 
 CPDF_Parser::CPDF_Parser()
     : m_pDocument(nullptr),
       m_bHasParsed(false),
       m_bOwnFileRead(true),
       m_FileVersion(0),
       m_pTrailer(nullptr),
       m_pEncryptDict(nullptr),
       m_bVersionUpdated(false),
-      m_pLinearized(nullptr),
       m_dwFirstPageNo(0),
       m_dwXrefStartObjNum(0) {
   m_pSyntax.reset(new CPDF_SyntaxParser);
 }
 
 CPDF_Parser::~CPDF_Parser() {
   delete m_pTrailer;
   ReleaseEncryptHandler();
   SetEncryptDictionary(nullptr);
 
   if (m_bOwnFileRead && m_pSyntax->m_pFileAccess) {
     m_pSyntax->m_pFileAccess->Release();
     m_pSyntax->m_pFileAccess = nullptr;
   }
 
   for (CPDF_Dictionary* trailer : m_Trailers)
     delete trailer;
-
-  delete m_pLinearized;
 }
 
 uint32_t CPDF_Parser::GetLastObjNum() const {
   return m_ObjectInfo.empty() ? 0 : m_ObjectInfo.rbegin()->first;
 }
 
 bool CPDF_Parser::IsValidObjectNumber(uint32_t objnum) const {
   return !m_ObjectInfo.empty() && objnum <= m_ObjectInfo.rbegin()->first;
 }
 
@@ skipping 640 matching lines @@
               } else {
                 inside_index++;
               }
               break;
             case 3:
               if (PDFCharIsWhitespace(byte) || PDFCharIsDelimiter(byte)) {
                 FX_FILESIZE obj_pos = start_pos - m_pSyntax->m_HeaderOffset;
                 m_SortedOffset.insert(obj_pos);
                 last_obj = start_pos;
                 FX_FILESIZE obj_end = 0;
-                CPDF_Object* pObject = ParseIndirectObjectAtByStrict(
-                    m_pDocument, obj_pos, objnum, &obj_end);
-                if (CPDF_Stream* pStream = ToStream(pObject)) {
+                std::unique_ptr<CPDF_Object> pObject =
+                    ParseIndirectObjectAtByStrict(m_pDocument, obj_pos, objnum,
+                                                  &obj_end);
+                if (CPDF_Stream* pStream = ToStream(pObject.get())) {
                   if (CPDF_Dictionary* pDict = pStream->GetDict()) {
                     if ((pDict->KeyExist("Type")) &&
                         (pDict->GetStringFor("Type") == "XRef" &&
                          pDict->KeyExist("Size"))) {
                       CPDF_Object* pRoot = pDict->GetObjectFor("Root");
                       if (pRoot && pRoot->GetDict() &&
                           pRoot->GetDict()->GetObjectFor("Pages")) {
                         delete m_pTrailer;
                         m_pTrailer = ToDictionary(pDict->Clone());
                       }
@@ skipping 24 matching lines @@
                     m_ObjectInfo[objnum].pos = obj_pos;
                     m_ObjectInfo[objnum].gennum = gennum;
                     if (oldgen != gennum)
                       m_bVersionUpdated = true;
                   }
                 } else {
                   m_ObjectInfo[objnum].pos = obj_pos;
                   m_ObjectInfo[objnum].type = 1;
                   m_ObjectInfo[objnum].gennum = gennum;
                 }
-
-                delete pObject;
               }
               --i;
               state = ParserState::kDefault;
               break;
           }
           break;
 
         case ParserState::kTrailer:
           if (inside_index == 7) {
             if (PDFCharIsWhitespace(byte) || PDFCharIsDelimiter(byte)) {
               last_trailer = pos + i - 7;
               m_pSyntax->RestorePos(pos + i - m_pSyntax->m_HeaderOffset);
 
-              CPDF_Object* pObj = m_pSyntax->GetObject(m_pDocument, 0, 0, true);
+              std::unique_ptr<CPDF_Object> pObj =
+                  m_pSyntax->GetObject(m_pDocument, 0, 0, true);
               if (pObj) {
-                if (!pObj->IsDictionary() && !pObj->AsStream()) {
-                  delete pObj;
-                } else {
+                if (pObj->IsDictionary() || pObj->AsStream()) {
                   CPDF_Stream* pStream = pObj->AsStream();
                   if (CPDF_Dictionary* pTrailer =
                           pStream ? pStream->GetDict() : pObj->AsDictionary()) {
                     if (m_pTrailer) {
                       CPDF_Object* pRoot = pTrailer->GetObjectFor("Root");
                       CPDF_Reference* pRef = ToReference(pRoot);
                       if (!pRoot ||
                           (pRef && IsValidObjectNumber(pRef->GetRefObjNum()) &&
                            m_ObjectInfo[pRef->GetRefObjNum()].pos != 0)) {
                         auto it = pTrailer->begin();
                         while (it != pTrailer->end()) {
                           const CFX_ByteString& key = it->first;
                           CPDF_Object* pElement = it->second;
                           ++it;
                           uint32_t dwObjNum =
                               pElement ? pElement->GetObjNum() : 0;
                           if (dwObjNum) {
                             m_pTrailer->SetReferenceFor(key, m_pDocument,
                                                         dwObjNum);
                           } else {
                             m_pTrailer->SetFor(key, pElement->Clone());
                           }
                         }
                       }
-                      delete pObj;
                     } else {
                       if (pObj->IsStream()) {
                         m_pTrailer = ToDictionary(pTrailer->Clone());
-                        delete pObj;
                       } else {
                         m_pTrailer = pTrailer;
                       }
 
                       FX_FILESIZE dwSavePos = m_pSyntax->SavePos();
                       CFX_ByteString strWord = m_pSyntax->GetKeyword();
                       if (!strWord.Compare("startxref")) {
                         bool bNumber;
                         CFX_ByteString bsOffset =
                             m_pSyntax->GetNextWord(&bNumber);
                         if (bNumber)
                           m_LastXRefOffset = FXSYS_atoi(bsOffset.c_str());
                       }
                       m_pSyntax->RestorePos(dwSavePos);
                     }
-                  } else {
-                    delete pObj;
                   }
                 }
               }
             }
             --i;
             state = ParserState::kDefault;
           } else if (byte == "trailer"[inside_index]) {
             inside_index++;
           } else {
             --i;
@@ skipping 223 matching lines @@
   }
   return true;
 }
 
 CPDF_Array* CPDF_Parser::GetIDArray() {
   CPDF_Object* pID = m_pTrailer ? m_pTrailer->GetObjectFor("ID") : nullptr;
   if (!pID)
     return nullptr;
 
   if (CPDF_Reference* pRef = pID->AsReference()) {
-    pID = ParseIndirectObject(nullptr, pRef->GetRefObjNum());
+    pID = ParseIndirectObject(nullptr, pRef->GetRefObjNum()).release();
     m_pTrailer->SetFor("ID", pID);
   }
   return ToArray(pID);
 }
 
 uint32_t CPDF_Parser::GetRootObjNum() {
   CPDF_Reference* pRef =
       ToReference(m_pTrailer ? m_pTrailer->GetObjectFor("Root") : nullptr);
   return pRef ? pRef->GetRefObjNum() : 0;
 }
 
 uint32_t CPDF_Parser::GetInfoObjNum() {
   CPDF_Reference* pRef =
       ToReference(m_pTrailer ? m_pTrailer->GetObjectFor("Info") : nullptr);
   return pRef ? pRef->GetRefObjNum() : 0;
 }
 
-CPDF_Object* CPDF_Parser::ParseIndirectObject(
+std::unique_ptr<CPDF_Object> CPDF_Parser::ParseIndirectObject(
     CPDF_IndirectObjectHolder* pObjList,
     uint32_t objnum) {
   if (!IsValidObjectNumber(objnum))
     return nullptr;
 
   // Prevent circular parsing the same object.
   if (pdfium::ContainsKey(m_ParsingObjNums, objnum))
     return nullptr;
 
   pdfium::ScopedSetInsertion<uint32_t> local_insert(&m_ParsingObjNums, objnum);
@@ skipping 182 matching lines @@
     nextoff = m_pSyntax->SavePos();
   }
 
   size = (uint32_t)(nextoff - pos);
   pBuffer = FX_Alloc(uint8_t, size);
   m_pSyntax->RestorePos(pos);
   m_pSyntax->ReadBlock(pBuffer, size);
   m_pSyntax->RestorePos(SavedPos);
 }
 
-CPDF_Object* CPDF_Parser::ParseIndirectObjectAt(
+std::unique_ptr<CPDF_Object> CPDF_Parser::ParseIndirectObjectAt(
     CPDF_IndirectObjectHolder* pObjList,
     FX_FILESIZE pos,
     uint32_t objnum) {
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
   m_pSyntax->RestorePos(pos);
   bool bIsNumber;
   CFX_ByteString word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
@@ skipping 12 matching lines @@
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
   uint32_t parser_gennum = FXSYS_atoui(word.c_str());
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
-  CPDF_Object* pObj =
+  std::unique_ptr<CPDF_Object> pObj =
       m_pSyntax->GetObject(pObjList, objnum, parser_gennum, true);
   m_pSyntax->SavePos();
 
   CFX_ByteString bsWord = m_pSyntax->GetKeyword();
   if (bsWord == "endobj")
     m_pSyntax->SavePos();
 
   m_pSyntax->RestorePos(SavedPos);
   if (pObj) {
     if (!objnum)
       pObj->m_ObjNum = parser_objnum;
     pObj->m_GenNum = parser_gennum;
   }
   return pObj;
 }
 
-CPDF_Object* CPDF_Parser::ParseIndirectObjectAtByStrict(
+std::unique_ptr<CPDF_Object> CPDF_Parser::ParseIndirectObjectAtByStrict(
     CPDF_IndirectObjectHolder* pObjList,
     FX_FILESIZE pos,
     uint32_t objnum,
     FX_FILESIZE* pResultPos) {
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
   m_pSyntax->RestorePos(pos);
 
   bool bIsNumber;
   CFX_ByteString word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber) {
@@ skipping 12 matching lines @@
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
   uint32_t gennum = FXSYS_atoui(word.c_str());
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
-  CPDF_Object* pObj = m_pSyntax->GetObjectForStrict(pObjList, objnum, gennum);
+  std::unique_ptr<CPDF_Object> pObj =
+      m_pSyntax->GetObjectForStrict(pObjList, objnum, gennum);
+
   if (pResultPos)
     *pResultPos = m_pSyntax->m_Pos;
 
   m_pSyntax->RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() {
   if (m_pSyntax->GetKeyword() != "trailer")
     return nullptr;
@@ skipping 38 matching lines @@
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
     return false;
   }
 
   m_pLinearized = m_pSyntax->GetObject(nullptr, objnum, gennum, true);
   if (!m_pLinearized)
     return false;
 
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-  if (pDict && pDict->GetObjectFor("Linearized")) {
-    m_pSyntax->GetNextWord(nullptr);
+  if (!pDict || !pDict->GetObjectFor("Linearized")) {
+    m_pLinearized.reset();
+    return false;
+  }
 
-    CPDF_Object* pLen = pDict->GetObjectFor("L");
-    if (!pLen) {
-      delete m_pLinearized;
-      m_pLinearized = nullptr;
-      return false;
-    }
+  m_pSyntax->GetNextWord(nullptr);
 
-    if (pLen->GetInteger() != (int)pFileAccess->GetSize())
-      return false;
+  CPDF_Object* pLen = pDict->GetObjectFor("L");
+  if (!pLen) {
+    m_pLinearized.reset();
+    return false;
+  }
 
-    if (CPDF_Number* pNo = ToNumber(pDict->GetObjectFor("P")))
-      m_dwFirstPageNo = pNo->GetInteger();
+  if (pLen->GetInteger() != (int)pFileAccess->GetSize())
+    return false;
 
-    if (CPDF_Number* pTable = ToNumber(pDict->GetObjectFor("T")))
-      m_LastXRefOffset = pTable->GetInteger();
+  if (CPDF_Number* pNo = ToNumber(pDict->GetObjectFor("P")))
+    m_dwFirstPageNo = pNo->GetInteger();
 
-    return true;
-  }
-  delete m_pLinearized;
-  m_pLinearized = nullptr;
-  return false;
+  if (CPDF_Number* pTable = ToNumber(pDict->GetObjectFor("T")))
+    m_LastXRefOffset = pTable->GetInteger();
+
+  return true;
 }
 
 CPDF_Parser::Error CPDF_Parser::StartLinearizedParse(
     IFX_SeekableReadStream* pFileAccess,
     CPDF_Document* pDocument) {
   ASSERT(!m_bHasParsed);
 
   m_bXRefStream = false;
   m_LastXRefOffset = 0;
   m_bOwnFileRead = true;
@@ skipping 116 matching lines @@
   if (!LoadLinearizedAllCrossRefV4(m_LastXRefOffset, m_dwXrefStartObjNum) &&
       !LoadLinearizedAllCrossRefV5(m_LastXRefOffset)) {
     m_LastXRefOffset = 0;
     m_pSyntax->m_MetadataObjnum = dwSaveMetadataObjnum;
     return FORMAT_ERROR;
   }
 
   m_pSyntax->m_MetadataObjnum = dwSaveMetadataObjnum;
   return SUCCESS;
 }