Remove CFX_PtrList from renderer main loop.

core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp

 // Copyright 2014 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/src/fpdfapi/fpdf_page/pageint.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_page.h"
@@ skipping 762 matching lines @@
                                                  TRUE);
     }
     CPDF_StreamAcc stream;
     stream.LoadAllData(pStream, FALSE);
     if (stream.GetSize() == 0) {
       return;
     }
     parser.Parse(stream.GetData(), stream.GetSize(), 0);
     return;
   }
-  CPDF_FormObject* pFormObj = new CPDF_FormObject;
+  std::unique_ptr<CPDF_FormObject> pFormObj(new CPDF_FormObject);
   pFormObj->m_pForm =
       new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources);
   pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
   pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
   CPDF_AllStates status;
   status.m_GeneralState = m_pCurStates->m_GeneralState;
   status.m_GraphState = m_pCurStates->m_GraphState;
   status.m_ColorState = m_pCurStates->m_ColorState;
   status.m_TextState = m_pCurStates->m_TextState;
   pFormObj->m_pForm->ParseContent(&status, NULL, NULL, &m_Options, m_Level + 1);
   if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
       pFormObj->m_pForm->BackgroundAlphaNeeded()) {
     m_pObjectHolder->SetBackgroundAlphaNeeded(TRUE);
   }
   pFormObj->CalcBoundingBox();
-  SetGraphicStates(pFormObj, TRUE, TRUE, TRUE);
-  m_pObjectHolder->GetPageObjectList()->AddTail(pFormObj);
+  SetGraphicStates(pFormObj.get(), TRUE, TRUE, TRUE);
+  m_pObjectHolder->GetPageObjectList()->push_back(std::move(pFormObj));
 }
 
 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream,
                                                      CPDF_Image* pImage,
                                                      FX_BOOL bInline) {
   if (!pStream && !pImage) {
     return NULL;
   }
   CFX_Matrix ImageMatrix;
   ImageMatrix.Copy(m_pCurStates->m_CTM);
   ImageMatrix.Concat(m_mtContentToUser);
-  CPDF_ImageObject* pImageObj = new CPDF_ImageObject;
+
+  std::unique_ptr<CPDF_ImageObject> pImageObj(new CPDF_ImageObject);
   if (pImage) {
     pImageObj->m_pImage =
         m_pDocument->GetPageData()->GetImage(pImage->GetStream());
   } else if (pStream->GetObjNum()) {
     pImageObj->m_pImage = m_pDocument->LoadImageF(pStream);
   } else {
     pImageObj->m_pImage = new CPDF_Image(m_pDocument);
     pImageObj->m_pImage->LoadImageF(pStream, bInline);
   }
-  SetGraphicStates(pImageObj, pImageObj->m_pImage->IsMask(), FALSE, FALSE);
+  SetGraphicStates(pImageObj.get(), pImageObj->m_pImage->IsMask(), FALSE,
+                   FALSE);
   pImageObj->m_Matrix = ImageMatrix;
   pImageObj->CalcBoundingBox();
-  m_pObjectHolder->GetPageObjectList()->AddTail(pImageObj);
-  return pImageObj;
+  CPDF_ImageObject* pRet = pImageObj.get();
+  m_pObjectHolder->GetPageObjectList()->push_back(std::move(pImageObj));
+  return pRet;
 }
 
 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
 
 void CPDF_StreamContentParser::Handle_EndImage() {}
 
 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
   if (!m_Options.m_bMarkedContent) {
     return;
   }
@@ skipping 346 matching lines @@
   if (pPattern->m_PatternType != CPDF_Pattern::SHADING) {
     return;
   }
   CPDF_ShadingPattern* pShading = static_cast<CPDF_ShadingPattern*>(pPattern);
   if (!pShading->m_bShadingObj) {
     return;
   }
   if (!pShading->Load()) {
     return;
   }
-  CPDF_ShadingObject* pObj = new CPDF_ShadingObject;
+  std::unique_ptr<CPDF_ShadingObject> pObj(new CPDF_ShadingObject);
   pObj->m_pShading = pShading;
