Merge to XFA: Fix infinite recursion in CPDF_RenderStatus::RenderSingleObject().

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 "../../../include/fpdfapi/fpdf_render.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../fpdf_page/pageint.h"
 #include "../../../include/fxge/fx_ge.h"
@@ skipping 162 matching lines @@
     int fg = FXSYS_GetGValue(m_ForeColor);
     int fb = FXSYS_GetBValue(m_ForeColor);
     int br = FXSYS_GetRValue(m_BackColor);
     int bg = FXSYS_GetGValue(m_BackColor);
     int bb = FXSYS_GetBValue(m_BackColor);
     r = (br - fr) * gray / 255 + fr;
     g = (bg - fg) * gray / 255 + fg;
     b = (bb - fb) * gray / 255 + fb;
     return ArgbEncode(a, r, g, b);
 }
+
+// static
+int CPDF_RenderStatus::s_CurrentRecursionDepth = 0;
+
 CPDF_RenderStatus::CPDF_RenderStatus()
 {
     m_pContext = NULL;
     m_bStopped = FALSE;
-    m_Level = 0;
     m_pDevice = NULL;
     m_pCurObj = NULL;
     m_pStopObj = NULL;
     m_HalftoneLimit = 0;
     m_pObjectRenderer = NULL;
     m_bPrint = FALSE;
     m_Transparency = 0;
     m_DitherBits = 0;
     m_bDropObjects = FALSE;
     m_bStdCS = FALSE;
     m_GroupFamily = 0;
     m_bLoadMask = FALSE;
     m_pType3Char = NULL;
     m_T3FillColor = 0;
     m_pFormResource = NULL;
     m_pPageResource = NULL;
     m_curBlend = FXDIB_BLEND_NORMAL;
 }
+
 CPDF_RenderStatus::~CPDF_RenderStatus()
 {
     if (m_pObjectRenderer) {
         delete m_pObjectRenderer;
     }
 }
