Remove PageObject's m_Type and add As<Type> functions

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 "core/src/fpdfapi/fpdf_render/render_int.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_render.h"
@@ skipping 288 matching lines @@
   m_pCurObj = pObj;
   if (m_Options.m_pOCContext && pObj->m_ContentMark.NotNull() &&
       !m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
     return FALSE;
   }
 
   ProcessClipPath(pObj->m_ClipPath, pObj2Device);
   if (ProcessTransparency(pObj, pObj2Device))
     return FALSE;
 
-  if (pObj->m_Type == CPDF_PageObject::IMAGE) {
-    m_pObjectRenderer.reset(IPDF_ObjectRenderer::Create(pObj->m_Type));
+  if (pObj->IsImage()) {
+    m_pObjectRenderer.reset(IPDF_ObjectRenderer::Create(pObj->GetType()));
     if (!m_pObjectRenderer->Start(this, pObj, pObj2Device, FALSE)) {
       if (!m_pObjectRenderer->m_Result)
         DrawObjWithBackground(pObj, pObj2Device);
       m_pObjectRenderer.reset();
       return FALSE;
     }
     return ContinueSingleObject(pObj, pObj2Device, pPause);
   }
 
   ProcessObjectNoClip(pObj, pObj2Device);
   return FALSE;
 }
 
