Simplify PDFium by removing code that's not used in the open source repo.

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 17 matching lines @@
             CPDF_Font* pFont;
             CPDF_CountedObject<CPDF_Type3Cache*>* cache;
             m_Type3FaceMap.GetNextAssoc(pos, pFont, cache);
             if (bRelease || cache->m_nCount < 2) {
                 delete cache->m_Obj;
                 delete cache;
                 m_Type3FaceMap.RemoveKey(pFont);
             }
         }
     }
-#ifndef _FPDFAPI_MINI_
     {
         pos = m_TransferFuncMap.GetStartPosition();
         while (pos) {
             CPDF_Object* key;
             CPDF_CountedObject<CPDF_TransferFunc*>* value;
             m_TransferFuncMap.GetNextAssoc(pos, key, value);
             if (bRelease || value->m_nCount < 2) {
                 delete value->m_Obj;
                 delete value;
                 m_TransferFuncMap.RemoveKey(key);
             }
         }
     }
-#endif
     if (m_pFontCache) {
         if (bRelease) {
             delete m_pFontCache;
             m_pFontCache = NULL;
         } else {
             m_pFontCache->FreeCache(FALSE);
         }
     }
 }
 FX_BOOL CPDF_DocRenderData::Initialize()
@@ skipping 79 matching lines @@
 }
 CPDF_RenderOptions::CPDF_RenderOptions()
     : m_ColorMode(RENDER_COLOR_NORMAL)
     , m_Flags(RENDER_CLEARTYPE)
     , m_Interpolation(0)
     , m_AddFlags(0)
     , m_pOCContext(NULL)
     , m_dwLimitCacheSize(1024 * 1024 * 100)
     , m_HalftoneLimit(-1)
 {
-#if defined(_FPDFAPI_MINI_)
-    m_Flags |= RENDER_LIMITEDIMAGECACHE;
-#endif
 }
 FX_ARGB CPDF_RenderOptions::TranslateColor(FX_ARGB argb) const
 {
     if (m_ColorMode == RENDER_COLOR_NORMAL) {
         return argb;
     }
     if (m_ColorMode == RENDER_COLOR_ALPHA) {
         return argb;
     }
     int a, r, g, b;
@@ skipping 89 matching lines @@
             }
             if (!pColorData || pColorData->m_StrokeColor.IsNull()) {
                 CPDF_ColorStateData* pData = m_InitialStates.m_ColorState.GetModify();
                 pData->m_StrokeRGB = pParentData->m_FillRGB;
                 pData->m_StrokeColor.Copy(&pParentData->m_StrokeColor);
             }
         }
     } else {
         m_InitialStates.DefaultStates();
     }
-#if defined(_FPDFAPI_MINI_)||defined(_FXCORE_LIMITED_CPU_)
-    m_HalftoneLimit = CPDF_ModuleMgr::Get()->GetRenderModule()->GetConfig()->m_HalftoneLimit;
-    if (pOptions && pOptions->m_HalftoneLimit >= 0) {
-        m_HalftoneLimit = pOptions->m_HalftoneLimit;
-    }
-#endif
     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();
