Split CPDF_PageObjectHolder off from CPDF_PageObjectList

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 96 matching lines @@
     }
   }
   return false;
 }
 
 CPDF_StreamContentParser::CPDF_StreamContentParser(
     CPDF_Document* pDocument,
     CPDF_Dictionary* pPageResources,
     CPDF_Dictionary* pParentResources,
     CFX_Matrix* pmtContentToUser,
-    CPDF_PageObjectList* pObjList,
+    CPDF_PageObjectHolder* pObjHolder,
     CPDF_Dictionary* pResources,
     CPDF_Rect* pBBox,
     CPDF_ParseOptions* pOptions,
     CPDF_AllStates* pStates,
     int level)
     : m_pDocument(pDocument),
       m_pPageResources(pPageResources),
       m_pParentResources(pParentResources),
       m_pResources(pResources),
-      m_pObjectList(pObjList),
+      m_pObjectHolder(pObjHolder),
       m_Level(level),
       m_ParamStartPos(0),
       m_ParamCount(0),
       m_pCurStates(new CPDF_AllStates),
       m_pLastTextObject(nullptr),
       m_DefFontSize(0),
       m_pPathPoints(nullptr),
       m_PathPointCount(0),
       m_PathAllocSize(0),
       m_PathCurrentX(0.0f),
@@ skipping 593 matching lines @@
   CFX_ByteStringC type = pXObject->GetDict()
                              ? pXObject->GetDict()->GetConstStringBy("Subtype")
                              : CFX_ByteStringC();
   if (type == "Image") {
     if (m_Options.m_bTextOnly) {
       return;
     }
     CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
     m_LastImageName = name;
     m_pLastImage = pObj->m_pImage;
-    if (!m_pObjectList->HasImageMask())
-      m_pObjectList->SetHasImageMask(m_pLastImage->IsMask());
+    if (!m_pObjectHolder->HasImageMask())
+      m_pObjectHolder->SetHasImageMask(m_pLastImage->IsMask());
   } else if (type == "Form") {
     AddForm(pXObject);
   } else {
     return;
   }
 }
 
 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
   if (!m_Options.m_bSeparateForm) {
     CPDF_Dictionary* pResources = pStream->GetDict()->GetDictBy("Resources");
     CFX_Matrix form_matrix = pStream->GetDict()->GetMatrixBy("Matrix");
     form_matrix.Concat(m_pCurStates->m_CTM);
     CPDF_Array* pBBox = pStream->GetDict()->GetArrayBy("BBox");
     CFX_FloatRect form_bbox;
     CPDF_Path ClipPath;
     if (pBBox) {
       form_bbox = pStream->GetDict()->GetRectBy("BBox");
       ClipPath.New();
       ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right,
                           form_bbox.top);
       ClipPath.Transform(&form_matrix);
       form_bbox.Transform(&form_matrix);
     }
     CPDF_StreamContentParser parser(m_pDocument, m_pPageResources, m_pResources,
-                                    &m_mtContentToUser, m_pObjectList,
+                                    &m_mtContentToUser, m_pObjectHolder,
                                     pResources, &form_bbox, &m_Options,
                                     m_pCurStates.get(), m_Level + 1);
     parser.m_pCurStates->m_CTM = form_matrix;
     if (ClipPath.NotNull()) {
       parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING,
                                                  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;
   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_pObjectList->BackgroundAlphaNeeded() &&
+  if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
       pFormObj->m_pForm->BackgroundAlphaNeeded()) {
-    m_pObjectList->SetBackgroundAlphaNeeded(TRUE);
+    m_pObjectHolder->SetBackgroundAlphaNeeded(TRUE);
   }
   pFormObj->CalcBoundingBox();
   SetGraphicStates(pFormObj, TRUE, TRUE, TRUE);
-  m_pObjectList->AddTail(pFormObj);
+  m_pObjectHolder->GetPageObjectList()->AddTail(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;
   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);
   pImageObj->m_Matrix = ImageMatrix;
   pImageObj->CalcBoundingBox();
-  m_pObjectList->AddTail(pImageObj);
+  m_pObjectHolder->GetPageObjectList()->AddTail(pImageObj);
   return pImageObj;
 }
 
 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
 
 void CPDF_StreamContentParser::Handle_EndImage() {}
 
 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
   if (!m_Options.m_bMarkedContent) {
     return;
@@ skipping 368 matching lines @@
   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_pObjectList->AddTail(pObj);
+  m_pObjectHolder->GetPageObjectList()->AddTail(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 157 matching lines @@
   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_pObjectList->AddTail(pText);
+  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 214 matching lines @@
   CFX_Matrix matrix = m_pCurStates->m_CTM;
   matrix.Concat(m_mtContentToUser);
   if (bStroke || FillType) {
     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);
     pPathObj->CalcBoundingBox();
-    m_pObjectList->AddTail(pPathObj);
+    m_pObjectHolder->GetPageObjectList()->AddTail(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_pObjectList->CountObjects();
+  FX_DWORD InitObjCount = m_pObjectHolder->GetPageObjectList()->GetCount();
   CPDF_StreamParser syntax(pData, dwSize);
   CPDF_StreamParserAutoClearer auto_clearer(&m_pSyntax, &syntax);
   m_CompatCount = 0;
   while (1) {
-    FX_DWORD cost = m_pObjectList->CountObjects() - InitObjCount;
+    FX_DWORD cost =
+        m_pObjectHolder->GetPageObjectList()->GetCount() - 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;
   }
 }