Make CPDF_GeneralState have a CPDF_GeneralStateData

core/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/fpdfapi/fpdf_render/render_int.h"
 
 #include <memory>
 
@@ skipping 230 matching lines @@
     }
     RenderSingleObject(pCurObj.get(), pObj2Device);
     if (m_bStopped)
       return;
   }
 #if defined _SKIA_SUPPORT_
   DebugVerifyDeviceIsPreMultiplied();
 #endif
 }
 
-void CPDF_RenderStatus::RenderSingleObject(const CPDF_PageObject* pObj,
+void CPDF_RenderStatus::RenderSingleObject(CPDF_PageObject* pObj,
                                            const CFX_Matrix* pObj2Device) {
 #if defined _SKIA_SUPPORT_
   DebugVerifyDeviceIsPreMultiplied();
 #endif
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kRenderMaxRecursionDepth) {
     return;
   }
   m_pCurObj = pObj;
   if (m_Options.m_pOCContext && pObj->m_ContentMark) {
     if (!m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
       return;
     }
   }
   ProcessClipPath(pObj->m_ClipPath, pObj2Device);
   if (ProcessTransparency(pObj, pObj2Device)) {
     return;
   }
   ProcessObjectNoClip(pObj, pObj2Device);
 #if defined _SKIA_SUPPORT_
   DebugVerifyDeviceIsPreMultiplied();
 #endif
 }
 
-FX_BOOL CPDF_RenderStatus::ContinueSingleObject(const CPDF_PageObject* pObj,
+FX_BOOL CPDF_RenderStatus::ContinueSingleObject(CPDF_PageObject* pObj,
                                                 const CFX_Matrix* pObj2Device,
                                                 IFX_Pause* pPause) {
   if (m_pImageRenderer) {
     if (m_pImageRenderer->Continue(pPause))
       return TRUE;
 
     if (!m_pImageRenderer->m_Result)
       DrawObjWithBackground(pObj, pObj2Device);
     m_pImageRenderer.reset();
     return FALSE;
@@ skipping 40 matching lines @@
       rtClip.right =
           rtClip.left + (int32_t)FXSYS_ceil((FX_FLOAT)rtClip.Width() * a);
       rtClip.bottom =
           rtClip.top + (int32_t)FXSYS_ceil((FX_FLOAT)rtClip.Height() * d);
     }
   }
   rect.Intersect(rtClip);
   return rect.IsEmpty();
 }
 
