Revert of Remove CPDF_Object::Release() in favor of direct delete

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 43 matching lines @@
       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;
+  if (m_pTrailer)
+    m_pTrailer->Release();
+
   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;
+  for (CPDF_Dictionary* trailer : m_Trailers) {
+    if (trailer)
+      trailer->Release();
+  }
 
-  delete m_pLinearized;
+  if (m_pLinearized)
+    m_pLinearized->Release();
 }
 
 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 258 matching lines @@
     // Check for circular references.
     if (pdfium::ContainsKey(seen_xrefpos, xrefpos))
       return false;
 
     seen_xrefpos.insert(xrefpos);
 
     // SLOW ...
     CrossRefList.insert(CrossRefList.begin(), xrefpos);
     LoadCrossRefV4(xrefpos, 0, true);
 
-    std::unique_ptr<CPDF_Dictionary> pDict(LoadTrailerV4());
+    std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
+        LoadTrailerV4());
     if (!pDict)
       return false;
 
     xrefpos = GetDirectInteger(pDict.get(), "Prev");
 
     // SLOW ...
     XRefStreamList.insert(XRefStreamList.begin(),
                           pDict->GetIntegerFor("XRefStm"));
     m_Trailers.push_back(pDict.release());
   }
@@ skipping 33 matching lines @@
     // Check for circular references.
     if (pdfium::ContainsKey(seen_xrefpos, xrefpos))
       return false;
 
     seen_xrefpos.insert(xrefpos);
 
     // SLOW ...
     CrossRefList.insert(CrossRefList.begin(), xrefpos);
     LoadCrossRefV4(xrefpos, 0, true);
 
-    std::unique_ptr<CPDF_Dictionary> pDict(LoadTrailerV4());
+    std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
+        LoadTrailerV4());
     if (!pDict)
       return false;
 
     xrefpos = GetDirectInteger(pDict.get(), "Prev");
 
     // SLOW ...
     XRefStreamList.insert(XRefStreamList.begin(),
                           pDict->GetIntegerFor("XRefStm"));
     m_Trailers.push_back(pDict.release());
   }
@@ skipping 156 matching lines @@
       return false;
   }
   m_ObjectStreamMap.clear();
   m_bXRefStream = true;
   return true;
 }
 
 bool CPDF_Parser::RebuildCrossRef() {
   m_ObjectInfo.clear();
   m_SortedOffset.clear();
-  delete m_pTrailer;
-  m_pTrailer = nullptr;
+  if (m_pTrailer) {
+    m_pTrailer->Release();
+    m_pTrailer = nullptr;
+  }
 
   ParserState state = ParserState::kDefault;
+
   int32_t inside_index = 0;
   uint32_t objnum = 0;
   uint32_t gennum = 0;
   int32_t depth = 0;
+
   const uint32_t kBufferSize = 4096;
   std::vector<uint8_t> buffer(kBufferSize);
 
   FX_FILESIZE pos = m_pSyntax->m_HeaderOffset;
   FX_FILESIZE start_pos = 0;
   FX_FILESIZE start_pos1 = 0;
   FX_FILESIZE last_obj = -1;
   FX_FILESIZE last_xref = -1;
   FX_FILESIZE last_trailer = -1;
 
@@ skipping 133 matching lines @@
                 CPDF_Object* pObject = ParseIndirectObjectAtByStrict(
                     m_pDocument, obj_pos, objnum, &obj_end);
                 if (CPDF_Stream* pStream = ToStream(pObject)) {
                   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;
+                        if (m_pTrailer)
+                          m_pTrailer->Release();
                         m_pTrailer = ToDictionary(pDict->Clone());
                       }
                     }
                   }
                 }
 
                 FX_FILESIZE offset = 0;
                 m_pSyntax->RestorePos(obj_pos);
                 offset = m_pSyntax->FindTag("obj", 0);
                 if (offset == -1)
@@ skipping 17 matching lines @@
                     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;
+                if (pObject)
+                  pObject->Release();
               }
               --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);
               if (pObj) {
                 if (!pObj->IsDictionary() && !pObj->AsStream()) {
-                  delete pObj;
+                  pObj->Release();
                 } else {
                   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;
+                      pObj->Release();
                     } else {
                       if (pObj->IsStream()) {
                         m_pTrailer = ToDictionary(pTrailer->Clone());
-                        delete pObj;
+                        pObj->Release();
                       } 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;
+                    pObj->Release();
                   }
                 }
               }
             }
             --i;
             state = ParserState::kDefault;
           } else if (byte == "trailer"[inside_index]) {
             inside_index++;
           } else {
             --i;
@@ skipping 538 matching lines @@
     *pResultPos = m_pSyntax->m_Pos;
 
   m_pSyntax->RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() {
   if (m_pSyntax->GetKeyword() != "trailer")
     return nullptr;
 
-  std::unique_ptr<CPDF_Object> pObj(
+  std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
       m_pSyntax->GetObject(m_pDocument, 0, 0, true));
   if (!ToDictionary(pObj.get()))
     return nullptr;
   return pObj.release()->AsDictionary();
 }
 
 uint32_t CPDF_Parser::GetPermissions() const {
   if (!m_pSecurityHandler)
     return 0xFFFFFFFF;
 
@@ skipping 31 matching lines @@
   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);
 
     CPDF_Object* pLen = pDict->GetObjectFor("L");
     if (!pLen) {
-      delete m_pLinearized;
+      m_pLinearized->Release();
       m_pLinearized = nullptr;
       return false;
     }
 
     if (pLen->GetInteger() != (int)pFileAccess->GetSize())
       return false;
 
     if (CPDF_Number* pNo = ToNumber(pDict->GetObjectFor("P")))
       m_dwFirstPageNo = pNo->GetInteger();
 
     if (CPDF_Number* pTable = ToNumber(pDict->GetObjectFor("T")))
       m_LastXRefOffset = pTable->GetInteger();
 
     return true;
   }
-  delete m_pLinearized;
+  m_pLinearized->Release();
   m_pLinearized = nullptr;
   return false;
 }
 
 CPDF_Parser::Error CPDF_Parser::StartLinearizedParse(
     IFX_SeekableReadStream* pFileAccess,
     CPDF_Document* pDocument) {
   ASSERT(!m_bHasParsed);
 
   m_bXRefStream = false;
@@ skipping 88 matching lines @@
       return false;
   }
   m_ObjectStreamMap.clear();
   m_bXRefStream = true;
   return true;
 }
 
 CPDF_Parser::Error CPDF_Parser::LoadLinearizedMainXRefTable() {
   uint32_t dwSaveMetadataObjnum = m_pSyntax->m_MetadataObjnum;
   m_pSyntax->m_MetadataObjnum = 0;
+  if (m_pTrailer) {
+    m_pTrailer->Release();
+    m_pTrailer = nullptr;
+  }
 
-  delete m_pTrailer;
-  m_pTrailer = nullptr;
   m_pSyntax->RestorePos(m_LastXRefOffset - m_pSyntax->m_HeaderOffset);
-
   uint8_t ch = 0;
   uint32_t dwCount = 0;
   m_pSyntax->GetNextChar(ch);
   while (PDFCharIsWhitespace(ch)) {
     ++dwCount;
     if (m_pSyntax->m_FileLen >=
         (FX_FILESIZE)(m_pSyntax->SavePos() + m_pSyntax->m_HeaderOffset)) {
       break;
     }
     m_pSyntax->GetNextChar(ch);
   }
   m_LastXRefOffset += dwCount;
   m_ObjectStreamMap.clear();
   m_ObjCache.clear();
 
   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;
 }