-FX_BOOL CPDF_RenderStatus::Initialize(int level, CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice,
+
+FX_BOOL CPDF_RenderStatus::Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice,
                                       const CFX_AffineMatrix* pDeviceMatrix, const CPDF_PageObject* pStopObj,
                                       const CPDF_RenderStatus* pParentState, const CPDF_GraphicStates* pInitialStates,
                                       const CPDF_RenderOptions* pOptions, int transparency, FX_BOOL bDropObjects,
                                       CPDF_Dictionary* pFormResource, FX_BOOL bStdCS, CPDF_Type3Char* pType3Char,
                                       FX_ARGB fill_color, FX_DWORD GroupFamily,
                                       FX_BOOL bLoadMask)
 {
-    m_Level = level;
     m_pContext = pContext;
     m_pDevice = pDevice;
     m_DitherBits = pDevice->GetDeviceCaps(FXDC_DITHER_BITS);
     m_bPrint = m_pDevice->GetDeviceClass() != FXDC_DISPLAY;
     if (pDeviceMatrix) {
         m_DeviceMatrix = *pDeviceMatrix;
     }
     m_pStopObj = pStopObj;
     if (pOptions) {
         m_Options = *pOptions;
@@ skipping 24 matching lines @@
         }
     } else {
         m_InitialStates.DefaultStates();
     }
     m_pObjectRenderer = NULL;
     m_Transparency = transparency;
     return TRUE;
 }
 void CPDF_RenderStatus::RenderObjectList(const CPDF_PageObjects* pObjs, const CFX_AffineMatrix* pObj2Device)
 {
-    if (m_Level > 32) {
-        return;
-    }
     CFX_FloatRect clip_rect = m_pDevice->GetClipBox();
     CFX_AffineMatrix device2object;
     device2object.SetReverse(*pObj2Device);
     device2object.TransformRect(clip_rect);
     int index = 0;
     FX_POSITION pos = pObjs->GetFirstObjectPosition();
     while(pos) {
         index ++;
         CPDF_PageObject* pCurObj = pObjs->GetNextObject(pos);
         if (pCurObj == m_pStopObj) {
             m_bStopped = TRUE;
             return;
         }
         if (!pCurObj) {
             continue;
         }
         if(pCurObj == NULL || pCurObj->m_Left > clip_rect.right || pCurObj->m_Right < clip_rect.left ||
                 pCurObj->m_Bottom > clip_rect.top || pCurObj->m_Top < clip_rect.bottom) {
             continue;
         }
         RenderSingleObject(pCurObj, pObj2Device);
         if (m_bStopped) {
             return;
         }
     }
 }
 void CPDF_RenderStatus::RenderSingleObject(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device)
 {
-    if (m_Level > 32) {
+    CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
+    if (++s_CurrentRecursionDepth > kRenderMaxRecursionDepth) {
         return;
     }
     m_pCurObj = pObj;
-    if (m_Options.m_pOCContext && pObj->m_ContentMark.NotNull())
+    if (m_Options.m_pOCContext && pObj->m_ContentMark.NotNull()) {
         if (!m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
             return;
         }
+    }
     ProcessClipPath(pObj->m_ClipPath, pObj2Device);
     if (ProcessTransparency(pObj, pObj2Device)) {
         return;
     }
     ProcessObjectNoClip(pObj, pObj2Device);
 }
 FX_BOOL CPDF_RenderStatus::ContinueSingleObject(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, IFX_Pause* pPause)
 {
     if (m_pObjectRenderer) {
         if (m_pObjectRenderer->Continue(pPause)) {
@@ skipping 141 matching lines @@
     matrix.Concat(*buffer.GetMatrix());
     GetScaledMatrix(matrix);
     CPDF_Dictionary* pFormResource = NULL;
     if (pObj->m_Type == PDFPAGE_FORM) {
         CPDF_FormObject* pFormObj = (CPDF_FormObject*)pObj;
         if (pFormObj->m_pForm && pFormObj->m_pForm->m_pFormDict) {
             pFormResource = pFormObj->m_pForm->m_pFormDict->GetDict(FX_BSTRC("Resources"));
         }
     }
     CPDF_RenderStatus status;
-    status.Initialize(m_Level + 1, m_pContext, buffer.GetDevice(), buffer.GetMatrix(), NULL, NULL, NULL, &m_Options, m_Transparency, m_bDropObjects, pFormResource);
+    status.Initialize(m_pContext, buffer.GetDevice(), buffer.GetMatrix(), NULL, NULL, NULL, &m_Options, m_Transparency, m_bDropObjects, pFormResource);
     status.RenderSingleObject(pObj, &matrix);
     buffer.OutputToDevice();
 }
 FX_BOOL CPDF_RenderStatus::ProcessForm(CPDF_FormObject* pFormObj, const CFX_AffineMatrix* pObj2Device)
 {
     CPDF_Dictionary* pOC = pFormObj->m_pForm->m_pFormDict->GetDict(FX_BSTRC("OC"));
     if (pOC && m_Options.m_pOCContext && !m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
         return TRUE;
     }
     CFX_AffineMatrix matrix = pFormObj->m_FormMatrix;
     matrix.Concat(*pObj2Device);
     CPDF_Dictionary* pResources = NULL;
     if (pFormObj->m_pForm && pFormObj->m_pForm->m_pFormDict) {
         pResources = pFormObj->m_pForm->m_pFormDict->GetDict(FX_BSTRC("Resources"));
     }
     CPDF_RenderStatus status;
-    status.Initialize(m_Level + 1, m_pContext, m_pDevice, NULL, m_pStopObj,
+    status.Initialize(m_pContext, m_pDevice, NULL, m_pStopObj,
                       this, pFormObj, &m_Options, m_Transparency, m_bDropObjects, pResources, FALSE);
     status.m_curBlend = m_curBlend;
     m_pDevice->SaveState();
     status.RenderObjectList(pFormObj->m_pForm, &matrix);
     m_bStopped = status.m_bStopped;
     m_pDevice->RestoreState();
     return TRUE;
 }
 FX_BOOL IsAvailableMatrix(const CFX_AffineMatrix& matrix)
 {
@@ skipping 337 matching lines @@
                 break;
             }
             CFX_AffineMatrix text_matrix;
             textobj->GetTextMatrix(&text_matrix);
             CPDF_TextRenderer::DrawTextPath(&text_device, textobj->m_nChars, textobj->m_pCharCodes, textobj->m_pCharPos,
                                             textobj->m_TextState.GetFont(), textobj->m_TextState.GetFontSize(),
                                             &text_matrix, &new_matrix, textobj->m_GraphState, (FX_ARGB) - 1, 0, NULL);
         }
     }
     CPDF_RenderStatus bitmap_render;
-    bitmap_render.Initialize(m_Level + 1, m_pContext, &bitmap_device, NULL,
+    bitmap_render.Initialize(m_pContext, &bitmap_device, NULL,
                              m_pStopObj, NULL, NULL, &m_Options, 0, m_bDropObjects, pFormResource, TRUE);
     bitmap_render.ProcessObjectNoClip(pPageObj, &new_matrix);
     m_bStopped = bitmap_render.m_bStopped;
     if (pSMaskDict) {
         CFX_AffineMatrix smask_matrix;
         FXSYS_memcpy32(&smask_matrix, pGeneralState->m_SMaskMatrix, sizeof smask_matrix);
         smask_matrix.Concat(*pObj2Device);
         CFX_DIBSource* pSMaskSource = LoadSMask(pSMaskDict, &rect, &smask_matrix);
         if (pSMaskSource) {
             bitmap->MultiplyAlpha(pSMaskSource);
@@ skipping 143 matching lines @@
                                 const CPDF_RenderOptions* pOptions, const CFX_AffineMatrix* pLastMatrix)
 {
     int count = m_ContentList.GetSize();
     for (int j = 0; j < count; j ++) {
         pDevice->SaveState();
         _PDF_RenderItem* pItem = m_ContentList.GetDataPtr(j);
         if (pLastMatrix) {
             CFX_AffineMatrix FinalMatrix = pItem->m_Matrix;
             FinalMatrix.Concat(*pLastMatrix);
             CPDF_RenderStatus status;
-            status.Initialize(0, this, pDevice, pLastMatrix, pStopObj, NULL, NULL, pOptions,
+            status.Initialize(this, pDevice, pLastMatrix, pStopObj, NULL, NULL, pOptions,
                               pItem->m_pObjectList->m_Transparency, FALSE, NULL);
             status.RenderObjectList(pItem->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(0, this, pDevice, NULL, pStopObj, NULL, NULL, pOptions,
+            status.Initialize(this, pDevice, NULL, pStopObj, NULL, NULL, pOptions,
                               pItem->m_pObjectList->m_Transparency, FALSE, NULL);
             status.RenderObjectList(pItem->m_pObjectList, &pItem->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;
             }
         }
@@ skipping 83 matching lines @@
                 pItem->m_pObjectList->GetNextObject(m_ObjectPos);
             } else {
                 m_ObjectPos = pItem->m_pObjectList->GetFirstObjectPosition();
             }
             m_PrevLastPos = LastPos;
         }
         if (m_pRenderer == NULL) {
             m_ObjectPos = pItem->m_pObjectList->GetFirstObjectPosition();
             m_ObjectIndex = 0;
             m_pRenderer = FX_NEW CPDF_RenderStatus();
-            m_pRenderer->Initialize(0, m_pContext, m_pDevice, NULL, NULL, NULL, NULL,
+            m_pRenderer->Initialize(m_pContext, m_pDevice, NULL, NULL, NULL, NULL,
                                     m_pOptions, pItem->m_pObjectList->m_Transparency, m_bDropObjects, NULL);
             m_pDevice->SaveState();
             m_ClipRect = m_pDevice->GetClipBox();
             CFX_AffineMatrix device2object;
             device2object.SetReverse(pItem->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);
@@ skipping 289 matching lines @@
         CPDF_ContentMarkItem& item = pData->GetItem(i);
         if (item.GetName() == FX_BSTRC("OC") && item.GetParamType() == CPDF_ContentMarkItem::PropertiesDict) {
             CPDF_Dictionary* pOCG = (CPDF_Dictionary*)item.GetParam();
             if (!CheckOCGVisible(pOCG)) {
                 return FALSE;
             }
         }
     }
     return TRUE;
 }