@@ skipping 40 matching lines @@
 }
 FX_BOOL CPDF_RenderStatus::ContinueSingleObject(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, IFX_Pause* pPause)
 {
     if (m_pObjectRenderer) {
         if (m_pObjectRenderer->Continue(pPause)) {
             return TRUE;
         }
         if (!m_pObjectRenderer->m_Result) {
             DrawObjWithBackground(pObj, pObj2Device);
         }
-#ifdef _FPDFAPI_MINI_
-        if (m_DitherBits) {
-            DitherObjectArea(pObj, pObj2Device);
-        }
-#endif
         delete m_pObjectRenderer;
         m_pObjectRenderer = NULL;
         return FALSE;
     }
     m_pCurObj = pObj;
     if (m_Options.m_pOCContext && pObj->m_ContentMark.NotNull())
         if (!m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
             return FALSE;
         }
     ProcessClipPath(pObj->m_ClipPath, pObj2Device);
     if (ProcessTransparency(pObj, pObj2Device)) {
         return FALSE;
     }
     if (pObj->m_Type == PDFPAGE_IMAGE) {
         m_pObjectRenderer = IPDF_ObjectRenderer::Create(pObj->m_Type);
         if (!m_pObjectRenderer->Start(this, pObj, pObj2Device, FALSE)) {
             if (!m_pObjectRenderer->m_Result) {
                 DrawObjWithBackground(pObj, pObj2Device);
             }
-#ifdef _FPDFAPI_MINI_
-            if (m_DitherBits) {
-                DitherObjectArea(pObj, pObj2Device);
-            }
-#endif
             delete m_pObjectRenderer;
             m_pObjectRenderer = NULL;
             return FALSE;
         }
         return ContinueSingleObject(pObj, pObj2Device, pPause);
     }
     ProcessObjectNoClip(pObj, pObj2Device);
     return FALSE;
 }
 IPDF_ObjectRenderer* IPDF_ObjectRenderer::Create(int type)
@@ skipping 55 matching lines @@
             break;
         case PDFPAGE_IMAGE:
             bRet = ProcessImage((CPDF_ImageObject*)pObj, pObj2Device);
             break;
         case PDFPAGE_SHADING:
             bRet = ProcessShading((CPDF_ShadingObject*)pObj, pObj2Device);
             break;
         case PDFPAGE_FORM:
             bRet = ProcessForm((CPDF_FormObject*)pObj, pObj2Device);
             break;
-#if defined(_FPDFAPI_MINI_)
-        case PDFPAGE_INLINES:
-            bRet = ProcessInlines((CPDF_InlineImages*)pObj, pObj2Device);
-            break;
-#endif
     }
     if (!bRet) {
         DrawObjWithBackground(pObj, pObj2Device);
     }
 }
 FX_BOOL CPDF_RenderStatus::DrawObjWithBlend(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device)
 {
     FX_BOOL bRet = FALSE;
     switch (pObj->m_Type) {
         case PDFPAGE_PATH:
             bRet = ProcessPath((CPDF_PathObject*)pObj, pObj2Device);
             break;
         case PDFPAGE_IMAGE:
             bRet = ProcessImage((CPDF_ImageObject *)pObj, pObj2Device);
             break;
         case PDFPAGE_FORM:
             bRet = ProcessForm((CPDF_FormObject*)pObj, pObj2Device);
             break;
     }
     return bRet;
 }
 void CPDF_RenderStatus::GetScaledMatrix(CFX_Matrix &matrix) const
 {
     CFX_Matrix dCTM = m_pDevice->GetCTM();
     matrix.a *= FXSYS_fabs(dCTM.a);
     matrix.d *= FXSYS_fabs(dCTM.d);
 }
 void CPDF_RenderStatus::DrawObjWithBackground(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device)
 {
-#if !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
     FX_RECT rect;
     if (GetObjectClippedRect(pObj, pObj2Device, FALSE, rect)) {
         return;
     }
     int res = 300;
     if (pObj->m_Type == PDFPAGE_IMAGE && m_pDevice->GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
         res = 0;
     }
     CPDF_ScaledRenderBuffer buffer;
     if (!buffer.Initialize(m_pContext, m_pDevice, &rect, pObj, &m_Options, res)) {
         return;
     }
     CFX_AffineMatrix matrix = *pObj2Device;
     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.RenderSingleObject(pObj, &matrix);
     buffer.OutputToDevice();
-#endif
 }
 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;
@@ skipping 46 matching lines @@
     }
     if (m_Options.m_Flags & RENDER_FILL_FULLCOVER) {
         FillType |= FXFILL_FULLCOVER;
     }
     if (m_Options.m_Flags & RENDER_NOPATHSMOOTH) {
         FillType |= FXFILL_NOPATHSMOOTH;
     }
     if (bStroke) {
         FillType |= FX_FILL_STROKE;
     }
