Use unique_ptr return from CPDF_Parser::ParseIndirectObject()

core/fpdfapi/parser/cpdf_syntax_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_syntax_parser.h"
 
 #include <vector>
 
 #include "core/fpdfapi/cpdf_modulemgr.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_boolean.h"
 #include "core/fpdfapi/parser/cpdf_crypto_handler.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_null.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/cpdf_string.h"
 #include "core/fpdfapi/parser/fpdf_parser_decode.h"
 #include "core/fpdfapi/parser/fpdf_parser_utility.h"
 #include "core/fxcrt/fx_ext.h"
 #include "third_party/base/numerics/safe_math.h"
+#include "third_party/base/ptr_util.h"
 
 namespace {
 
 enum class ReadStatus { Normal, Backslash, Octal, FinishOctal, CarriageReturn };
 
 }  // namespace
 
 // static
 int CPDF_SyntaxParser::s_CurrentRecursionDepth = 0;
 
@@ skipping 319 matching lines @@
 
 CFX_ByteString CPDF_SyntaxParser::GetNextWord(bool* bIsNumber) {
   GetNextWordInternal(bIsNumber);
   return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
 }
 
 CFX_ByteString CPDF_SyntaxParser::GetKeyword() {
   return GetNextWord(nullptr);
 }
 
-CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjectHolder* pObjList,
-                                          uint32_t objnum,
-                                          uint32_t gennum,
-                                          bool bDecrypt) {
+std::unique_ptr<CPDF_Object> CPDF_SyntaxParser::GetObject(
+    CPDF_IndirectObjectHolder* pObjList,
+    uint32_t objnum,
+    uint32_t gennum,
+    bool bDecrypt) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth)
     return nullptr;
 
   FX_FILESIZE SavedObjPos = m_Pos;
   bool bIsNumber;
   CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0)
     return nullptr;
 
   if (bIsNumber) {
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(&bIsNumber);
     if (bIsNumber) {
       CFX_ByteString nextword2 = GetNextWord(nullptr);
-      if (nextword2 == "R")
-        return new CPDF_Reference(pObjList, FXSYS_atoui(word.c_str()));
+      if (nextword2 == "R") {
+        return pdfium::MakeUnique<CPDF_Reference>(pObjList,
+                                                  FXSYS_atoui(word.c_str()));
+      }
     }
     m_Pos = SavedPos;
-    return new CPDF_Number(word.AsStringC());
+    return pdfium::MakeUnique<CPDF_Number>(word.AsStringC());
   }
 
   if (word == "true" || word == "false")
-    return new CPDF_Boolean(word == "true");
+    return pdfium::MakeUnique<CPDF_Boolean>(word == "true");
 
   if (word == "null")
-    return new CPDF_Null;
+    return pdfium::MakeUnique<CPDF_Null>();
 
   if (word == "(") {
     CFX_ByteString str = ReadString();
     if (m_pCryptoHandler && bDecrypt)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
-    return new CPDF_String(MaybeIntern(str), false);
+    return pdfium::MakeUnique<CPDF_String>(MaybeIntern(str), false);
   }
-
   if (word == "<") {
     CFX_ByteString str = ReadHexString();
     if (m_pCryptoHandler && bDecrypt)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
-    return new CPDF_String(MaybeIntern(str), true);
+    return pdfium::MakeUnique<CPDF_String>(MaybeIntern(str), true);
   }
-
   if (word == "[") {
-    CPDF_Array* pArray = new CPDF_Array;
-    while (CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, true))
-      pArray->Add(pObj);
-
-    return pArray;
+    std::unique_ptr<CPDF_Array> pArray = pdfium::MakeUnique<CPDF_Array>();
+    while (std::unique_ptr<CPDF_Object> pObj =
+               GetObject(pObjList, objnum, gennum, true)) {
+      pArray->Add(pObj.release());
+    }
+    return std::move(pArray);
   }
-
   if (word[0] == '/') {
-    return new CPDF_Name(MaybeIntern(
+    return pdfium::MakeUnique<CPDF_Name>(MaybeIntern(
         PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1))));
   }
