Use unique_ptr return from CPDF_Parser::ParseIndirectObject()

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>
 #include <utility>
 
 #include "core/fpdfapi/cpdf_modulemgr.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfapi/parser/cpdf_hint_tables.h"
 #include "core/fpdfapi/parser/cpdf_linearized_header.h"
 #include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
 #include "core/fpdfapi/parser/cpdf_reference.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/fpdf_parser_utility.h"
 #include "core/fxcrt/fx_ext.h"
 #include "core/fxcrt/fx_safe_types.h"
+#include "third_party/base/numerics/safe_conversions.h"
 #include "third_party/base/stl_util.h"
 
 CPDF_DataAvail::FileAvail::~FileAvail() {}
 
 CPDF_DataAvail::DownloadHints::~DownloadHints() {}
 
 // static
 int CPDF_DataAvail::s_CurrentDataAvailRecursionDepth = 0;
 
 CPDF_DataAvail::CPDF_DataAvail(FileAvail* pFileAvail,
@@ skipping 22 matching lines @@
   m_bDocAvail = false;
   m_bPagesLoad = false;
   m_bPagesTreeLoad = false;
   m_bMainXRefLoadedOK = false;
   m_bAnnotsLoad = false;
   m_bHaveAcroForm = false;
   m_bAcroFormLoad = false;
   m_bPageLoadedOK = false;
   m_bNeedDownLoadResource = false;
   m_bLinearizedFormParamLoad = false;
-  m_pRoot = nullptr;
   m_pTrailer = nullptr;
   m_pCurrentParser = nullptr;
   m_pAcroForm = nullptr;
   m_pPageDict = nullptr;
   m_pPageResource = nullptr;
   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();
-
   for (CPDF_Object* pObject : m_arrayAcroforms)
     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();
@@ skipping 126 matching lines @@
 
   for (CPDF_Object* pObject : m_arrayAcroforms)
     delete pObject;
 
   m_arrayAcroforms.clear();
   return true;
 }
 
 bool CPDF_DataAvail::CheckAcroForm(DownloadHints* pHints) {
   bool bExist = false;
-  m_pAcroForm = GetObject(m_dwAcroFormObjNum, pHints, &bExist);
+  m_pAcroForm = GetObject(m_dwAcroFormObjNum, pHints, &bExist).release();
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_PAGETREE;
     return true;
   }
 
   if (!m_pAcroForm) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return true;
     }
@@ skipping 89 matching lines @@
     return false;
   }
 
   m_dwRootObjNum = m_parser.GetRootObjNum();
   m_dwInfoObjNum = m_parser.GetInfoObjNum();
   m_pCurrentParser = &m_parser;
   m_docStatus = PDF_DATAAVAIL_ROOT;
   return true;
 }
 
