Use more unique_ptrs in CPDF_SyntaxParser and CPDF_Annot

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 <algorithm>
 #include <utility>
@@ skipping 459 matching lines @@
       m_Pos = dwSignValuePos;
       pDict->SetFor("Contents", GetObject(pObjList, objnum, gennum, false));
     }
 
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(nullptr);
     if (nextword != "stream") {
       m_Pos = SavedPos;
       return std::move(pDict);
     }
-    return ReadStream(pDict.release(), objnum, gennum);
+    return ReadStream(std::move(pDict), objnum, gennum);
   }
-
   if (word == ">>")
     m_Pos = SavedObjPos;
 
   return nullptr;
 }
 
 std::unique_ptr<CPDF_Object> CPDF_SyntaxParser::GetObjectForStrict(
     CPDF_IndirectObjectHolder* pObjList,
     uint32_t objnum,
     uint32_t gennum) {
@@ skipping 87 matching lines @@
                       std::move(obj));
       }
     }
 
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(nullptr);
     if (nextword != "stream") {
       m_Pos = SavedPos;
       return std::move(pDict);
     }
-
-    return ReadStream(pDict.release(), objnum, gennum);
+    return ReadStream(std::move(pDict), 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;
 }
 
 std::unique_ptr<CPDF_Stream> CPDF_SyntaxParser::ReadStream(
-    CPDF_Dictionary* pDict,
+    std::unique_ptr<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();
@@ skipping 58 matching lines @@
 
         // Stop searching when "endobj" is found.
         if (IsWholeWord(m_Pos - kEndObjStr.GetLength(), m_FileLen, kEndObjStr,
                         true)) {
           endObjOffset = m_Pos - streamStartPos - kEndObjStr.GetLength();
           break;
         }
       }
 
       // Can't find "endstream" or "endobj".
-      if (endStreamOffset < 0 && endObjOffset < 0) {
-        delete pDict;
+      if (endStreamOffset < 0 && endObjOffset < 0)
         return nullptr;
-      }
 
       if (endStreamOffset < 0 && endObjOffset >= 0) {
         // Correct the position of end stream.
         endStreamOffset = endObjOffset;
       } else if (endStreamOffset >= 0 && endObjOffset < 0) {
         // Correct the position of end obj.
         endObjOffset = endStreamOffset;
       } else if (endStreamOffset > endObjOffset) {
         endStreamOffset = endObjOffset;
       }
+      len = endStreamOffset;
 
-      len = endStreamOffset;
       int numMarkers = ReadEOLMarkers(streamStartPos + endStreamOffset - 2);
       if (numMarkers == 2) {
         len -= 2;
       } else {
         numMarkers = ReadEOLMarkers(streamStartPos + endStreamOffset - 1);
         if (numMarkers == 1) {
           len -= 1;
         }
       }
+      if (len < 0)
+        return nullptr;
 
-      if (len < 0) {
-        delete pDict;
-        return nullptr;
-      }
       pDict->SetNewFor<CPDF_Number>("Length", static_cast<int>(len));
     }
     m_Pos = streamStartPos;
   }
-
-  if (len < 0) {
-    delete pDict;
+  if (len < 0)
     return nullptr;
-  }
 
   uint8_t* pData = nullptr;
   if (len > 0) {
     pData = FX_Alloc(uint8_t, len);
     ReadBlock(pData, len);
     if (pCryptoHandler) {
       CFX_BinaryBuf dest_buf;
       dest_buf.EstimateSize(pCryptoHandler->DecryptGetSize(len));
 
       void* context = pCryptoHandler->DecryptStart(objnum, gennum);
       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();
     }
   }
 
-  auto pStream =
-      pdfium::MakeUnique<CPDF_Stream>(pData, len, pdfium::WrapUnique(pDict));
+  auto pStream = pdfium::MakeUnique<CPDF_Stream>(pData, len, std::move(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;
@@ skipping 146 matching lines @@
     if (limit && m_Pos == limit)
       return -1;
   }
   return -1;
 }
 
 void CPDF_SyntaxParser::SetEncrypt(
     std::unique_ptr<CPDF_CryptoHandler> pCryptoHandler) {
   m_pCryptoHandler = std::move(pCryptoHandler);
 }