Use smart pointers for class owned member variables

core/fpdfapi/fpdf_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/fpdf_parser/include/cpdf_parser.h"
 
 #include <vector>
 
@@ skipping 33 matching lines @@
   return pObjStream->GetDict()->GetIntegerBy("N");
 }
 
 int32_t GetStreamFirst(CPDF_StreamAcc* pObjStream) {
   return pObjStream->GetDict()->GetIntegerBy("First");
 }
 
 }  // namespace
 
 CPDF_Parser::CPDF_Parser()
-    : m_pDocument(nullptr),
-      m_bOwnFileRead(true),
+    : 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);
 }
 
@@ skipping 54 matching lines @@
     auto saved_it = it++;
     m_ObjectInfo.erase(saved_it);
   }
 
   if (!pdfium::ContainsKey(m_ObjectInfo, objnum - 1))
     m_ObjectInfo[objnum - 1].pos = 0;
 }
 
 void CPDF_Parser::CloseParser() {
   m_bVersionUpdated = false;
-  delete m_pDocument;
-  m_pDocument = nullptr;
+  m_pDocument.reset();
 
   if (m_pTrailer) {
     m_pTrailer->Release();
     m_pTrailer = nullptr;
   }
   ReleaseEncryptHandler();
   SetEncryptDictionary(nullptr);
 
   if (m_bOwnFileRead && m_pSyntax->m_pFileAccess) {
     m_pSyntax->m_pFileAccess->Release();
@@ skipping 41 matching lines @@
 
   if (!m_pSyntax->GetCharAt(7, ch))
     return FORMAT_ERROR;
   if (std::isdigit(ch))
     m_FileVersion += FXSYS_toDecimalDigit(static_cast<FX_WCHAR>(ch));
 
   if (m_pSyntax->m_FileLen < m_pSyntax->m_HeaderOffset + 9)
     return FORMAT_ERROR;
 
   m_pSyntax->RestorePos(m_pSyntax->m_FileLen - m_pSyntax->m_HeaderOffset - 9);
-  m_pDocument = new CPDF_Document(this);
+  m_pDocument.reset(new CPDF_Document(this));
 
   FX_BOOL bXRefRebuilt = FALSE;
   if (m_pSyntax->SearchWord("startxref", TRUE, FALSE, 4096)) {
     m_SortedOffset.insert(m_pSyntax->SavePos());
     m_pSyntax->GetKeyword();
 
     bool bNumber;
     CFX_ByteString xrefpos_str = m_pSyntax->GetNextWord(&bNumber);
     if (!bNumber)
       return FORMAT_ERROR;
@@ skipping 554 matching lines @@
                 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);
+                    m_pDocument.get(), obj_pos, objnum, &obj_end);
                 if (CPDF_Stream* pStream = ToStream(pObject)) {
                   if (CPDF_Dictionary* pDict = pStream->GetDict()) {
                     if ((pDict->KeyExist("Type")) &&
                         (pDict->GetStringBy("Type") == "XRef" &&
                          pDict->KeyExist("Size"))) {
                       CPDF_Object* pRoot = pDict->GetObjectBy("Root");
                       if (pRoot && pRoot->GetDict() &&
                           pRoot->GetDict()->GetObjectBy("Pages")) {
                         if (m_pTrailer)
                           m_pTrailer->Release();
@@ skipping 42 matching lines @@
               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);
+              CPDF_Object* pObj =
+                  m_pSyntax->GetObject(m_pDocument.get(), 0, 0, true);
               if (pObj) {
                 if (!pObj->IsDictionary() && !pObj->AsStream()) {
                   pObj->Release();
                 } else {
                   CPDF_Stream* pStream = pObj->AsStream();
                   if (CPDF_Dictionary* pTrailer =
                           pStream ? pStream->GetDict() : pObj->AsDictionary()) {
                     if (m_pTrailer) {
                       CPDF_Object* pRoot = pTrailer->GetObjectBy("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->SetAtReference(key, m_pDocument,
+                            m_pTrailer->SetAtReference(key, m_pDocument.get(),
                                                        dwObjNum);
                           } else {
                             m_pTrailer->SetAt(key, pElement->Clone());
                           }
                         }
                       }
                       pObj->Release();
                     } else {
                       if (pObj->IsStream()) {
                         m_pTrailer = ToDictionary(pTrailer->Clone());
@@ skipping 103 matching lines @@
   if (last_xref != -1 && last_xref > last_obj)
     last_trailer = last_xref;
   else if (last_trailer == -1 || last_xref < last_obj)
     last_trailer = m_pSyntax->m_FileLen;
 
   m_SortedOffset.insert(last_trailer - m_pSyntax->m_HeaderOffset);
   return m_pTrailer && !m_ObjectInfo.empty();
 }
 
 FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE* pos, FX_BOOL bMainXRef) {
-  CPDF_Object* pObject = ParseIndirectObjectAt(m_pDocument, *pos, 0);
+  CPDF_Object* pObject = ParseIndirectObjectAt(m_pDocument.get(), *pos, 0);
   if (!pObject)
     return FALSE;
 
   if (m_pDocument) {
     CPDF_Dictionary* pRootDict = m_pDocument->GetRoot();
     if (pRootDict && pRootDict->GetObjNum() == pObject->m_ObjNum) {
       if (pObject->IsStream())
         pObject->Release();
       return FALSE;
     }
@@ skipping 477 matching lines @@
 
   m_pSyntax->RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() {
   if (m_pSyntax->GetKeyword() != "trailer")
     return nullptr;
 
   std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
-      m_pSyntax->GetObject(m_pDocument, 0, 0, true));
+      m_pSyntax->GetObject(m_pDocument.get(), 0, 0, true));
   if (!ToDictionary(pObj.get()))
     return nullptr;
   return pObj.release()->AsDictionary();
 }
 
 uint32_t CPDF_Parser::GetPermissions() const {
   if (!m_pSecurityHandler)
     return 0xFFFFFFFF;
 
   uint32_t dwPermission = m_pSecurityHandler->GetPermissions();
@@ skipping 66 matching lines @@
 
   int32_t offset = GetHeaderOffset(pFileAccess);
   if (offset == -1)
     return FORMAT_ERROR;
 
   if (!IsLinearizedFile(pFileAccess, offset)) {
     m_pSyntax->m_pFileAccess = nullptr;
     return StartParse(pFileAccess);
   }
 
-  m_pDocument = new CPDF_Document(this);
+  m_pDocument.reset(new CPDF_Document(this));
   FX_FILESIZE dwFirstXRefOffset = m_pSyntax->SavePos();
 
   FX_BOOL bXRefRebuilt = FALSE;
   FX_BOOL bLoadV4 = LoadCrossRefV4(dwFirstXRefOffset, 0, FALSE);
   if (!bLoadV4 && !LoadCrossRefV5(&dwFirstXRefOffset, TRUE)) {
     if (!RebuildCrossRef())
       return FORMAT_ERROR;
 
     bXRefRebuilt = TRUE;
     m_LastXRefOffset = 0;
@@ skipping 95 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;
 }