-CPDF_Object* CPDF_DataAvail::GetObject(uint32_t objnum,
-                                       DownloadHints* pHints,
-                                       bool* pExistInFile) {
-  CPDF_Object* pRet = nullptr;
+std::unique_ptr<CPDF_Object> CPDF_DataAvail::GetObject(uint32_t objnum,
+                                                       DownloadHints* pHints,
+                                                       bool* pExistInFile) {
   uint32_t size = 0;
   FX_FILESIZE offset = 0;
   CPDF_Parser* pParser = nullptr;
 
   if (pExistInFile)
     *pExistInFile = true;
 
   if (m_pDocument) {
     size = GetObjectSize(objnum, offset);
     pParser = m_pDocument->GetParser();
   } else {
     size = (uint32_t)m_parser.GetObjectSize(objnum);
     offset = m_parser.GetObjectOffset(objnum);
     pParser = &m_parser;
   }
 
   if (!IsDataAvail(offset, size, pHints))
     return nullptr;
 
+  std::unique_ptr<CPDF_Object> pRet;
   if (pParser)
     pRet = pParser->ParseIndirectObject(nullptr, objnum);
 
   if (!pRet && pExistInFile)
     *pExistInFile = false;
 
   return pRet;
 }
 
 bool CPDF_DataAvail::CheckInfo(DownloadHints* pHints) {
   bool bExist = false;
-  CPDF_Object* pInfo = GetObject(m_dwInfoObjNum, pHints, &bExist);
-  if (!bExist) {
-    m_docStatus =
-        (m_bHaveAcroForm ? PDF_DATAAVAIL_ACROFORM : PDF_DATAAVAIL_PAGETREE);
-    return true;
-  }
-
-  if (!pInfo) {
+  std::unique_ptr<CPDF_Object> pInfo =
+      GetObject(m_dwInfoObjNum, pHints, &bExist);
+  if (bExist && !pInfo) {
     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;
   }
-
-  delete pInfo;
   m_docStatus =
-      (m_bHaveAcroForm ? PDF_DATAAVAIL_ACROFORM : PDF_DATAAVAIL_PAGETREE);
-
+      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) {
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return true;
   }
@@ skipping 57 matching lines @@
 void CPDF_DataAvail::ResetFirstCheck(uint32_t dwPage) {
   m_pageMapCheckState.erase(dwPage);
 }
 
 bool CPDF_DataAvail::CheckPage(DownloadHints* pHints) {
   uint32_t iPageObjs = m_PageObjList.GetSize();
   CFX_ArrayTemplate<uint32_t> UnavailObjList;
   for (uint32_t i = 0; i < iPageObjs; ++i) {
     uint32_t dwPageObjNum = m_PageObjList.GetAt(i);
     bool bExist = false;
-    CPDF_Object* pObj = GetObject(dwPageObjNum, pHints, &bExist);
+    std::unique_ptr<CPDF_Object> pObj =
+        GetObject(dwPageObjNum, pHints, &bExist);
     if (!pObj) {
       if (bExist)
         UnavailObjList.Add(dwPageObjNum);
       continue;
     }
 
-    CPDF_Array* pArray = ToArray(pObj);
+    CPDF_Array* pArray = ToArray(pObj.get());
     if (pArray) {
       for (CPDF_Object* pArrayObj : *pArray) {
         if (CPDF_Reference* pRef = ToReference(pArrayObj))
           UnavailObjList.Add(pRef->GetRefObjNum());
       }
     }
 
     if (!pObj->IsDictionary()) {
-      delete pObj;
       continue;
     }
 
     CFX_ByteString type = pObj->GetDict()->GetStringFor("Type");
     if (type == "Pages") {
-      m_PagesArray.push_back(pObj);
+      m_PagesArray.push_back(std::move(pObj));
       continue;
     }
-    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)) {
-      delete pPages;
-      while (++i < iPages)
-        delete m_PagesArray[i];
-
+    std::unique_ptr<CPDF_Object> pPages = std::move(m_PagesArray[i]);
+    if (pPages && !GetPageKids(m_pCurrentParser, pPages.get())) {
       m_PagesArray.clear();
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
     }
-    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) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   CPDF_Dictionary* pDict = pPages->GetDict();
@@ skipping 14 matching lines @@
     } break;
     default:
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
   }
   return true;
 }
 
 bool CPDF_DataAvail::CheckPages(DownloadHints* pHints) {
   bool bExist = false;
-  CPDF_Object* pPages = GetObject(m_PagesObjNum, pHints, &bExist);
+  std::unique_ptr<CPDF_Object> pPages =
+      GetObject(m_PagesObjNum, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return true;
   }
 
   if (!pPages) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return true;
     }
     return false;
   }
 