-void CPDF_RenderStatus::ProcessObjectNoClip(const CPDF_PageObject* pObj,
+void CPDF_RenderStatus::ProcessObjectNoClip(CPDF_PageObject* pObj,
                                             const CFX_Matrix* pObj2Device) {
 #if defined _SKIA_SUPPORT_
   DebugVerifyDeviceIsPreMultiplied();
 #endif
   FX_BOOL bRet = FALSE;
   switch (pObj->GetType()) {
     case CPDF_PageObject::TEXT:
       bRet = ProcessText(pObj->AsText(), pObj2Device, nullptr);
       break;
     case CPDF_PageObject::PATH:
       bRet = ProcessPath(pObj->AsPath(), pObj2Device);
       break;
     case CPDF_PageObject::IMAGE:
       bRet = ProcessImage(pObj->AsImage(), pObj2Device);
       break;
     case CPDF_PageObject::SHADING:
       ProcessShading(pObj->AsShading(), pObj2Device);
       return;
     case CPDF_PageObject::FORM:
       bRet = ProcessForm(pObj->AsForm(), pObj2Device);
       break;
   }
   if (!bRet)
     DrawObjWithBackground(pObj, pObj2Device);
 #if defined _SKIA_SUPPORT_
   DebugVerifyDeviceIsPreMultiplied();
 #endif
 }
 
-FX_BOOL CPDF_RenderStatus::DrawObjWithBlend(const CPDF_PageObject* pObj,
+FX_BOOL CPDF_RenderStatus::DrawObjWithBlend(CPDF_PageObject* pObj,
                                             const CFX_Matrix* pObj2Device) {
   FX_BOOL bRet = FALSE;
   switch (pObj->GetType()) {
     case CPDF_PageObject::PATH:
       bRet = ProcessPath(pObj->AsPath(), pObj2Device);
       break;
     case CPDF_PageObject::IMAGE:
       bRet = ProcessImage(pObj->AsImage(), pObj2Device);
       break;
     case CPDF_PageObject::FORM:
       bRet = ProcessForm(pObj->AsForm(), 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,
+
+void CPDF_RenderStatus::DrawObjWithBackground(CPDF_PageObject* pObj,
                                               const CFX_Matrix* pObj2Device) {
   FX_RECT rect;
   if (GetObjectClippedRect(pObj, pObj2Device, FALSE, rect)) {
     return;
   }
   int res = 300;
   if (pObj->IsImage() &&
       m_pDevice->GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
     res = 0;
   }
@@ skipping 53 matching lines @@
 FX_BOOL IsAvailableMatrix(const CFX_Matrix& matrix) {
   if (matrix.a == 0 || matrix.d == 0) {
     return matrix.b != 0 && matrix.c != 0;
   }
   if (matrix.b == 0 || matrix.c == 0) {
     return matrix.a != 0 && matrix.d != 0;
   }
   return TRUE;
 }
 
-FX_BOOL CPDF_RenderStatus::ProcessPath(const CPDF_PathObject* pPathObj,
+FX_BOOL CPDF_RenderStatus::ProcessPath(CPDF_PathObject* pPathObj,
                                        const CFX_Matrix* pObj2Device) {
   int FillType = pPathObj->m_FillType;
   FX_BOOL bStroke = pPathObj->m_bStroke;
   ProcessPathPattern(pPathObj, pObj2Device, FillType, bStroke);
   if (FillType == 0 && !bStroke)
     return TRUE;
 
   uint32_t fill_argb = FillType ? GetFillArgb(pPathObj) : 0;
   uint32_t stroke_argb = bStroke ? GetStrokeArgb(pPathObj) : 0;
   CFX_Matrix path_matrix = pPathObj->m_Matrix;
   path_matrix.Concat(*pObj2Device);
   if (!IsAvailableMatrix(path_matrix))
     return TRUE;
 
   if (FillType && (m_Options.m_Flags & RENDER_RECT_AA))
     FillType |= FXFILL_RECT_AA;
   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;
-  const CPDF_GeneralStateData* pGeneralData =
-      static_cast<const CPDF_PageObject*>(pPathObj)->m_GeneralState.GetObject();
-  if (pGeneralData && pGeneralData->m_StrokeAdjust)
+
+  const CPDF_PageObject* pPageObj =
+      static_cast<const CPDF_PageObject*>(pPathObj);
+  if (pPageObj->m_GeneralState.GetStrokeAdjust())
     FillType |= FX_STROKE_ADJUST;
   if (m_pType3Char)
     FillType |= FX_FILL_TEXT_MODE;
 
   CPDF_GraphState graphState = pPathObj->m_GraphState;
   if (m_Options.m_Flags & RENDER_THINLINE)
     graphState.SetLineWidth(0);
   return m_pDevice->DrawPathWithBlend(
       pPathObj->m_Path.GetObject(), &path_matrix, graphState.GetObject(),
       fill_argb, stroke_argb, FillType, m_curBlend);
 }
 
 CPDF_TransferFunc* CPDF_RenderStatus::GetTransferFunc(CPDF_Object* pObj) const {
   ASSERT(pObj);
   CPDF_DocRenderData* pDocCache = m_pContext->GetDocument()->GetRenderData();
   return pDocCache ? pDocCache->GetTransferFunc(pObj) : nullptr;
 }
-FX_ARGB CPDF_RenderStatus::GetFillArgb(const CPDF_PageObject* pObj,
+
+FX_ARGB CPDF_RenderStatus::GetFillArgb(CPDF_PageObject* pObj,
                                        FX_BOOL bType3) const {
   const CPDF_ColorStateData* pColorData = pObj->m_ColorState.GetObject();
   if (m_pType3Char && !bType3 &&
       (!m_pType3Char->m_bColored ||
        (m_pType3Char->m_bColored &&
         (!pColorData || pColorData->m_FillColor.IsNull())))) {
     return m_T3FillColor;
   }
   if (!pColorData || pColorData->m_FillColor.IsNull()) {
     pColorData = m_InitialStates.m_ColorState.GetObject();
   }
   FX_COLORREF rgb = pColorData->m_FillRGB;
   if (rgb == (uint32_t)-1) {
     return 0;
   }
-  const CPDF_GeneralStateData* pGeneralData = pObj->m_GeneralState.GetObject();
-  int alpha;
-  if (pGeneralData) {
-    alpha = (int32_t)(pGeneralData->m_FillAlpha * 255);
-    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);
-      }
+  int32_t alpha = (int32_t)(pObj->m_GeneralState.GetFillAlpha() * 255);
+  if (pObj->m_GeneralState.GetTR()) {
+    if (!pObj->m_GeneralState.GetTransferFunc()) {
+      pObj->m_GeneralState.SetTransferFunc(
+          GetTransferFunc(pObj->m_GeneralState.GetTR()));
     }
-  } else {
-    alpha = 255;
+    if (pObj->m_GeneralState.GetTransferFunc())
+      rgb = pObj->m_GeneralState.GetTransferFunc()->TranslateColor(rgb);
   }
   return m_Options.TranslateColor(ArgbEncode(alpha, rgb));
 }
-FX_ARGB CPDF_RenderStatus::GetStrokeArgb(const CPDF_PageObject* pObj) const {
+
+FX_ARGB CPDF_RenderStatus::GetStrokeArgb(CPDF_PageObject* pObj) const {
   const CPDF_ColorStateData* pColorData = pObj->m_ColorState.GetObject();
   if (m_pType3Char && (!m_pType3Char->m_bColored ||
                        (m_pType3Char->m_bColored &&
                         (!pColorData || pColorData->m_StrokeColor.IsNull())))) {
     return m_T3FillColor;
   }
   if (!pColorData || pColorData->m_StrokeColor.IsNull()) {
     pColorData = m_InitialStates.m_ColorState.GetObject();
   }
   FX_COLORREF rgb = pColorData->m_StrokeRGB;
   if (rgb == (uint32_t)-1) {
     return 0;
   }
-  const CPDF_GeneralStateData* pGeneralData = pObj->m_GeneralState.GetObject();
-  int alpha;
-  if (pGeneralData) {
-    alpha = (int32_t)(pGeneralData->m_StrokeAlpha * 255);
-    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);
-      }
+  int32_t alpha =
+      (int32_t)(pObj->m_GeneralState.GetStrokeAlpha() * 255);  // not rounded.
+  if (pObj->m_GeneralState.GetTR()) {
+    if (!pObj->m_GeneralState.GetTransferFunc()) {
+      pObj->m_GeneralState.SetTransferFunc(
+          GetTransferFunc(pObj->m_GeneralState.GetTR()));
     }
-  } else {
-    alpha = 255;
+    if (pObj->m_GeneralState.GetTransferFunc())
+      rgb = pObj->m_GeneralState.GetTransferFunc()->TranslateColor(rgb);
   }
   return m_Options.TranslateColor(ArgbEncode(alpha, rgb));
 }
 void CPDF_RenderStatus::ProcessClipPath(CPDF_ClipPath ClipPath,
                                         const CFX_Matrix* pObj2Device) {
   if (!ClipPath) {
     if (m_LastClipPath) {
       m_pDevice->RestoreState(true);
       m_LastClipPath.SetNull();
     }
@@ skipping 87 matching lines @@
     return m_pDevice->SetClip_PathStroke(pPathObj->m_Path.GetObject(),
                                          &path_matrix, &graphState);
   }
   int fill_mode = pPathObj->m_FillType;
   if (m_Options.m_Flags & RENDER_NOPATHSMOOTH) {
     fill_mode |= FXFILL_NOPATHSMOOTH;
   }
   return m_pDevice->SetClip_PathFill(pPathObj->m_Path.GetObject(), &path_matrix,
                                      fill_mode);
 }
-FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
+FX_BOOL CPDF_RenderStatus::ProcessTransparency(CPDF_PageObject* pPageObj,
                                                const CFX_Matrix* pObj2Device) {
 #if defined _SKIA_SUPPORT_
   DebugVerifyDeviceIsPreMultiplied();
 #endif
-  const CPDF_GeneralStateData* pGeneralState =
-      pPageObj->m_GeneralState.GetObject();
-  int blend_type =
-      pGeneralState ? pGeneralState->m_BlendType : FXDIB_BLEND_NORMAL;
-  if (blend_type == FXDIB_BLEND_UNSUPPORTED) {
+  int blend_type = pPageObj->m_GeneralState.GetBlendType();
+  if (blend_type == FXDIB_BLEND_UNSUPPORTED)
     return TRUE;
-  }
+
   CPDF_Dictionary* pSMaskDict =
-      pGeneralState ? ToDictionary(pGeneralState->m_pSoftMask) : nullptr;
+      ToDictionary(pPageObj->m_GeneralState.GetSoftMask());
   if (pSMaskDict) {
     if (pPageObj->IsImage() &&
         pPageObj->AsImage()->GetImage()->GetDict()->KeyExist("SMask")) {
       pSMaskDict = nullptr;
     }
   }
   CPDF_Dictionary* pFormResource = nullptr;
   FX_FLOAT group_alpha = 1.0f;
   int Transparency = m_Transparency;
   FX_BOOL bGroupTransparent = FALSE;
   if (pPageObj->IsForm()) {
     const CPDF_FormObject* pFormObj = pPageObj->AsForm();
-    const CPDF_GeneralStateData* pStateData =
-        pFormObj->m_GeneralState.GetObject();
-    if (pStateData) {
-      group_alpha = pStateData->m_FillAlpha;
-    }
+    group_alpha = pFormObj->m_GeneralState.GetFillAlpha();
     Transparency = pFormObj->m_pForm->m_Transparency;
     bGroupTransparent = !!(Transparency & PDFTRANS_ISOLATED);
     if (pFormObj->m_pForm->m_pFormDict) {
       pFormResource = pFormObj->m_pForm->m_pFormDict->GetDictBy("Resources");
     }
   }
   bool bTextClip =
       (pPageObj->m_ClipPath && pPageObj->m_ClipPath.GetTextCount() &&
        m_pDevice->GetDeviceClass() == FXDC_DISPLAY &&
        !(m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_SOFT_CLIP));
   if ((m_Options.m_Flags & RENDER_OVERPRINT) && pPageObj->IsImage() &&
-      pGeneralState && pGeneralState->m_FillOP && pGeneralState->m_StrokeOP) {
+      pPageObj->m_GeneralState.GetFillOP() &&
+      pPageObj->m_GeneralState.GetStrokeOP()) {
     CPDF_Document* pDocument = nullptr;
     CPDF_Page* pPage = nullptr;
     if (m_pContext->GetPageCache()) {
       pPage = m_pContext->GetPageCache()->GetPage();
       pDocument = pPage->m_pDocument;
     } else {
       pDocument = pPageObj->AsImage()->GetImage()->GetDocument();
     }
     CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : nullptr;
     CPDF_Object* pCSObj = pPageObj->AsImage()
@@ skipping 81 matching lines @@
     }
   }
   CPDF_RenderStatus bitmap_render;
   bitmap_render.Initialize(m_pContext, &bitmap_device, nullptr, m_pStopObj,
                            nullptr, nullptr, &m_Options, 0, m_bDropObjects,
                            pFormResource, TRUE);
   bitmap_render.ProcessObjectNoClip(pPageObj, &new_matrix);
   m_bStopped = bitmap_render.m_bStopped;
   if (pSMaskDict) {
     CFX_Matrix smask_matrix;
-    FXSYS_memcpy(&smask_matrix, pGeneralState->m_SMaskMatrix,
+    FXSYS_memcpy(&smask_matrix, pPageObj->m_GeneralState.GetSMaskMatrix(),
                  sizeof smask_matrix);
     smask_matrix.Concat(*pObj2Device);
     std::unique_ptr<CFX_DIBSource> pSMaskSource(
         LoadSMask(pSMaskDict, &rect, &smask_matrix));
     if (pSMaskSource)
       bitmap->MultiplyAlpha(pSMaskSource.get());
   }
   if (pTextMask) {
     bitmap->MultiplyAlpha(pTextMask.get());
     pTextMask.reset();
@@ skipping 460 matching lines @@
     m_pDevice->StretchDIBits(m_pBitmapDevice->GetBitmap(), m_Rect.left,
                              m_Rect.top, m_Rect.Width(), m_Rect.Height());
   }
 }
 
 #if defined _SKIA_SUPPORT_
 void CPDF_RenderStatus::DebugVerifyDeviceIsPreMultiplied() const {
   m_pDevice->DebugVerifyBitmapIsPreMultiplied();
 }
 #endif