-IPDF_ObjectRenderer* IPDF_ObjectRenderer::Create(int type) {
+IPDF_ObjectRenderer* IPDF_ObjectRenderer::Create(CPDF_PageObject::Type type) {
   if (type != CPDF_PageObject::IMAGE) {

[Lei Zhang, 2016/02/19 04:22:31]

Maybe just remove the type parameter and this check? The only caller on line 310
above behaves as though we never return NULL here.

[Wei Li, 2016/02/19 19:32:19]

I removed it for now. Looks like IPDF_ObjectRenderer is only used by
ImageRender, maybe we could get rid of it all later.

     return NULL;
   }
   return new CPDF_ImageRenderer;
 }
 FX_BOOL CPDF_RenderStatus::GetObjectClippedRect(const CPDF_PageObject* pObj,
                                                 const CFX_Matrix* pObj2Device,
                                                 FX_BOOL bLogical,
                                                 FX_RECT& rect) const {
   rect = pObj->GetBBox(pObj2Device);
   FX_RECT rtClip = m_pDevice->GetClipBox();
@@ skipping 31 matching lines @@
     pBitmap->DitherFS(pal, 8, &rect);
   } else if (m_DitherBits == 4) {
     static FX_ARGB pal[16] = {0,   17,  34,  51,  68,  85,  102, 119,
                               136, 153, 170, 187, 204, 221, 238, 255};
     pBitmap->DitherFS(pal, 16, &rect);
   }
 }
 void CPDF_RenderStatus::ProcessObjectNoClip(const CPDF_PageObject* pObj,
                                             const CFX_Matrix* pObj2Device) {
   FX_BOOL bRet = FALSE;
-  switch (pObj->m_Type) {
+  switch (pObj->GetType()) {
     case CPDF_PageObject::TEXT:
       bRet = ProcessText((CPDF_TextObject*)pObj, pObj2Device, NULL);

[Lei Zhang, 2016/02/19 04:22:31]

More casts to get rid of.

[Wei Li, 2016/02/19 19:32:19]

Thanks for spotting these. Done.

       break;
     case CPDF_PageObject::PATH:
       bRet = ProcessPath((CPDF_PathObject*)pObj, pObj2Device);
       break;
     case CPDF_PageObject::IMAGE:
       bRet = ProcessImage((CPDF_ImageObject*)pObj, pObj2Device);
       break;
     case CPDF_PageObject::SHADING:
       bRet = ProcessShading((CPDF_ShadingObject*)pObj, pObj2Device);
       break;
     case CPDF_PageObject::FORM:
       bRet = ProcessForm((CPDF_FormObject*)pObj, pObj2Device);
       break;
   }
   if (!bRet) {
     DrawObjWithBackground(pObj, pObj2Device);
   }
 }
 FX_BOOL CPDF_RenderStatus::DrawObjWithBlend(const CPDF_PageObject* pObj,
                                             const CFX_Matrix* pObj2Device) {
   FX_BOOL bRet = FALSE;
-  switch (pObj->m_Type) {
+  switch (pObj->GetType()) {
     case CPDF_PageObject::PATH:
       bRet = ProcessPath((CPDF_PathObject*)pObj, pObj2Device);
       break;
     case CPDF_PageObject::IMAGE:
       bRet = ProcessImage((CPDF_ImageObject*)pObj, pObj2Device);
       break;
     case CPDF_PageObject::FORM:
       bRet = ProcessForm((CPDF_FormObject*)pObj, pObj2Device);
       break;
     default:
       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_Matrix* pObj2Device) {
   FX_RECT rect;
   if (GetObjectClippedRect(pObj, pObj2Device, FALSE, rect)) {
     return;
   }
   int res = 300;
-  if (pObj->m_Type == CPDF_PageObject::IMAGE &&
+  if (pObj->IsImage() &&
       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_Matrix matrix = *pObj2Device;
   matrix.Concat(*buffer.GetMatrix());
   GetScaledMatrix(matrix);
   CPDF_Dictionary* pFormResource = NULL;
-  if (pObj->m_Type == CPDF_PageObject::FORM) {
-    CPDF_FormObject* pFormObj = (CPDF_FormObject*)pObj;
+  if (pObj->IsForm()) {
+    const CPDF_FormObject* pFormObj = pObj->AsForm();
     if (pFormObj->m_pForm && pFormObj->m_pForm->m_pFormDict) {
       pFormResource = pFormObj->m_pForm->m_pFormDict->GetDictBy("Resources");
     }
   }
   CPDF_RenderStatus status;
   status.Initialize(m_pContext, buffer.GetDevice(), buffer.GetMatrix(), NULL,
                     NULL, NULL, &m_Options, m_Transparency, m_bDropObjects,
                     pFormResource);
   status.RenderSingleObject(pObj, &matrix);
   buffer.OutputToDevice();
@@ skipping 262 matching lines @@
                                                const CFX_Matrix* pObj2Device) {
   const CPDF_GeneralStateData* pGeneralState = pPageObj->m_GeneralState;
   int blend_type =
       pGeneralState ? pGeneralState->m_BlendType : FXDIB_BLEND_NORMAL;
   if (blend_type == FXDIB_BLEND_UNSUPPORTED) {
     return TRUE;
   }
   CPDF_Dictionary* pSMaskDict =
       pGeneralState ? ToDictionary(pGeneralState->m_pSoftMask) : NULL;
   if (pSMaskDict) {
-    if (pPageObj->m_Type == CPDF_PageObject::IMAGE &&
-        ((CPDF_ImageObject*)pPageObj)->m_pImage->GetDict()->KeyExist("SMask")) {
+    if (pPageObj->IsImage() &&
+        pPageObj->AsImage()->m_pImage->GetDict()->KeyExist("SMask")) {
       pSMaskDict = NULL;
     }
   }
   CPDF_Dictionary* pFormResource = NULL;
   FX_FLOAT group_alpha = 1.0f;
   int Transparency = m_Transparency;
   FX_BOOL bGroupTransparent = FALSE;
-  if (pPageObj->m_Type == CPDF_PageObject::FORM) {
-    CPDF_FormObject* pFormObj = (CPDF_FormObject*)pPageObj;
+  if (pPageObj->IsForm()) {
+    const CPDF_FormObject* pFormObj = pPageObj->AsForm();
     const CPDF_GeneralStateData* pStateData =
         pFormObj->m_GeneralState.GetObject();
     if (pStateData) {
       group_alpha = pStateData->m_FillAlpha;
     }
     Transparency = pFormObj->m_pForm->m_Transparency;
     bGroupTransparent = !!(Transparency & PDFTRANS_ISOLATED);
     if (pFormObj->m_pForm->m_pFormDict) {
       pFormResource = pFormObj->m_pForm->m_pFormDict->GetDictBy("Resources");
     }
   }
   FX_BOOL bTextClip = FALSE;
   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 == CPDF_PageObject::IMAGE && pGeneralState &&
-      pGeneralState->m_FillOP && pGeneralState->m_StrokeOP) {
+  if ((m_Options.m_Flags & RENDER_OVERPRINT) && pPageObj->IsImage() &&
+      pGeneralState && pGeneralState->m_FillOP && pGeneralState->m_StrokeOP) {
     CPDF_Document* pDocument = NULL;
     CPDF_Page* pPage = NULL;
     if (m_pContext->GetPageCache()) {
       pPage = m_pContext->GetPageCache()->GetPage();
       pDocument = pPage->m_pDocument;
     } else {
-      pDocument = ((CPDF_ImageObject*)pPageObj)->m_pImage->GetDocument();
+      pDocument = pPageObj->AsImage()->m_pImage->GetDocument();
     }
     CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : NULL;
-    CPDF_Object* pCSObj = ((CPDF_ImageObject*)pPageObj)
-                              ->m_pImage->GetStream()
-                              ->GetDict()
-                              ->GetElementValue("ColorSpace");
+    CPDF_Object* pCSObj =
+        pPageObj->AsImage()->m_pImage->GetStream()->GetDict()->GetElementValue(
+            "ColorSpace");
     CPDF_ColorSpace* pColorSpace =
         pDocument->LoadColorSpace(pCSObj, pPageResources);
     if (pColorSpace) {
       int format = pColorSpace->GetFamily();
       if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION ||
           format == PDFCS_DEVICEN) {
         blend_type = FXDIB_BLEND_DARKEN;
       }
       pDocument->GetPageData()->ReleaseColorSpace(pCSObj);
     }
@@ skipping 85 matching lines @@
       bitmap->MultiplyAlpha(pSMaskSource.get());
   }
   if (pTextMask) {
     bitmap->MultiplyAlpha(pTextMask.get());
     pTextMask.reset();
   }
   if (Transparency & PDFTRANS_GROUP && group_alpha != 1.0f) {
     bitmap->MultiplyAlpha((int32_t)(group_alpha * 255));
   }
   Transparency = m_Transparency;
-  if (pPageObj->m_Type == CPDF_PageObject::FORM) {
+  if (pPageObj->IsForm()) {
     Transparency |= PDFTRANS_GROUP;
   }
   CompositeDIBitmap(bitmap, rect.left, rect.top, 0, 255, blend_type,
                     Transparency);
   return TRUE;
 }
 
 CFX_DIBitmap* CPDF_RenderStatus::GetBackdrop(const CPDF_PageObject* pObj,
                                              const FX_RECT& rect,
                                              int& left,
@@ skipping 197 matching lines @@
     while (iter != iterEnd) {
       CPDF_PageObject* pCurObj = iter->get();
       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, &m_pCurrentLayer->m_Matrix, pPause)) {
           return;
         }
-        if (pCurObj->m_Type == CPDF_PageObject::IMAGE &&
+        if (pCurObj->IsImage() &&
             m_pRenderStatus->m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
           m_pContext->GetPageCache()->CacheOptimization(
               m_pRenderStatus->m_Options.m_dwLimitCacheSize);
         }
-        if (pCurObj->m_Type == CPDF_PageObject::FORM ||
-            pCurObj->m_Type == CPDF_PageObject::SHADING) {
+        if (pCurObj->IsForm() || pCurObj->IsShading()) {
           nObjsToGo = 0;
         } else {
           --nObjsToGo;
         }
       }
       m_LastObjectRendered = iter;
       if (nObjsToGo == 0) {
         if (pPause && pPause->NeedToPauseNow())
           return;
         nObjsToGo = kStepLimit;
@@ skipping 226 matching lines @@
   for (int i = 0; i < nItems; i++) {
     const CPDF_ContentMarkItem& item = pData->GetItem(i);
     if (item.GetName() == "OC" &&
         item.GetParamType() == CPDF_ContentMarkItem::PropertiesDict &&
         !CheckOCGVisible(item.GetParam())) {
       return FALSE;
     }
   }
   return TRUE;
 }