Remove some WrapUnique() calls by returing unique_ptrs

core/fpdfapi/page/cpdf_streamparser.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/page/pageint.h"
 
 #include <limits.h>
 
+#include <memory>
 #include <utility>
 
 #include "core/fpdfapi/cpdf_modulemgr.h"
 #include "core/fpdfapi/page/cpdf_docpagedata.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_boolean.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_null.h"
@@ skipping 84 matching lines @@
   dest_buf = 0;
   return (uint32_t)-1;
 }
 
 }  // namespace
 
 CPDF_StreamParser::CPDF_StreamParser(const uint8_t* pData, uint32_t dwSize)
     : m_pBuf(pData),
       m_Size(dwSize),
       m_Pos(0),
-      m_pLastObj(nullptr),
       m_pPool(nullptr) {}
 
 CPDF_StreamParser::CPDF_StreamParser(
     const uint8_t* pData,
     uint32_t dwSize,
     const CFX_WeakPtr<CFX_ByteStringPool>& pPool)
     : m_pBuf(pData),
       m_Size(dwSize),
       m_Pos(0),
-      m_pLastObj(nullptr),
       m_pPool(pPool) {}
 
-CPDF_StreamParser::~CPDF_StreamParser() {
-  delete m_pLastObj;
-}
+CPDF_StreamParser::~CPDF_StreamParser() {}
 
-CPDF_Stream* CPDF_StreamParser::ReadInlineStream(CPDF_Document* pDoc,
-                                                 CPDF_Dictionary* pDict,
-                                                 CPDF_Object* pCSObj) {
+std::unique_ptr<CPDF_Stream> CPDF_StreamParser::ReadInlineStream(
+    CPDF_Document* pDoc,
+    CPDF_Dictionary* pDict,
+    CPDF_Object* pCSObj) {
   if (m_Pos == m_Size)
     return nullptr;
 
   if (PDFCharIsWhitespace(m_pBuf[m_Pos]))
     m_Pos++;
 
   CFX_ByteString Decoder;
   CPDF_Dictionary* pParam = nullptr;
   CPDF_Object* pFilter = pDict->GetDirectObjectFor("Filter");
   if (pFilter) {
@@ skipping 81 matching lines @@
         break;
       }
       dwStreamSize += m_Pos - dwPrevPos;
     }
     m_Pos = dwSavePos;
     pData = FX_Alloc(uint8_t, dwStreamSize);
     FXSYS_memcpy(pData, m_pBuf + m_Pos, dwStreamSize);
     m_Pos += dwStreamSize;
   }
   pDict->SetNewFor<CPDF_Number>("Length", (int)dwStreamSize);
-  return new CPDF_Stream(pData, dwStreamSize, pdfium::WrapUnique(pDict));
+  return pdfium::MakeUnique<CPDF_Stream>(pData, dwStreamSize,
+                                         pdfium::WrapUnique(pDict));
 }
 
 CPDF_StreamParser::SyntaxType CPDF_StreamParser::ParseNextElement() {
-  delete m_pLastObj;
-  m_pLastObj = nullptr;
-
+  m_pLastObj.reset();
   m_WordSize = 0;
-  bool bIsNumber = true;
   if (!PositionIsInBounds())
     return EndOfData;
 
   int ch = m_pBuf[m_Pos++];
   while (1) {
     while (PDFCharIsWhitespace(ch)) {
       if (!PositionIsInBounds())
         return EndOfData;
 
       ch = m_pBuf[m_Pos++];
@@ skipping 11 matching lines @@
         break;
     }
   }
 
   if (PDFCharIsDelimiter(ch) && ch != '/') {
     m_Pos--;
     m_pLastObj = ReadNextObject(false, 0);
     return Others;
   }
 
+  bool bIsNumber = true;
   while (1) {
     if (m_WordSize < kMaxWordBuffer)
       m_WordBuffer[m_WordSize++] = ch;
 
     if (!PDFCharIsNumeric(ch))
       bIsNumber = false;
 
     if (!PositionIsInBounds())
       break;
 
     ch = m_pBuf[m_Pos++];
 
     if (PDFCharIsDelimiter(ch) || PDFCharIsWhitespace(ch)) {
       m_Pos--;
       break;
     }
   }
 
   m_WordBuffer[m_WordSize] = 0;
   if (bIsNumber)
     return Number;
 
   if (m_WordBuffer[0] == '/')
     return Name;
 
   if (m_WordSize == 4) {
     if (memcmp(m_WordBuffer, "true", 4) == 0) {
-      m_pLastObj = new CPDF_Boolean(true);
+      m_pLastObj = pdfium::MakeUnique<CPDF_Boolean>(true);
       return Others;
     }
     if (memcmp(m_WordBuffer, "null", 4) == 0) {
-      m_pLastObj = new CPDF_Null;
+      m_pLastObj = pdfium::MakeUnique<CPDF_Null>();
       return Others;
     }
   } else if (m_WordSize == 5) {
     if (memcmp(m_WordBuffer, "false", 5) == 0) {
-      m_pLastObj = new CPDF_Boolean(false);
+      m_pLastObj = pdfium::MakeUnique<CPDF_Boolean>(false);
       return Others;
     }
   }
   return Keyword;
 }
 
