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

core/fpdfapi/parser/cpdf_data_avail.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_data_avail.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 65 matching lines @@
   m_docStatus = PDF_DATAAVAIL_HEADER;
   m_parser.m_bOwnFileRead = false;
   m_bTotalLoadPageTree = false;
   m_bCurPageDictLoadOK = false;
   m_bLinearedDataOK = false;
   m_bSupportHintTable = bSupportHintTable;
 }
 
 CPDF_DataAvail::~CPDF_DataAvail() {
   m_pHintTables.reset();
-  if (m_pLinearized)
-    m_pLinearized->Release();
-
-  if (m_pRoot)
-    m_pRoot->Release();
-
-  if (m_pTrailer)
-    m_pTrailer->Release();
+  delete m_pLinearized;
+  delete m_pRoot;
+  delete m_pTrailer;
 
   for (CPDF_Object* pObject : m_arrayAcroforms)
-    pObject->Release();
+    delete pObject;
 }
 
 void CPDF_DataAvail::SetDocument(CPDF_Document* pDoc) {
   m_pDocument = pDoc;
 }
 
 uint32_t CPDF_DataAvail::GetObjectSize(uint32_t objnum, FX_FILESIZE& offset) {
   CPDF_Parser* pParser = m_pDocument->GetParser();
   if (!pParser || !pParser->IsValidObjectNumber(objnum))
     return 0;
@@ skipping 116 matching lines @@
     return true;
   }
 
   std::vector<CPDF_Object*> new_objs_array;
   if (!AreObjectsAvailable(m_objs_array, false, pHints, new_objs_array)) {
     m_objs_array = new_objs_array;
     return false;
   }
 
   for (CPDF_Object* pObject : m_arrayAcroforms)
-    pObject->Release();
+    delete pObject;
 
   m_arrayAcroforms.clear();
   return true;
 }
 
 bool CPDF_DataAvail::CheckAcroForm(DownloadHints* pHints) {
   bool bExist = false;
   m_pAcroForm = GetObject(m_dwAcroFormObjNum, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_PAGETREE;
@@ skipping 149 matching lines @@
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return true;
     }
 
     if (m_Pos == m_dwFileLen)
       m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
-  if (pInfo)
-    pInfo->Release();
-
+  delete pInfo;
   m_docStatus =
       (m_bHaveAcroForm ? PDF_DATAAVAIL_ACROFORM : PDF_DATAAVAIL_PAGETREE);
 
   return true;
 }
 
 bool CPDF_DataAvail::CheckRoot(DownloadHints* pHints) {
   bool bExist = false;
   m_pRoot = GetObject(m_dwRootObjNum, pHints, &bExist);
   if (!bExist) {
@@ skipping 76 matching lines @@
 
     CPDF_Array* pArray = ToArray(pObj);
     if (pArray) {
       for (CPDF_Object* pArrayObj : *pArray) {
         if (CPDF_Reference* pRef = ToReference(pArrayObj))
           UnavailObjList.Add(pRef->GetRefObjNum());
       }
     }
 
     if (!pObj->IsDictionary()) {
-      pObj->Release();
+      delete pObj;
       continue;
     }
 
     CFX_ByteString type = pObj->GetDict()->GetStringFor("Type");
     if (type == "Pages") {
       m_PagesArray.push_back(pObj);
       continue;
     }
-    pObj->Release();
+    delete pObj;
   }
 
   m_PageObjList.RemoveAll();
   if (UnavailObjList.GetSize()) {
     m_PageObjList.Append(UnavailObjList);
     return false;
   }
 
   uint32_t iPages = m_PagesArray.size();
   for (uint32_t i = 0; i < iPages; i++) {
     CPDF_Object* pPages = m_PagesArray[i];
     if (!pPages)
       continue;
 
     if (!GetPageKids(m_pCurrentParser, pPages)) {
-      pPages->Release();
+      delete pPages;
       while (++i < iPages)
-        m_PagesArray[i]->Release();
+        delete m_PagesArray[i];
 
       m_PagesArray.clear();
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
     }
-    pPages->Release();
+    delete pPages;
   }
 
   m_PagesArray.clear();
   if (!m_PageObjList.GetSize())
     m_docStatus = PDF_DATAAVAIL_DONE;
   return true;
 }
 
 bool CPDF_DataAvail::GetPageKids(CPDF_Parser* pParser, CPDF_Object* pPages) {
   if (!pParser) {
@@ skipping 34 matching lines @@
 
   if (!pPages) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return true;
     }
     return false;
   }
 
   if (!GetPageKids(m_pCurrentParser, pPages)) {
-    pPages->Release();
+    delete pPages;
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
-  pPages->Release();
+  delete pPages;
   m_docStatus = PDF_DATAAVAIL_PAGE;
   return true;
 }
 
 bool CPDF_DataAvail::CheckHeader(DownloadHints* pHints) {
   ASSERT(m_dwFileLen >= 0);
   const uint32_t kReqSize = std::min(static_cast<uint32_t>(m_dwFileLen), 1024U);
 
   if (m_pFileAvail->IsDataAvail(0, kReqSize)) {
     uint8_t buffer[1024];
@@ skipping 150 matching lines @@
     return false;
   }
 
   if (!IsDataAvail(szHintStart, szHintLength, pHints))
     return false;
 
   m_syntaxParser.InitParser(m_pFileRead, m_dwHeaderOffset);
 
   std::unique_ptr<CPDF_HintTables> pHintTables(
       new CPDF_HintTables(this, pDict));
-  std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pHintStream(
+  std::unique_ptr<CPDF_Object> pHintStream(
       ParseIndirectObjectAt(szHintStart, 0));
   CPDF_Stream* pStream = ToStream(pHintStream.get());
   if (pStream && pHintTables->LoadHintStream(pStream))
     m_pHintTables = std::move(pHintTables);
 
   m_docStatus = PDF_DATAAVAIL_DONE;
   return true;
 }
 
 CPDF_Object* CPDF_DataAvail::ParseIndirectObjectAt(
@@ skipping 167 matching lines @@
       m_Pos += m_parser.m_pSyntax->SavePos();
       return 0;
     }
 
     CPDF_Dictionary* pDict = pObj->GetDict();
     CPDF_Name* pName = ToName(pDict ? pDict->GetObjectFor("Type") : nullptr);
     if (pName) {
       if (pName->GetString() == "XRef") {
         m_Pos += m_parser.m_pSyntax->SavePos();
         xref_offset = pObj->GetDict()->GetIntegerFor("Prev");
-        pObj->Release();
+        delete pObj;
         return 1;
       }
     }
-    pObj->Release();
+    delete pObj;
     return -1;
   }
   pHints->AddSegment(m_Pos, req_size);
   return 0;
 }
 
 void CPDF_DataAvail::SetStartOffset(FX_FILESIZE dwOffset) {
   m_Pos = dwOffset;
 }
 