-  if (!GetPageKids(m_pCurrentParser, pPages)) {
-    delete pPages;
+  if (!GetPageKids(m_pCurrentParser, pPages.get())) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
-  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 104 matching lines @@
   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(
+std::unique_ptr<CPDF_Object> CPDF_DataAvail::ParseIndirectObjectAt(
     FX_FILESIZE pos,
     uint32_t objnum,
     CPDF_IndirectObjectHolder* pObjList) {
   FX_FILESIZE SavedPos = m_syntaxParser.SavePos();
   m_syntaxParser.RestorePos(pos);
 
   bool bIsNumber;
   CFX_ByteString word = m_syntaxParser.GetNextWord(&bIsNumber);
   if (!bIsNumber)
     return nullptr;
 
   uint32_t parser_objnum = FXSYS_atoui(word.c_str());
   if (objnum && parser_objnum != objnum)
     return nullptr;
 
   word = m_syntaxParser.GetNextWord(&bIsNumber);
   if (!bIsNumber)
     return nullptr;
 
   uint32_t gennum = FXSYS_atoui(word.c_str());
   if (m_syntaxParser.GetKeyword() != "obj") {
     m_syntaxParser.RestorePos(SavedPos);
     return nullptr;
   }
 
-  CPDF_Object* pObj =
+  std::unique_ptr<CPDF_Object> pObj =
       m_syntaxParser.GetObject(pObjList, parser_objnum, gennum, true);
   m_syntaxParser.RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_DataAvail::DocLinearizationStatus CPDF_DataAvail::IsLinearizedPDF() {
   const uint32_t kReqSize = 1024;
   if (!m_pFileAvail->IsDataAvail(0, kReqSize))
     return LinearizationUnknown;
 
@@ skipping 14 matching lines @@
 
 bool CPDF_DataAvail::IsLinearized() {
   return !!m_pLinearized;
 }
 
 bool CPDF_DataAvail::IsLinearizedFile(uint8_t* pData, uint32_t dwLen) {
   if (m_pLinearized)
     return true;
 
   ScopedFileStream file(FX_CreateMemoryStream(pData, (size_t)dwLen, false));
-
   int32_t offset = GetHeaderOffset(file.get());
   if (offset == -1) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   m_dwHeaderOffset = offset;
   m_syntaxParser.InitParser(file.get(), offset);
   m_syntaxParser.RestorePos(m_syntaxParser.m_HeaderOffset + 9);
 
   bool bNumber;
   CFX_ByteString wordObjNum = m_syntaxParser.GetNextWord(&bNumber);
   if (!bNumber)
     return false;
 
   uint32_t objnum = FXSYS_atoui(wordObjNum.c_str());
-  m_pLinearized = CPDF_LinearizedHeader::CreateForObject(pdfium::WrapUnique(
-      ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum)));
+  m_pLinearized = CPDF_LinearizedHeader::CreateForObject(
+      ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum));
   if (!m_pLinearized ||
       m_pLinearized->GetFileSize() != m_pFileRead->GetSize()) {
     m_pLinearized.reset();
     return false;
   }
   return true;
 }
 
 bool CPDF_DataAvail::CheckEnd(DownloadHints* pHints) {
   uint32_t req_pos = (uint32_t)(m_dwFileLen > 1024 ? m_dwFileLen - 1024 : 0);
@@ skipping 52 matching lines @@
 
     ScopedFileStream file(FX_CreateMemoryStream(pBuf, (size_t)iSize, false));
     m_parser.m_pSyntax->InitParser(file.get(), 0);
 
     bool bNumber;
     CFX_ByteString objnum = m_parser.m_pSyntax->GetNextWord(&bNumber);
     if (!bNumber)
       return -1;
 
     uint32_t objNum = FXSYS_atoui(objnum.c_str());
-    CPDF_Object* pObj = m_parser.ParseIndirectObjectAt(nullptr, 0, objNum);
+    std::unique_ptr<CPDF_Object> pObj =
+        m_parser.ParseIndirectObjectAt(nullptr, 0, objNum);
+
     if (!pObj) {
       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");
-        delete pObj;
-        return 1;
-      }
+    if (pName && pName->GetString() == "XRef") {
+      m_Pos += m_parser.m_pSyntax->SavePos();
+      xref_offset = pObj->GetDict()->GetIntegerFor("Prev");
+      return 1;
     }
-    delete pObj;
     return -1;
   }
   pHints->AddSegment(m_Pos, req_size);
   return 0;
 }
 
 void CPDF_DataAvail::SetStartOffset(FX_FILESIZE dwOffset) {
   m_Pos = dwOffset;
 }
 
@@ skipping 274 matching lines @@
         m_docStatus = PDF_DATAAVAIL_PAGE;
         return true;
     }
   }
 }
 
 bool CPDF_DataAvail::CheckArrayPageNode(uint32_t dwPageNo,
                                         PageNode* pPageNode,
                                         DownloadHints* pHints) {
   bool bExist = false;
-  CPDF_Object* pPages = GetObject(dwPageNo, pHints, &bExist);
+  std::unique_ptr<CPDF_Object> pPages = GetObject(dwPageNo, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   if (!pPages) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
     }
     return false;
   }
 
   CPDF_Array* pArray = pPages->AsArray();
   if (!pArray) {
-    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();
   }
