Revert of Remove CPDF_Object::Release() in favor of direct delete

core/fpdfapi/page/cpdf_streamcontentparser.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/cpdf_streamcontentparser.h"
 
 #include "core/fpdfapi/font/cpdf_font.h"
 #include "core/fpdfapi/font/cpdf_type3font.h"
@@ skipping 162 matching lines @@
     m_pCurStates->m_ColorState.Emplace();
   }
   for (size_t i = 0; i < FX_ArraySize(m_Type3Data); ++i) {
     m_Type3Data[i] = 0.0;
   }
 }
 
 CPDF_StreamContentParser::~CPDF_StreamContentParser() {
   ClearAllParams();
   FX_Free(m_pPathPoints);
-  delete m_pLastImageDict;
-  delete m_pLastCloneImageDict;
+  if (m_pLastImageDict) {
+    m_pLastImageDict->Release();
+  }
+  if (m_pLastCloneImageDict) {
+    m_pLastCloneImageDict->Release();
+  }
 }
 
 int CPDF_StreamContentParser::GetNextParamPos() {
   if (m_ParamCount == kParamBufSize) {
     m_ParamStartPos++;
     if (m_ParamStartPos == kParamBufSize) {
       m_ParamStartPos = 0;
     }
-    if (m_ParamBuf[m_ParamStartPos].m_Type == 0)
-      delete m_ParamBuf[m_ParamStartPos].m_pObject;
-
+    if (m_ParamBuf[m_ParamStartPos].m_Type == 0) {
+      if (CPDF_Object* pObject = m_ParamBuf[m_ParamStartPos].m_pObject)
+        pObject->Release();
+    }
     return m_ParamStartPos;
   }
   int index = m_ParamStartPos + m_ParamCount;
   if (index >= kParamBufSize) {
     index -= kParamBufSize;
   }
   m_ParamCount++;
   return index;
 }
 
@@ skipping 26 matching lines @@
 
 void CPDF_StreamContentParser::AddObjectParam(CPDF_Object* pObj) {
   ContentParam& param = m_ParamBuf[GetNextParamPos()];
   param.m_Type = ContentParam::OBJECT;
   param.m_pObject = pObj;
 }
 
 void CPDF_StreamContentParser::ClearAllParams() {
   uint32_t index = m_ParamStartPos;
   for (uint32_t i = 0; i < m_ParamCount; i++) {
-    if (m_ParamBuf[index].m_Type == 0)
-      delete m_ParamBuf[index].m_pObject;
-
+    if (m_ParamBuf[index].m_Type == 0) {
+      if (CPDF_Object* pObject = m_ParamBuf[index].m_pObject)
+        pObject->Release();
+    }
     index++;
     if (index == kParamBufSize) {
       index = 0;
     }
   }
   m_ParamStartPos = 0;
   m_ParamCount = 0;
 }
 
 CPDF_Object* CPDF_StreamContentParser::GetObject(uint32_t index) {
@@ skipping 263 matching lines @@
   FX_FILESIZE savePos = m_pSyntax->GetPos();
   CPDF_Dictionary* pDict =
       new CPDF_Dictionary(m_pDocument->GetByteStringPool());
   while (1) {
     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
     if (type == CPDF_StreamParser::Keyword) {
       CFX_ByteString bsKeyword(m_pSyntax->GetWordBuf(),
                                m_pSyntax->GetWordSize());
       if (bsKeyword != "ID") {
         m_pSyntax->SetPos(savePos);
-        delete pDict;
+        pDict->Release();
         return;
       }
     }
     if (type != CPDF_StreamParser::Name) {
       break;
     }
     CFX_ByteString key((const FX_CHAR*)m_pSyntax->GetWordBuf() + 1,
                        m_pSyntax->GetWordSize() - 1);
-    std::unique_ptr<CPDF_Object> pObj(m_pSyntax->ReadNextObject(false, 0));
+    std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
+        m_pSyntax->ReadNextObject(false, 0));
     if (!key.IsEmpty()) {
       uint32_t dwObjNum = pObj ? pObj->GetObjNum() : 0;
       if (dwObjNum)
         pDict->SetReferenceFor(key, m_pDocument, dwObjNum);
       else
         pDict->SetFor(key, pObj.release());
     }
   }
   PDF_ReplaceAbbr(pDict);
   CPDF_Object* pCSObj = nullptr;
   if (pDict->KeyExist("ColorSpace")) {
     pCSObj = pDict->GetDirectObjectFor("ColorSpace");
     if (pCSObj->IsName()) {
       CFX_ByteString name = pCSObj->GetString();
       if (name != "DeviceRGB" && name != "DeviceGray" && name != "DeviceCMYK") {
         pCSObj = FindResourceObj("ColorSpace", name);
         if (pCSObj && pCSObj->IsInline()) {
           pCSObj = pCSObj->Clone();
           pDict->SetFor("ColorSpace", pCSObj);
         }
       }
     }
   }
   pDict->SetNameFor("Subtype", "Image");