-
   if (word == "<<") {
     int32_t nKeys = 0;
     FX_FILESIZE dwSignValuePos = 0;
-
-    std::unique_ptr<CPDF_Dictionary> pDict(new CPDF_Dictionary(m_pPool));
+    std::unique_ptr<CPDF_Dictionary> pDict =
+        pdfium::MakeUnique<CPDF_Dictionary>(m_pPool);
     while (1) {
       CFX_ByteString key = GetNextWord(nullptr);
       if (key.IsEmpty())
         return nullptr;
 
       FX_FILESIZE SavedPos = m_Pos - key.GetLength();
       if (key == ">>")
         break;
 
       if (key == "endobj") {
         m_Pos = SavedPos;
         break;
       }
-
       if (key[0] != '/')
         continue;
 
       ++nKeys;
       key = PDF_NameDecode(key);
       if (key.IsEmpty())
         continue;
 
       if (key == "/Contents")
         dwSignValuePos = m_Pos;
 
-      CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, true);
+      std::unique_ptr<CPDF_Object> pObj =
+          GetObject(pObjList, objnum, gennum, true);
       if (!pObj)
         continue;
 
       CFX_ByteString keyNoSlash(key.raw_str() + 1, key.GetLength() - 1);
-      pDict->SetFor(keyNoSlash, pObj);
+      pDict->SetFor(keyNoSlash, pObj.release());
     }
 
     // Only when this is a signature dictionary and has contents, we reset the
     // contents to the un-decrypted form.
     if (pDict->IsSignatureDict() && dwSignValuePos) {
       CFX_AutoRestorer<FX_FILESIZE> save_pos(&m_Pos);
       m_Pos = dwSignValuePos;
-      pDict->SetFor("Contents", GetObject(pObjList, objnum, gennum, false));
+      pDict->SetFor("Contents",
+                    GetObject(pObjList, objnum, gennum, false).release());
     }
 
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(nullptr);
     if (nextword != "stream") {
       m_Pos = SavedPos;
-      return pDict.release();
+      return std::move(pDict);
     }
     return ReadStream(pDict.release(), objnum, gennum);
   }
 
   if (word == ">>")
     m_Pos = SavedObjPos;
 
   return nullptr;
 }
 
-CPDF_Object* CPDF_SyntaxParser::GetObjectForStrict(
+std::unique_ptr<CPDF_Object> CPDF_SyntaxParser::GetObjectForStrict(
     CPDF_IndirectObjectHolder* pObjList,
     uint32_t objnum,
     uint32_t gennum) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth)
     return nullptr;
 
   FX_FILESIZE SavedObjPos = m_Pos;
   bool bIsNumber;
   CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0)
     return nullptr;
 
   if (bIsNumber) {
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(&bIsNumber);
     if (bIsNumber) {
       CFX_ByteString nextword2 = GetNextWord(nullptr);
-      if (nextword2 == "R")
-        return new CPDF_Reference(pObjList, FXSYS_atoui(word.c_str()));
+      if (nextword2 == "R") {
+        return pdfium::MakeUnique<CPDF_Reference>(pObjList,
+                                                  FXSYS_atoui(word.c_str()));
+      }
     }
     m_Pos = SavedPos;
-    return new CPDF_Number(word.AsStringC());
+    return pdfium::MakeUnique<CPDF_Number>(word.AsStringC());
   }
 
   if (word == "true" || word == "false")
-    return new CPDF_Boolean(word == "true");
+    return pdfium::MakeUnique<CPDF_Boolean>(word == "true");
 
   if (word == "null")
-    return new CPDF_Null;
+    return pdfium::MakeUnique<CPDF_Null>();
 
   if (word == "(") {
     CFX_ByteString str = ReadString();
     if (m_pCryptoHandler)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
-    return new CPDF_String(MaybeIntern(str), false);
+    return pdfium::MakeUnique<CPDF_String>(MaybeIntern(str), false);
   }
-
   if (word == "<") {
     CFX_ByteString str = ReadHexString();
     if (m_pCryptoHandler)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
-    return new CPDF_String(MaybeIntern(str), true);
+    return pdfium::MakeUnique<CPDF_String>(MaybeIntern(str), true);
   }
-
   if (word == "[") {
-    std::unique_ptr<CPDF_Array> pArray(new CPDF_Array);
-    while (CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, true))
-      pArray->Add(pObj);
-
-    return m_WordBuffer[0] == ']' ? pArray.release() : nullptr;
+    std::unique_ptr<CPDF_Array> pArray = pdfium::MakeUnique<CPDF_Array>();
+    while (std::unique_ptr<CPDF_Object> pObj =
+               GetObject(pObjList, objnum, gennum, true)) {
+      pArray->Add(pObj.release());
+    }
+    return m_WordBuffer[0] == ']' ? std::move(pArray) : nullptr;
   }
-
   if (word[0] == '/') {
-    return new CPDF_Name(MaybeIntern(
+    return pdfium::MakeUnique<CPDF_Name>(MaybeIntern(
         PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1))));
   }