-#if !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
     const CPDF_GeneralStateData* pGeneralData = ((CPDF_PageObject*)pPathObj)->m_GeneralState;
     if (pGeneralData && pGeneralData->m_StrokeAdjust) {
         FillType |= FX_STROKE_ADJUST;
     }
-#endif
     if (m_pType3Char) {
         FillType |= FX_FILL_TEXT_MODE;
     }
     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
@@ skipping 14 matching lines @@
         pColorData = (CPDF_ColorStateData*)(const CPDF_ColorStateData*)m_InitialStates.m_ColorState;
     }
     FX_COLORREF rgb = pColorData->m_FillRGB;
     if (rgb == (FX_DWORD) - 1) {
         return 0;
     }
     const CPDF_GeneralStateData* pGeneralData = pObj->m_GeneralState;
     int alpha;
     if (pGeneralData) {
         alpha = (FX_INT32)(pGeneralData->m_FillAlpha * 255);
-#ifndef _FPDFAPI_MINI_
         if (pGeneralData->m_pTR) {
             if (!pGeneralData->m_pTransferFunc) {
                 ((CPDF_GeneralStateData*)pGeneralData)->m_pTransferFunc = GetTransferFunc(pGeneralData->m_pTR);
             }
             if (pGeneralData->m_pTransferFunc) {
                 rgb = pGeneralData->m_pTransferFunc->TranslateColor(rgb);
             }
         }
-#endif
     } else {
         alpha = 255;
     }
     return m_Options.TranslateColor(ArgbEncode(alpha, rgb));
 }
 FX_ARGB CPDF_RenderStatus::GetStrokeArgb(const CPDF_PageObject* pObj) const
 {
     CPDF_ColorStateData* pColorData = (CPDF_ColorStateData*)(const CPDF_ColorStateData*)pObj->m_ColorState;
     if (m_pType3Char && (!m_pType3Char->m_bColored || (m_pType3Char->m_bColored && (!pColorData || pColorData->m_StrokeColor.IsNull())))) {
         return m_T3FillColor;
     } else if (!pColorData || pColorData->m_StrokeColor.IsNull()) {
         pColorData = (CPDF_ColorStateData*)(const CPDF_ColorStateData*)m_InitialStates.m_ColorState;
     }
     FX_COLORREF rgb = pColorData->m_StrokeRGB;
     if (rgb == (FX_DWORD) - 1) {
         return 0;
     }
     const CPDF_GeneralStateData* pGeneralData = pObj->m_GeneralState;
     int alpha;
     if (pGeneralData) {
         alpha = (FX_INT32)(pGeneralData->m_StrokeAlpha * 255);
-#ifndef _FPDFAPI_MINI_
         if (pGeneralData->m_pTR) {
             if (!pGeneralData->m_pTransferFunc) {
                 ((CPDF_GeneralStateData*)pGeneralData)->m_pTransferFunc = GetTransferFunc(pGeneralData->m_pTR);
             }
             if (pGeneralData->m_pTransferFunc) {
                 rgb = pGeneralData->m_pTransferFunc->TranslateColor(rgb);
             }
         }
-#endif
     } else {
         alpha = 255;
     }
     return m_Options.TranslateColor(ArgbEncode(alpha, rgb));
 }
 void CPDF_RenderStatus::ProcessClipPath(CPDF_ClipPath ClipPath, const CFX_AffineMatrix* pObj2Device)
 {
     if (ClipPath.IsNull()) {
         if (m_LastClipPath.IsNull()) {
             return;
@@ skipping 378 matching lines @@
     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,
                               pItem->m_pObjectList->m_Transparency, FALSE, NULL);
             status.RenderObjectList(pItem->m_pObjectList, &FinalMatrix);
-#if !defined(_FPDFAPI_MINI_)
             if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
                 m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
             }
-#endif
             if (status.m_bStopped) {
                 pDevice->RestoreState();
                 break;
             }
         } else {
             CPDF_RenderStatus status;
             status.Initialize(0, this, pDevice, NULL, pStopObj, NULL, NULL, pOptions,
                               pItem->m_pObjectList->m_Transparency, FALSE, NULL);
             status.RenderObjectList(pItem->m_pObjectList, &pItem->m_Matrix);
-#if !defined(_FPDFAPI_MINI_)
             if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
                 m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
             }