-CPDF_Object* CPDF_StreamParser::GetObject() {
-  CPDF_Object* pObj = m_pLastObj;
-  m_pLastObj = nullptr;
-  return pObj;
-}
-
-CPDF_Object* CPDF_StreamParser::ReadNextObject(bool bAllowNestedArray,
-                                               uint32_t dwInArrayLevel) {
+std::unique_ptr<CPDF_Object> CPDF_StreamParser::ReadNextObject(
+    bool bAllowNestedArray,
+    uint32_t dwInArrayLevel) {
   bool bIsNumber;
   GetNextWord(bIsNumber);
   if (!m_WordSize)
     return nullptr;
 
   if (bIsNumber) {
     m_WordBuffer[m_WordSize] = 0;
-    return new CPDF_Number(CFX_ByteStringC(m_WordBuffer, m_WordSize));
+    return pdfium::MakeUnique<CPDF_Number>(
+        CFX_ByteStringC(m_WordBuffer, m_WordSize));
   }
 
   int first_char = m_WordBuffer[0];
   if (first_char == '/') {
     CFX_ByteString name =
         PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1));
-    return new CPDF_Name(m_pPool, name);
+    return pdfium::MakeUnique<CPDF_Name>(m_pPool, name);
   }
 
   if (first_char == '(') {
     CFX_ByteString str = ReadString();
-    return new CPDF_String(m_pPool, str, false);
+    return pdfium::MakeUnique<CPDF_String>(m_pPool, str, false);
   }
 
   if (first_char == '<') {
     if (m_WordSize == 1)
-      return new CPDF_String(m_pPool, ReadHexString(), true);
+      return pdfium::MakeUnique<CPDF_String>(m_pPool, ReadHexString(), true);
 
-    CPDF_Dictionary* pDict = new CPDF_Dictionary(m_pPool);
+    auto pDict = pdfium::MakeUnique<CPDF_Dictionary>(m_pPool);
     while (1) {
       GetNextWord(bIsNumber);
       if (m_WordSize == 2 && m_WordBuffer[0] == '>')
         break;
 
-      if (!m_WordSize || m_WordBuffer[0] != '/') {
-        delete pDict;
+      if (!m_WordSize || m_WordBuffer[0] != '/')
         return nullptr;
-      }
 
       CFX_ByteString key =
           PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1));
-      auto pObj = pdfium::WrapUnique(ReadNextObject(true, 0));
-      if (!pObj) {
-        delete pDict;
+      std::unique_ptr<CPDF_Object> pObj = ReadNextObject(true, 0);
+      if (!pObj)
         return nullptr;
-      }
+
       if (!key.IsEmpty())
         pDict->SetFor(key, std::move(pObj));
     }
-    return pDict;
+    return std::move(pDict);
   }
 
   if (first_char == '[') {
     if ((!bAllowNestedArray && dwInArrayLevel) ||
         dwInArrayLevel > kMaxNestedArrayLevel) {
       return nullptr;
     }
 
-    CPDF_Array* pArray = new CPDF_Array;
+    auto pArray = pdfium::MakeUnique<CPDF_Array>();
     while (1) {
-      CPDF_Object* pObj = ReadNextObject(bAllowNestedArray, dwInArrayLevel + 1);
+      std::unique_ptr<CPDF_Object> pObj =
+          ReadNextObject(bAllowNestedArray, dwInArrayLevel + 1);
       if (pObj) {
-        pArray->Add(pdfium::WrapUnique(pObj));
+        pArray->Add(std::move(pObj));
         continue;
       }
       if (!m_WordSize || m_WordBuffer[0] == ']')
         break;
     }
-    return pArray;
+    return std::move(pArray);
   }
 
   if (m_WordSize == 5 && !memcmp(m_WordBuffer, "false", 5))
-    return new CPDF_Boolean(false);
+    return pdfium::MakeUnique<CPDF_Boolean>(false);
 
   if (m_WordSize == 4) {
     if (memcmp(m_WordBuffer, "true", 4) == 0)
-      return new CPDF_Boolean(true);
-
+      return pdfium::MakeUnique<CPDF_Boolean>(true);
     if (memcmp(m_WordBuffer, "null", 4) == 0)
-      return new CPDF_Null;
+      return pdfium::MakeUnique<CPDF_Null>();
   }
 
   return nullptr;
 }
 
 // TODO(npm): the following methods are almost identical in cpdf_syntaxparser
 void CPDF_StreamParser::GetNextWord(bool& bIsNumber) {
   m_WordSize = 0;
   bIsNumber = true;
   if (!PositionIsInBounds())
@@ skipping 201 matching lines @@
 
   if (buf.GetLength() > kMaxStringLength)
     return CFX_ByteString(buf.GetBuffer(), kMaxStringLength);
 
   return buf.MakeString();
 }
 
 bool CPDF_StreamParser::PositionIsInBounds() const {
   return m_Pos < m_Size;
 }