-
   if (word == "<<") {
-    std::unique_ptr<CPDF_Dictionary> pDict(new CPDF_Dictionary(m_pPool));
+    std::unique_ptr<CPDF_Dictionary> pDict =
+        pdfium::MakeUnique<CPDF_Dictionary>(m_pPool);
     while (1) {
       FX_FILESIZE SavedPos = m_Pos;
       CFX_ByteString key = GetNextWord(nullptr);
       if (key.IsEmpty())
         return nullptr;
 
       if (key == ">>")
         break;
 
       if (key == "endobj") {
         m_Pos = SavedPos;
         break;
       }
-
       if (key[0] != '/')
         continue;
 
       key = PDF_NameDecode(key);
       std::unique_ptr<CPDF_Object> obj(
           GetObject(pObjList, objnum, gennum, true));
       if (!obj) {
         uint8_t ch;
         while (GetNextChar(ch) && ch != 0x0A && ch != 0x0D) {
           continue;
         }
         return nullptr;
       }
 
       if (key.GetLength() > 1) {
         pDict->SetFor(CFX_ByteString(key.c_str() + 1, key.GetLength() - 1),
                       obj.release());
       }
     }
 
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(nullptr);
     if (nextword != "stream") {
       m_Pos = SavedPos;
-      return pDict.release();
+      return std::move(pDict);
     }
 
     return ReadStream(pDict.release(), objnum, gennum);
   }
 
   if (word == ">>")
     m_Pos = SavedObjPos;
 
   return nullptr;
 }
 
 unsigned int CPDF_SyntaxParser::ReadEOLMarkers(FX_FILESIZE pos) {
   unsigned char byte1 = 0;
   unsigned char byte2 = 0;
 
   GetCharAt(pos, byte1);
   GetCharAt(pos + 1, byte2);
 
   if (byte1 == '\r' && byte2 == '\n')
     return 2;
 
   if (byte1 == '\r' || byte1 == '\n')
     return 1;
 
   return 0;
 }
 
-CPDF_Stream* CPDF_SyntaxParser::ReadStream(CPDF_Dictionary* pDict,
-                                           uint32_t objnum,
-                                           uint32_t gennum) {
+std::unique_ptr<CPDF_Stream> CPDF_SyntaxParser::ReadStream(
+    CPDF_Dictionary* pDict,
+    uint32_t objnum,
+    uint32_t gennum) {
   CPDF_Object* pLenObj = pDict->GetObjectFor("Length");
   FX_FILESIZE len = -1;
   CPDF_Reference* pLenObjRef = ToReference(pLenObj);
 
   bool differingObjNum = !pLenObjRef || (pLenObjRef->GetObjList() &&
                                          pLenObjRef->GetRefObjNum() != objnum);
   if (pLenObj && differingObjNum)
     len = pLenObj->GetInteger();
 
   // Locate the start of stream.
@@ skipping 115 matching lines @@
       pCryptoHandler->DecryptStream(context, pData, len, dest_buf);
       pCryptoHandler->DecryptFinish(context, dest_buf);
 
       FX_Free(pData);
       pData = dest_buf.GetBuffer();
       len = dest_buf.GetSize();
       dest_buf.DetachBuffer();
     }
   }
 
-  CPDF_Stream* pStream = new CPDF_Stream(pData, len, pDict);
+  auto pStream = pdfium::MakeUnique<CPDF_Stream>(pData, len, pDict);
   streamStartPos = m_Pos;
   FXSYS_memset(m_WordBuffer, 0, kEndObjStr.GetLength() + 1);
-
   GetNextWordInternal(nullptr);
 
   int numMarkers = ReadEOLMarkers(m_Pos);
   if (m_WordSize == static_cast<unsigned int>(kEndObjStr.GetLength()) &&
       numMarkers != 0 &&
       FXSYS_memcmp(m_WordBuffer, kEndObjStr.raw_str(),
                    kEndObjStr.GetLength()) == 0) {
     m_Pos = streamStartPos;
   }
   return pStream;
@@ skipping 148 matching lines @@
 }
 
 void CPDF_SyntaxParser::SetEncrypt(
     std::unique_ptr<CPDF_CryptoHandler> pCryptoHandler) {
   m_pCryptoHandler = std::move(pCryptoHandler);
 }
 
 CFX_ByteString CPDF_SyntaxParser::MaybeIntern(const CFX_ByteString& str) {
   return m_pPool ? m_pPool->Intern(str) : str;
 }