-  std::unique_ptr<CPDF_Stream> pStream(
-      m_pSyntax->ReadInlineStream(m_pDocument, pDict, pCSObj));
+  UniqueStream pStream(m_pSyntax->ReadInlineStream(m_pDocument, pDict, pCSObj));
   bool bGaveDictAway = !!pStream;
   while (1) {
     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
     if (type == CPDF_StreamParser::EndOfData) {
       break;
     }
     if (type != CPDF_StreamParser::Keyword) {
       continue;
     }
     if (m_pSyntax->GetWordSize() == 2 && m_pSyntax->GetWordBuf()[0] == 'E' &&
         m_pSyntax->GetWordBuf()[1] == 'I') {
       break;
     }
   }
   CPDF_ImageObject* pImgObj = AddImage(std::move(pStream));
   if (!pImgObj && !bGaveDictAway)
-    delete pDict;
+    pDict->Release();
 }
 
 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
   m_CurContentMark.AddMark(GetString(0), nullptr, false);
 }
 
 void CPDF_StreamContentParser::Handle_BeginText() {
   m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
   OnChangeTextMatrix();
   m_pCurStates->m_TextX = 0;
@@ skipping 65 matching lines @@
   if (!pXObject) {
     m_bResourceMissing = true;
     return;
   }
 
   CFX_ByteString type;
   if (pXObject->GetDict())
     type = pXObject->GetDict()->GetStringFor("Subtype");
 
   if (type == "Image") {
-    CPDF_ImageObject* pObj = pXObject->IsInline()
-                                 ? AddImage(std::unique_ptr<CPDF_Stream>(
-                                       ToStream(pXObject->Clone())))
-                                 : AddImage(pXObject->GetObjNum());
+    CPDF_ImageObject* pObj =
+        pXObject->IsInline()
+            ? AddImage(UniqueStream(ToStream(pXObject->Clone())))
+            : AddImage(pXObject->GetObjNum());
 
     m_LastImageName = name;
     m_pLastImage = pObj->GetImage();
     if (!m_pObjectHolder->HasImageMask())
       m_pObjectHolder->SetHasImageMask(m_pLastImage->IsMask());
   } else if (type == "Form") {
     AddForm(pXObject);
   }
 }
 
@@ skipping 11 matching lines @@
   pFormObj->m_pForm->ParseContent(&status, nullptr, nullptr, m_Level + 1);
   if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
       pFormObj->m_pForm->BackgroundAlphaNeeded()) {
     m_pObjectHolder->SetBackgroundAlphaNeeded(true);
   }
   pFormObj->CalcBoundingBox();
   SetGraphicStates(pFormObj.get(), true, true, true);
   m_pObjectHolder->GetPageObjectList()->push_back(std::move(pFormObj));
 }
 
-CPDF_ImageObject* CPDF_StreamContentParser::AddImage(
-    std::unique_ptr<CPDF_Stream> pStream) {
+CPDF_ImageObject* CPDF_StreamContentParser::AddImage(UniqueStream pStream) {
   if (!pStream)
     return nullptr;
 
   auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
   pImageObj->SetOwnedImage(
       pdfium::MakeUnique<CPDF_Image>(m_pDocument, std::move(pStream)));
   return AddImageObject(std::move(pImageObj));
 }
 
 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(uint32_t streamObjNum) {
@@ skipping 837 matching lines @@
       }
       default:
         bProcessed = false;
     }
     if (!bProcessed) {
       m_pSyntax->SetPos(last_pos);
       return;
     }
   }
 }