-#endif
             if (status.m_bStopped) {
                 pDevice->RestoreState();
                 break;
             }
         }
         pDevice->RestoreState();
     }
 }
 void CPDF_RenderContext::DrawObjectList(CFX_RenderDevice* pDevice, CPDF_PageObjects* pObjs,
                                         const CFX_AffineMatrix* pObject2Device, const CPDF_RenderOptions* pOptions)
@@ skipping 36 matching lines @@
         m_Status = Failed;
         return;
     }
     m_Status = ToBeContinued;
     m_ObjectPos = NULL;
     m_LayerIndex = 0;
     m_ObjectIndex = 0;
     m_PrevLastPos = NULL;
     Continue(pPause);
 }
-#ifdef _FPDFAPI_MINI_
-#define RENDER_STEP_LIMIT 20
-#else
 #define RENDER_STEP_LIMIT 100
-#endif
 void CPDF_ProgressiveRenderer::Continue(IFX_Pause* pPause)
 {
     if (m_Status != ToBeContinued) {
         return;
     }
     FX_DWORD nLayers = m_pContext->m_ContentList.GetSize();
     for (; m_LayerIndex < nLayers; m_LayerIndex ++) {
         _PDF_RenderItem* pItem = m_pContext->m_ContentList.GetDataPtr(m_LayerIndex);
         FX_POSITION LastPos = pItem->m_pObjectList->GetLastObjectPosition();
         if (m_ObjectPos == NULL) {
@@ skipping 37 matching lines @@
             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);
             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_pRenderer->ContinueSingleObject(pCurObj, &pItem->m_Matrix, pPause)) {
                     return;
                 }
-#if !defined(_FPDFAPI_MINI_)
                 if (pCurObj->m_Type == PDFPAGE_IMAGE && m_pRenderer->m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
                     m_pContext->GetPageCache()->CacheOptimization(m_pRenderer->m_Options.m_dwLimitCacheSize);
                 }
-#endif
                 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);
             if (objs_to_go == 0) {
                 if (pPause && pPause->NeedToPauseNow()) {
@@ skipping 120 matching lines @@
 {
     CPDF_CountedObject<CPDF_TransferFunc*>* pTransferCounter;
     if (!m_TransferFuncMap.Lookup(pObj, pTransferCounter)) {
         return;
     }
     pTransferCounter->m_nCount--;
 }
 CPDF_RenderConfig::CPDF_RenderConfig()
 {
     m_HalftoneLimit = 0;
-#ifdef _FPDFAPI_MINI_
-    m_RenderStepLimit = 20;
-#else
     m_RenderStepLimit = 100;
-#endif
 }
 CPDF_RenderConfig::~CPDF_RenderConfig()
 {
 }
 CPDF_DeviceBuffer::CPDF_DeviceBuffer()
 {
     m_pBitmap = NULL;
     m_pDevice = NULL;
     m_pContext = NULL;
     m_pObject = NULL;
@@ skipping 18 matching lines @@
     if (horz_size && vert_size && max_dpi) {
         int dpih = pDevice->GetDeviceCaps(FXDC_PIXEL_WIDTH) * 254 / (horz_size * 10);
         int dpiv = pDevice->GetDeviceCaps(FXDC_PIXEL_HEIGHT) * 254 / (vert_size * 10);
         if (dpih > max_dpi) {
             m_Matrix.Scale((FX_FLOAT)(max_dpi) / dpih, 1.0f);
         }
         if (dpiv > max_dpi) {
             m_Matrix.Scale(1.0f, (FX_FLOAT)(max_dpi) / (FX_FLOAT)dpiv);
         }
     }
-#ifdef _FPDFAPI_MINI_
-    m_Matrix.Scale(0.5f, 0.5f);
-#endif
 #endif
     CFX_Matrix ctm = m_pDevice->GetCTM();
     FX_FLOAT fScaleX = FXSYS_fabs(ctm.a);
     FX_FLOAT fScaleY = FXSYS_fabs(ctm.d);
     m_Matrix.Concat(fScaleX, 0, 0, fScaleY, 0, 0);
     CFX_FloatRect rect(*pRect);
     m_Matrix.TransformRect(rect);
     FX_RECT bitmap_rect = rect.GetOutterRect();
     m_pBitmap = FX_NEW CFX_DIBitmap;
     m_pBitmap->Create(bitmap_rect.Width(), bitmap_rect.Height(), FXDIB_Argb);
     return TRUE;
 }
 void CPDF_DeviceBuffer::OutputToDevice()
 {
     if (m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_GET_BITS) {
         if (m_Matrix.a == 1.0f && m_Matrix.d == 1.0f) {
             m_pDevice->SetDIBits(m_pBitmap, m_Rect.left, m_Rect.top);
         } else {
             m_pDevice->StretchDIBits(m_pBitmap, m_Rect.left, m_Rect.top, m_Rect.Width(), m_Rect.Height());
         }
     } else {
-#if !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
         CFX_DIBitmap buffer;
         m_pDevice->CreateCompatibleBitmap(&buffer, m_pBitmap->GetWidth(), m_pBitmap->GetHeight());
         m_pContext->GetBackground(&buffer, m_pObject, NULL, &m_Matrix);
         buffer.CompositeBitmap(0, 0, buffer.GetWidth(), buffer.GetHeight(), m_pBitmap, 0, 0);
         m_pDevice->StretchDIBits(&buffer, m_Rect.left, m_Rect.top, m_Rect.Width(), m_Rect.Height());
-#endif
     }
 }
 CPDF_ScaledRenderBuffer::CPDF_ScaledRenderBuffer()
 {
     m_pBitmapDevice = NULL;
 }
 CPDF_ScaledRenderBuffer::~CPDF_ScaledRenderBuffer()
 {
     if (m_pBitmapDevice) {
         delete m_pBitmapDevice;
     }
 }
-#ifndef _FPDFAPI_MINI_
 #define _FPDFAPI_IMAGESIZE_LIMIT_       (30 * 1024 * 1024)
-#else
-#define _FPDFAPI_IMAGESIZE_LIMIT_       (10 * 1024 * 1024)
-#endif
 FX_BOOL CPDF_ScaledRenderBuffer::Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
         const CPDF_PageObject* pObj, const CPDF_RenderOptions *pOptions, int max_dpi)
 {
     FXSYS_assert(pRect != NULL);
     m_pDevice = pDevice;
     if (m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_GET_BITS) {
         return TRUE;
     }
     m_pContext = pContext;
     m_Rect = *pRect;
@@ skipping 29 matching lines @@
         iPitch = (iWidth * bpp + 31) / 32 * 4;
         if (iWidth * iHeight < 1) {
             return FALSE;
         }
         if (iPitch * iHeight <= _FPDFAPI_IMAGESIZE_LIMIT_ &&
                 m_pBitmapDevice->Create(iWidth, iHeight, dibFormat)) {
             break;
         }
         m_Matrix.Scale(0.5f, 0.5f);
     }
-#if  !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
     m_pContext->GetBackground(m_pBitmapDevice->GetBitmap(), m_pObject, pOptions, &m_Matrix);
-#endif
     return TRUE;
 }
 void CPDF_ScaledRenderBuffer::OutputToDevice()
 {
     if (m_pBitmapDevice) {
         m_pDevice->StretchDIBits(m_pBitmapDevice->GetBitmap(), m_Rect.left, m_Rect.top, m_Rect.Width(), m_Rect.Height());
     }
 }
 FX_BOOL IPDF_OCContext::CheckObjectVisible(const CPDF_PageObject* pObj)
 {
     const CPDF_ContentMarkData* pData = pObj->m_ContentMark;
     int nItems = pData->CountItems();
     for (int i = 0; i < nItems; i ++) {
         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;
 }