-  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);
+  std::unique_ptr<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;
-    delete pPage;
     return true;
   }
 
   if (!pPage->IsDictionary()) {
-    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 {
-    delete pPage;
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
-  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 56 matching lines @@
     }
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return true;
   }
   int32_t iCount = -1;
   return CheckPageNode(m_pageNodes, iPage, iCount, pHints, 0);
 }
 
 bool CPDF_DataAvail::CheckPageCount(DownloadHints* pHints) {
   bool bExist = false;
-  CPDF_Object* pPages = GetObject(m_PagesObjNum, pHints, &bExist);
+  std::unique_ptr<CPDF_Object> pPages =
+      GetObject(m_PagesObjNum, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   if (!pPages)
     return false;
 
   CPDF_Dictionary* pPagesDict = pPages->GetDict();
   if (!pPagesDict) {
-    delete pPages;
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
-  if (!pPagesDict->KeyExist("Kids")) {
-    delete pPages;
+  if (!pPagesDict->KeyExist("Kids"))
     return true;
-  }
 
-  int count = pPagesDict->GetIntegerFor("Count");
-  if (count > 0) {
-    delete pPages;
-    return true;
-  }
-
-  delete pPages;
-  return false;
+  return pPagesDict->GetIntegerFor("Count") > 0;
 }
 
 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 285 matching lines @@
   FX_FILESIZE szPageLength = 0;
   uint32_t dwObjNum = 0;
   const bool bPagePosGot = m_pHintTables->GetPagePos(index, &szPageStartPos,
                                                      &szPageLength, &dwObjNum);
   if (!bPagePosGot || !dwObjNum)
     return nullptr;
   // We should say to the document, which object is the page.
   m_pDocument->SetPageObjNum(index, dwObjNum);
   // Page object already can be parsed in document.
   if (!m_pDocument->GetIndirectObject(dwObjNum)) {
-    m_syntaxParser.InitParser(m_pFileRead, (uint32_t)szPageStartPos);
+    m_syntaxParser.InitParser(
+        m_pFileRead, pdfium::base::checked_cast<uint32_t>(szPageStartPos));
     m_pDocument->ReplaceIndirectObjectIfHigherGeneration(
-        dwObjNum, pdfium::WrapUnique<CPDF_Object>(
-                      ParseIndirectObjectAt(0, dwObjNum, m_pDocument)));
+        dwObjNum, ParseIndirectObjectAt(0, dwObjNum, m_pDocument));
   }
   return m_pDocument->GetPage(index);
 }
 
 CPDF_DataAvail::DocFormStatus CPDF_DataAvail::IsFormAvail(
     DownloadHints* pHints) {
   if (!m_pDocument)
     return FormAvailable;
 
   if (!m_bLinearizedFormParamLoad) {
@@ skipping 26 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();
 }