@@ skipping 205 matching lines @@
       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(
+    std::unique_ptr<CPDF_Object> pTrailer(
         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;
 
@@ skipping 64 matching lines @@
   if (!pPages) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
     }
     return false;
   }
 
   CPDF_Array* pArray = pPages->AsArray();
   if (!pArray) {
-    pPages->Release();
+    delete pPages;
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   pPageNode->m_type = PDF_PAGENODE_PAGES;
   for (size_t i = 0; i < pArray->GetCount(); ++i) {
     CPDF_Reference* pKid = ToReference(pArray->GetObjectAt(i));
     if (!pKid)
       continue;
 
     PageNode* pNode = new PageNode();
     pPageNode->m_childNode.Add(pNode);
     pNode->m_dwPageNo = pKid->GetRefObjNum();
   }
-  pPages->Release();
+  delete pPages;
   return true;
 }
 
 bool CPDF_DataAvail::CheckUnkownPageNode(uint32_t dwPageNo,
                                          PageNode* pPageNode,
                                          DownloadHints* pHints) {
   bool bExist = false;
   CPDF_Object* pPage = GetObject(dwPageNo, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   if (!pPage) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR)
       m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   if (pPage->IsArray()) {
     pPageNode->m_dwPageNo = dwPageNo;
     pPageNode->m_type = PDF_PAGENODE_ARRAY;
-    pPage->Release();
+    delete pPage;
     return true;
   }
 
   if (!pPage->IsDictionary()) {
-    pPage->Release();
+    delete pPage;
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   pPageNode->m_dwPageNo = dwPageNo;
   CPDF_Dictionary* pDict = pPage->GetDict();
   CFX_ByteString type = pDict->GetStringFor("Type");
   if (type == "Pages") {
     pPageNode->m_type = PDF_PAGENODE_PAGES;
     CPDF_Object* pKids = pDict->GetObjectFor("Kids");
@@ skipping 20 matching lines @@
           pPageNode->m_childNode.Add(pNode);
           pNode->m_dwPageNo = pKid->GetRefObjNum();
         }
       } break;
       default:
         break;
     }
   } else if (type == "Page") {
     pPageNode->m_type = PDF_PAGENODE_PAGE;
   } else {
-    pPage->Release();
+    delete pPage;
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
-  pPage->Release();
+  delete pPage;
   return true;
 }
 
 bool CPDF_DataAvail::CheckPageNode(CPDF_DataAvail::PageNode& pageNodes,
                                    int32_t iPage,
                                    int32_t& iCount,
                                    DownloadHints* pHints,
                                    int level) {
   if (level >= kMaxPageRecursionDepth)
     return false;
@@ skipping 67 matching lines @@
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   if (!pPages)
     return false;
 
   CPDF_Dictionary* pPagesDict = pPages->GetDict();
   if (!pPagesDict) {
-    pPages->Release();
+    delete pPages;
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   if (!pPagesDict->KeyExist("Kids")) {
-    pPages->Release();
+    delete pPages;
     return true;
   }
 
   int count = pPagesDict->GetIntegerFor("Count");
   if (count > 0) {
-    pPages->Release();
+    delete pPages;
     return true;
   }
 
-  pPages->Release();
+  delete pPages;
   return false;
 }
 
 bool CPDF_DataAvail::LoadDocPages(DownloadHints* pHints) {
   if (!CheckUnkownPageNode(m_PagesObjNum, &m_pageNodes, pHints))
     return false;
 
   if (CheckPageCount(pHints)) {
     m_docStatus = PDF_DATAAVAIL_PAGE;
     return true;
@@ skipping 344 matching lines @@
   return FormAvailable;
 }
 
 CPDF_DataAvail::PageNode::PageNode() : m_type(PDF_PAGENODE_UNKNOWN) {}
 
 CPDF_DataAvail::PageNode::~PageNode() {
   for (int32_t i = 0; i < m_childNode.GetSize(); ++i)
     delete m_childNode[i];
   m_childNode.RemoveAll();
 }