-  SetGraphicStates(pObj, FALSE, FALSE, FALSE);
+  SetGraphicStates(pObj.get(), FALSE, FALSE, FALSE);
   pObj->m_Matrix = m_pCurStates->m_CTM;
   pObj->m_Matrix.Concat(m_mtContentToUser);
   CFX_FloatRect bbox;
   if (!pObj->m_ClipPath.IsNull()) {
     bbox = pObj->m_ClipPath.GetClipBox();
   } else {
     bbox = m_BBox;
   }
   if (pShading->IsMeshShading()) {
     bbox.Intersect(GetShadingBBox(ToStream(pShading->m_pShadingObj),
                                   pShading->m_ShadingType, &pObj->m_Matrix,
                                   pShading->m_pFunctions, pShading->m_nFuncs,
                                   pShading->m_pCS));
   }
   pObj->m_Left = bbox.left;
   pObj->m_Right = bbox.right;
   pObj->m_Top = bbox.top;
   pObj->m_Bottom = bbox.bottom;
-  m_pObjectHolder->GetPageObjectList()->AddTail(pObj);
+  m_pObjectHolder->GetPageObjectList()->push_back(std::move(pObj));
 }
 
 void CPDF_StreamContentParser::Handle_SetCharSpace() {
   m_pCurStates->m_TextState.GetModify()->m_CharSpace = GetNumber(0);
 }
 
 void CPDF_StreamContentParser::Handle_MoveTextPoint() {
   m_pCurStates->m_TextLineX += GetNumber(1);
   m_pCurStates->m_TextLineY += GetNumber(0);
   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
@@ skipping 133 matching lines @@
   }
   if (nsegs == 0) {
     return;
   }
   int textmode;
   if (pFont->GetFontType() == PDFFONT_TYPE3) {
     textmode = 0;
   } else {
     textmode = m_pCurStates->m_TextState.GetObject()->m_TextMode;
   }
