Change _PDF_RenderItem to CPDF_RenderContext::Layer.

core/src/fpdfapi/fpdf_render/fpdf_render.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 "render_int.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_render.h"
@@ skipping 194 matching lines @@
   if (pOptions) {
     m_Options = *pOptions;
   }
   m_bDropObjects = bDropObjects;
   m_bStdCS = bStdCS;
   m_T3FillColor = fill_color;
   m_pType3Char = pType3Char;
   m_GroupFamily = GroupFamily;
   m_bLoadMask = bLoadMask;
   m_pFormResource = pFormResource;
-  m_pPageResource = m_pContext->m_pPageResources;
+  m_pPageResource = m_pContext->GetPageResources();
   if (pInitialStates && !m_pType3Char) {
     m_InitialStates.CopyStates(*pInitialStates);
     if (pParentState) {
       CPDF_ColorStateData* pColorData =
           (CPDF_ColorStateData*)(const CPDF_ColorStateData*)
               m_InitialStates.m_ColorState;
       CPDF_ColorStateData* pParentData =
           (CPDF_ColorStateData*)(const CPDF_ColorStateData*)
               pParentState->m_InitialStates.m_ColorState;
       if (!pColorData || pColorData->m_FillColor.IsNull()) {
@@ skipping 305 matching lines @@
   CFX_GraphStateData graphState(*pPathObj->m_GraphState);
   if (m_Options.m_Flags & RENDER_THINLINE) {
     graphState.m_LineWidth = 0;
   }
   return m_pDevice->DrawPath(pPathObj->m_Path, &path_matrix, &graphState,
                              fill_argb, stroke_argb, FillType, 0, NULL,
                              m_curBlend);
 }
 CPDF_TransferFunc* CPDF_RenderStatus::GetTransferFunc(CPDF_Object* pObj) const {
   ASSERT(pObj);
-  CPDF_DocRenderData* pDocCache = m_pContext->m_pDocument->GetRenderData();
+  CPDF_DocRenderData* pDocCache = m_pContext->GetDocument()->GetRenderData();
   return pDocCache ? pDocCache->GetTransferFunc(pObj) : nullptr;
 }
 FX_ARGB CPDF_RenderStatus::GetFillArgb(const CPDF_PageObject* pObj,
                                        FX_BOOL bType3) const {
   CPDF_ColorStateData* pColorData =
       (CPDF_ColorStateData*)(const CPDF_ColorStateData*)pObj->m_ColorState;
   if (m_pType3Char && !bType3 &&
       (!m_pType3Char->m_bColored ||
        (m_pType3Char->m_bColored &&
         (!pColorData || pColorData->m_FillColor.IsNull())))) {
@@ skipping 199 matching lines @@
   if (pPageObj->m_ClipPath.NotNull() && pPageObj->m_ClipPath.GetTextCount() &&
       m_pDevice->GetDeviceClass() == FXDC_DISPLAY &&
       !(m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_SOFT_CLIP)) {
     bTextClip = TRUE;
   }
   if ((m_Options.m_Flags & RENDER_OVERPRINT) &&
       pPageObj->m_Type == PDFPAGE_IMAGE && pGeneralState &&
       pGeneralState->m_FillOP && pGeneralState->m_StrokeOP) {
     CPDF_Document* pDocument = NULL;
     CPDF_Page* pPage = NULL;
-    if (m_pContext->m_pPageCache) {
-      pPage = m_pContext->m_pPageCache->GetPage();
+    if (m_pContext->GetPageCache()) {
+      pPage = m_pContext->GetPageCache()->GetPage();
       pDocument = pPage->m_pDocument;
     } else {
       pDocument = ((CPDF_ImageObject*)pPageObj)->m_pImage->GetDocument();
     }
     CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : NULL;
     CPDF_Object* pCSObj = ((CPDF_ImageObject*)pPageObj)
                               ->m_pImage->GetStream()
                               ->GetDict()
                               ->GetElementValue("ColorSpace");
     CPDF_ColorSpace* pColorSpace =
@@ skipping 176 matching lines @@
                                   : pSrcStates->m_ColorState.GetFillColor();
   if (!pObjColor->IsNull()) {
     CPDF_ColorStateData* pColorData = pStates->m_ColorState.GetModify();
     pColorData->m_FillRGB =
         bStroke ? pSrcStates->m_ColorState.GetObject()->m_StrokeRGB
                 : pSrcStates->m_ColorState.GetObject()->m_FillRGB;
     pColorData->m_StrokeRGB = pColorData->m_FillRGB;
   }
   return pStates;
 }
+
 CPDF_RenderContext::CPDF_RenderContext(CPDF_Page* pPage)
     : m_pDocument(pPage->m_pDocument),
       m_pPageResources(pPage->m_pPageResources),
       m_pPageCache(pPage->GetRenderCache()),
       m_bFirstLayer(TRUE) {}
+
 CPDF_RenderContext::CPDF_RenderContext(CPDF_Document* pDoc,
                                        CPDF_PageRenderCache* pPageCache)
     : m_pDocument(pDoc),
       m_pPageResources(nullptr),
       m_pPageCache(pPageCache),
       m_bFirstLayer(TRUE) {}
+
 CPDF_RenderContext::~CPDF_RenderContext() {}
-void CPDF_RenderContext::AppendObjectList(CPDF_PageObjectList* pObjs,
-                                          const CFX_Matrix* pObject2Device) {
-  _PDF_RenderItem* pItem = m_ContentList.AddSpace();
-  pItem->m_pObjectList = pObjs;
+
+void CPDF_RenderContext::AppendLayer(CPDF_PageObjectList* pObjs,
+                                     const CFX_Matrix* pObject2Device) {
+  Layer* pLayer = m_Layers.AddSpace();
+  pLayer->m_pObjectList = pObjs;
   if (pObject2Device) {
-    pItem->m_Matrix = *pObject2Device;
+    pLayer->m_Matrix = *pObject2Device;
   } else {
-    pItem->m_Matrix.SetIdentity();
+    pLayer->m_Matrix.SetIdentity();
   }
 }
 void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice,
                                 const CPDF_RenderOptions* pOptions,
                                 const CFX_Matrix* pLastMatrix) {
   Render(pDevice, NULL, pOptions, pLastMatrix);
 }
 void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice,
                                 const CPDF_PageObject* pStopObj,
                                 const CPDF_RenderOptions* pOptions,
                                 const CFX_Matrix* pLastMatrix) {
-  int count = m_ContentList.GetSize();
+  int count = m_Layers.GetSize();
   for (int j = 0; j < count; j++) {
     pDevice->SaveState();
-    _PDF_RenderItem* pItem = m_ContentList.GetDataPtr(j);
+    Layer* pLayer = m_Layers.GetDataPtr(j);
     if (pLastMatrix) {
-      CFX_Matrix FinalMatrix = pItem->m_Matrix;
+      CFX_Matrix FinalMatrix = pLayer->m_Matrix;
       FinalMatrix.Concat(*pLastMatrix);
       CPDF_RenderStatus status;
       status.Initialize(this, pDevice, pLastMatrix, pStopObj, NULL, NULL,
-                        pOptions, pItem->m_pObjectList->m_Transparency, FALSE,
+                        pOptions, pLayer->m_pObjectList->m_Transparency, FALSE,
                         NULL);
-      status.RenderObjectList(pItem->m_pObjectList, &FinalMatrix);
+      status.RenderObjectList(pLayer->m_pObjectList, &FinalMatrix);
       if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
         m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
       }
       if (status.m_bStopped) {
         pDevice->RestoreState();
         break;
       }
     } else {
       CPDF_RenderStatus status;
       status.Initialize(this, pDevice, NULL, pStopObj, NULL, NULL, pOptions,
-                        pItem->m_pObjectList->m_Transparency, FALSE, NULL);
-      status.RenderObjectList(pItem->m_pObjectList, &pItem->m_Matrix);
+                        pLayer->m_pObjectList->m_Transparency, FALSE, NULL);
+      status.RenderObjectList(pLayer->m_pObjectList, &pLayer->m_Matrix);
       if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
         m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
       }
       if (status.m_bStopped) {
         pDevice->RestoreState();
         break;
       }
     }
     pDevice->RestoreState();
   }
 }
-void CPDF_RenderContext::DrawObjectList(CFX_RenderDevice* pDevice,
-                                        CPDF_PageObjectList* pObjs,
-                                        const CFX_Matrix* pObject2Device,
-                                        const CPDF_RenderOptions* pOptions) {
-  AppendObjectList(pObjs, pObject2Device);
-  Render(pDevice, pOptions);
-}
 
 CPDF_ProgressiveRenderer::CPDF_ProgressiveRenderer(
     CPDF_RenderContext* pContext,
     CFX_RenderDevice* pDevice,
     const CPDF_RenderOptions* pOptions)
     : m_Status(Ready),
       m_pContext(pContext),
       m_pDevice(pDevice),
       m_pOptions(pOptions),
       m_LayerIndex(0),
       m_ObjectIndex(0),
       m_ObjectPos(nullptr),
       m_PrevLastPos(nullptr) {
 }
 
 CPDF_ProgressiveRenderer::~CPDF_ProgressiveRenderer() {
   if (m_pRenderStatus)
     m_pDevice->RestoreState();
 }
 
 void CPDF_ProgressiveRenderer::Start(IFX_Pause* pPause) {
   if (!m_pContext || !m_pDevice || m_Status != Ready) {
     m_Status = Failed;
     return;
   }
   m_Status = ToBeContinued;
   Continue(pPause);
 }
 
-#define RENDER_STEP_LIMIT 100
 void CPDF_ProgressiveRenderer::Continue(IFX_Pause* pPause) {
   if (m_Status != ToBeContinued) {
     return;
   }
-  FX_DWORD nLayers = m_pContext->m_ContentList.GetSize();
+  FX_DWORD nLayers = m_pContext->CountLayers();
   for (; m_LayerIndex < nLayers; m_LayerIndex++) {
-    _PDF_RenderItem* pItem = m_pContext->m_ContentList.GetDataPtr(m_LayerIndex);
-    FX_POSITION LastPos = pItem->m_pObjectList->GetLastObjectPosition();
+    CPDF_RenderContext::Layer* pLayer = m_pContext->GetLayer(m_LayerIndex);
+    FX_POSITION LastPos = pLayer->m_pObjectList->GetLastObjectPosition();
     if (!m_ObjectPos) {
       if (LastPos == m_PrevLastPos) {
-        if (!pItem->m_pObjectList->IsParsed()) {
-          pItem->m_pObjectList->ContinueParse(pPause);
-          if (!pItem->m_pObjectList->IsParsed()) {
+        if (!pLayer->m_pObjectList->IsParsed()) {
+          pLayer->m_pObjectList->ContinueParse(pPause);
+          if (!pLayer->m_pObjectList->IsParsed()) {
             return;
           }
-          LastPos = pItem->m_pObjectList->GetLastObjectPosition();
+          LastPos = pLayer->m_pObjectList->GetLastObjectPosition();
         }
       }
       if (LastPos == m_PrevLastPos) {
         if (m_pRenderStatus) {
           m_pRenderStatus.reset();
           m_pDevice->RestoreState();
           m_ObjectPos = NULL;
           m_PrevLastPos = NULL;
         }
         continue;
       }
       if (m_PrevLastPos) {
         m_ObjectPos = m_PrevLastPos;
-        pItem->m_pObjectList->GetNextObject(m_ObjectPos);
+        pLayer->m_pObjectList->GetNextObject(m_ObjectPos);
       } else {
-        m_ObjectPos = pItem->m_pObjectList->GetFirstObjectPosition();
+        m_ObjectPos = pLayer->m_pObjectList->GetFirstObjectPosition();
       }
       m_PrevLastPos = LastPos;
     }
     if (!m_pRenderStatus) {
-      m_ObjectPos = pItem->m_pObjectList->GetFirstObjectPosition();
+      m_ObjectPos = pLayer->m_pObjectList->GetFirstObjectPosition();
       m_ObjectIndex = 0;
       m_pRenderStatus.reset(new CPDF_RenderStatus());
       m_pRenderStatus->Initialize(
           m_pContext, m_pDevice, NULL, NULL, NULL, NULL, m_pOptions,
-          pItem->m_pObjectList->m_Transparency, FALSE, NULL);
+          pLayer->m_pObjectList->m_Transparency, FALSE, NULL);
       m_pDevice->SaveState();
       m_ClipRect = m_pDevice->GetClipBox();
       CFX_Matrix device2object;
-      device2object.SetReverse(pItem->m_Matrix);
+      device2object.SetReverse(pLayer->m_Matrix);
       device2object.TransformRect(m_ClipRect);
     }
     int objs_to_go = CPDF_ModuleMgr::Get()
                          ->GetRenderModule()
                          ->GetConfig()
                          ->m_RenderStepLimit;
     while (m_ObjectPos) {
-      CPDF_PageObject* pCurObj = pItem->m_pObjectList->GetObjectAt(m_ObjectPos);
+      CPDF_PageObject* pCurObj =
+          pLayer->m_pObjectList->GetObjectAt(m_ObjectPos);
       if (pCurObj && pCurObj->m_Left <= m_ClipRect.right &&
           pCurObj->m_Right >= m_ClipRect.left &&
           pCurObj->m_Bottom <= m_ClipRect.top &&
           pCurObj->m_Top >= m_ClipRect.bottom) {
-        if (m_pRenderStatus->ContinueSingleObject(pCurObj, &pItem->m_Matrix,
+        if (m_pRenderStatus->ContinueSingleObject(pCurObj, &pLayer->m_Matrix,
                                                   pPause)) {
           return;
         }
         if (pCurObj->m_Type == PDFPAGE_IMAGE &&
             m_pRenderStatus->m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
           m_pContext->GetPageCache()->CacheOptimization(
               m_pRenderStatus->m_Options.m_dwLimitCacheSize);
         }
         if (pCurObj->m_Type == PDFPAGE_FORM ||
             pCurObj->m_Type == PDFPAGE_SHADING) {
           objs_to_go = 0;
         } else {
           objs_to_go--;
         }
       }
       m_ObjectIndex++;
-      pItem->m_pObjectList->GetNextObject(m_ObjectPos);
+      pLayer->m_pObjectList->GetNextObject(m_ObjectPos);
       if (objs_to_go == 0) {
         if (pPause && pPause->NeedToPauseNow()) {
           return;
         }
         objs_to_go = CPDF_ModuleMgr::Get()
                          ->GetRenderModule()
                          ->GetConfig()
                          ->m_RenderStepLimit;
       }
     }
-    if (!pItem->m_pObjectList->IsParsed()) {
+    if (!pLayer->m_pObjectList->IsParsed()) {
       return;
     }
     m_pRenderStatus.reset();
     m_pDevice->RestoreState();
     m_ObjectPos = NULL;
     m_PrevLastPos = NULL;
     if (pPause && pPause->NeedToPauseNow()) {
       m_LayerIndex++;
       return;
     }
   }
   m_Status = Done;
 }
 int CPDF_ProgressiveRenderer::EstimateProgress() {
   if (!m_pContext) {
     return 0;
   }
-  FX_DWORD nLayers = m_pContext->m_ContentList.GetSize();
-  int nTotal = 0, nRendered = 0;
+  FX_DWORD nLayers = m_pContext->CountLayers();
+  int nTotal = 0;
+  int nRendered = 0;
   for (FX_DWORD layer = 0; layer < nLayers; layer++) {
-    _PDF_RenderItem* pItem = m_pContext->m_ContentList.GetDataPtr(layer);
-    int nObjs = pItem->m_pObjectList->CountObjects();
+    CPDF_RenderContext::Layer* pLayer = m_pContext->GetLayer(layer);
+    int nObjs = pLayer->m_pObjectList->CountObjects();
     if (layer == m_LayerIndex) {
       nRendered += m_ObjectIndex;
     } else if (layer < m_LayerIndex) {
       nRendered += nObjs;
     }
     nTotal += nObjs;
   }
   if (nTotal == 0) {
     return 0;
   }
@@ skipping 217 matching lines @@
         item.GetParamType() == CPDF_ContentMarkItem::PropertiesDict) {
       CPDF_Dictionary* pOCG =
           ToDictionary(static_cast<CPDF_Object*>(item.GetParam()));
       if (!CheckOCGVisible(pOCG)) {
         return FALSE;
       }
     }
   }
   return TRUE;
 }