-  CPDF_TextObject* pText = new CPDF_TextObject;
-  m_pLastTextObject = pText;
-  SetGraphicStates(pText, TRUE, TRUE, TRUE);
-  if (textmode && textmode != 3 && textmode != 4 && textmode != 7) {
-    FX_FLOAT* pCTM = pText->m_TextState.GetModify()->m_CTM;
-    pCTM[0] = m_pCurStates->m_CTM.a;
-    pCTM[1] = m_pCurStates->m_CTM.c;
-    pCTM[2] = m_pCurStates->m_CTM.b;
-    pCTM[3] = m_pCurStates->m_CTM.d;
+  {
+    std::unique_ptr<CPDF_TextObject> pText(new CPDF_TextObject);
+    m_pLastTextObject = pText.get();
+    SetGraphicStates(m_pLastTextObject, TRUE, TRUE, TRUE);
+    if (textmode && textmode != 3 && textmode != 4 && textmode != 7) {
+      FX_FLOAT* pCTM = pText->m_TextState.GetModify()->m_CTM;
+      pCTM[0] = m_pCurStates->m_CTM.a;
+      pCTM[1] = m_pCurStates->m_CTM.c;
+      pCTM[2] = m_pCurStates->m_CTM.b;
+      pCTM[3] = m_pCurStates->m_CTM.d;
+    }
+    pText->SetSegments(pStrs, pKerning, nsegs);
+    pText->m_PosX = m_pCurStates->m_TextX;
+    pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
+    ConvertTextSpace(pText->m_PosX, pText->m_PosY);
+    FX_FLOAT x_advance;
+    FX_FLOAT y_advance;
+    pText->CalcPositionData(&x_advance, &y_advance,
+                            m_pCurStates->m_TextHorzScale, m_Level);
+    m_pCurStates->m_TextX += x_advance;
+    m_pCurStates->m_TextY += y_advance;
+    if (textmode > 3) {
+      CPDF_TextObject* pCopy = new CPDF_TextObject;
+      pCopy->Copy(pText.get());
+      m_ClipTextList.Add(pCopy);
+    }
+    m_pObjectHolder->GetPageObjectList()->push_back(std::move(pText));
   }
-  pText->SetSegments(pStrs, pKerning, nsegs);
-  pText->m_PosX = m_pCurStates->m_TextX;
-  pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
-  ConvertTextSpace(pText->m_PosX, pText->m_PosY);
-  FX_FLOAT x_advance, y_advance;
-  pText->CalcPositionData(&x_advance, &y_advance, m_pCurStates->m_TextHorzScale,
-                          m_Level);
-  m_pCurStates->m_TextX += x_advance;
-  m_pCurStates->m_TextY += y_advance;
-  if (textmode > 3) {
-    CPDF_TextObject* pCopy = new CPDF_TextObject;
-    pCopy->Copy(pText);
-    m_ClipTextList.Add(pCopy);
-  }
-  m_pObjectHolder->GetPageObjectList()->AddTail(pText);
   if (pKerning && pKerning[nsegs - 1] != 0) {
     if (!pFont->IsVertWriting()) {
       m_pCurStates->m_TextX -=
           FXSYS_Mul(pKerning[nsegs - 1],
                     m_pCurStates->m_TextState.GetFontSize()) /
           1000;
     } else {
       m_pCurStates->m_TextY -=
           FXSYS_Mul(pKerning[nsegs - 1],
                     m_pCurStates->m_TextState.GetFontSize()) /
@@ skipping 207 matching lines @@
     PathPointCount--;
   }
   CPDF_Path Path;
   CFX_PathData* pPathData = Path.New();
   pPathData->SetPointCount(PathPointCount);
   FXSYS_memcpy(pPathData->GetPoints(), m_pPathPoints,
                sizeof(FX_PATHPOINT) * PathPointCount);
   CFX_Matrix matrix = m_pCurStates->m_CTM;
   matrix.Concat(m_mtContentToUser);
   if (bStroke || FillType) {
-    CPDF_PathObject* pPathObj = new CPDF_PathObject;
+    std::unique_ptr<CPDF_PathObject> pPathObj(new CPDF_PathObject);
     pPathObj->m_bStroke = bStroke;
     pPathObj->m_FillType = FillType;
     pPathObj->m_Path = Path;
     pPathObj->m_Matrix = matrix;
-    SetGraphicStates(pPathObj, TRUE, FALSE, TRUE);
+    SetGraphicStates(pPathObj.get(), TRUE, FALSE, TRUE);
     pPathObj->CalcBoundingBox();
-    m_pObjectHolder->GetPageObjectList()->AddTail(pPathObj);
+    m_pObjectHolder->GetPageObjectList()->push_back(std::move(pPathObj));
   }
   if (PathClipType) {
     if (!matrix.IsIdentity()) {
       Path.Transform(&matrix);
       matrix.SetIdentity();
     }
     m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
   }
 }
 
 FX_DWORD CPDF_StreamContentParser::Parse(const uint8_t* pData,
                                          FX_DWORD dwSize,
                                          FX_DWORD max_cost) {
   if (m_Level > _FPDF_MAX_FORM_LEVEL_) {
     return dwSize;
   }
-  FX_DWORD InitObjCount = m_pObjectHolder->GetPageObjectList()->GetCount();
+  FX_DWORD InitObjCount = m_pObjectHolder->GetPageObjectList()->size();
   CPDF_StreamParser syntax(pData, dwSize);
   CPDF_StreamParserAutoClearer auto_clearer(&m_pSyntax, &syntax);
   m_CompatCount = 0;
   while (1) {
-    FX_DWORD cost =
-        m_pObjectHolder->GetPageObjectList()->GetCount() - InitObjCount;
+    FX_DWORD cost = m_pObjectHolder->GetPageObjectList()->size() - InitObjCount;
     if (max_cost && cost >= max_cost) {
       break;
     }
     switch (syntax.ParseNextElement()) {
       case CPDF_StreamParser::EndOfData:
         return m_pSyntax->GetPos();
       case CPDF_StreamParser::Keyword:
         OnOperator((char*)syntax.GetWordBuf());
         ClearAllParams();
         break;
@@ skipping 153 matching lines @@
         } else {
           PDF_ReplaceAbbr(pElement);
         }
       }
       break;
     }
     default:
       break;
   }
 }