Store the address of the page data map's value for proper referencing.

core/src/fpdfapi/fpdf_page/fpdf_page_colors.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_page.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "pageint.h"
@@ skipping 742 matching lines @@
         min = 0;
         max = (FX_FLOAT)m_MaxIndex;
     }
     virtual FX_BOOL             GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const;
     virtual CPDF_ColorSpace*    GetBaseCS() const
     {
         return m_pBaseCS;
     }
     virtual void                EnableStdConversion(FX_BOOL bEnabled);
     CPDF_ColorSpace*    m_pBaseCS;
+    CPDF_CountedColorSpace*     m_pCountedBaseCS;
     int                                 m_nBaseComponents;
     int                                 m_MaxIndex;
     CFX_ByteString              m_Table;
     FX_FLOAT*           m_pCompMinMax;
 };
 CPDF_IndexedCS::CPDF_IndexedCS()
 {
     m_pBaseCS = NULL;
+    m_pCountedBaseCS = NULL;
     m_Family = PDFCS_INDEXED;
     m_nComponents = 1;
     m_pCompMinMax = NULL;
 }
 CPDF_IndexedCS::~CPDF_IndexedCS()
 {
     if (m_pCompMinMax) {
         FX_Free(m_pCompMinMax);
     }
+    CPDF_ColorSpace* pCS = m_pCountedBaseCS ? m_pCountedBaseCS->m_Obj : NULL;
+    if (pCS && m_pDocument) {
+        m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
+    }
 }
 FX_BOOL CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     if (pArray->GetCount() < 4) {
         return FALSE;
     }
     CPDF_Object* pBaseObj = pArray->GetElementValue(1);
     if (pBaseObj == m_pArray) {
         return FALSE;
     }
     CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
     m_pBaseCS = pDocPageData->GetColorSpace(pBaseObj, NULL);
     if (m_pBaseCS == NULL) {
         return FALSE;
     }
+    m_pCountedBaseCS = pDocPageData->FindColorSpacePtr(m_pBaseCS->GetArray());
     m_nBaseComponents = m_pBaseCS->CountComponents();
     m_pCompMinMax = FX_Alloc(FX_FLOAT, m_nBaseComponents * 2);
     FX_FLOAT defvalue;
     for (int i = 0; i < m_nBaseComponents; i ++) {
         m_pBaseCS->GetDefaultValue(i, defvalue, m_pCompMinMax[i * 2], m_pCompMinMax[i * 2 + 1]);
         m_pCompMinMax[i * 2 + 1] -= m_pCompMinMax[i * 2];
     }
     m_MaxIndex = pArray->GetInteger(2);
     CPDF_Object* pTableObj = pArray->GetElementValue(3);
     if (pTableObj == NULL) {
@@ skipping 33 matching lines @@
 void CPDF_IndexedCS::EnableStdConversion(FX_BOOL bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pBaseCS) {
         m_pBaseCS->EnableStdConversion(bEnabled);
     }
 }
 #define MAX_PATTERN_COLORCOMPS  16
 typedef struct _PatternValue {
     CPDF_Pattern*       m_pPattern;
+    CPDF_CountedPattern*        m_pCountedPattern;
     int                         m_nComps;
     FX_FLOAT            m_Comps[MAX_PATTERN_COLORCOMPS];
 } PatternValue;
 CPDF_PatternCS::CPDF_PatternCS()
 {
     m_Family = PDFCS_PATTERN;
     m_pBaseCS = NULL;
     m_nComponents = 1;
+    m_pCountedBaseCS = NULL;
 }
 CPDF_PatternCS::~CPDF_PatternCS()
 {
+    CPDF_ColorSpace* pCS = m_pCountedBaseCS ? m_pCountedBaseCS->m_Obj : NULL;
+    if (pCS && m_pDocument) {
+            m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
+    }
 }
 FX_BOOL CPDF_PatternCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Object* pBaseCS = pArray->GetElementValue(1);
     if (pBaseCS == m_pArray) {
         return FALSE;
     }
     CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
     m_pBaseCS = pDocPageData->GetColorSpace(pBaseCS, NULL);
     if (m_pBaseCS) {
         if (m_pBaseCS->GetFamily() == PDFCS_PATTERN) {
             return FALSE;
         }
+        m_pCountedBaseCS = pDocPageData->FindColorSpacePtr(m_pBaseCS->GetArray());
         m_nComponents = m_pBaseCS->CountComponents() + 1;
         if (m_pBaseCS->CountComponents() > MAX_PATTERN_COLORCOMPS) {
             return FALSE;
         }
     } else {
         m_nComponents = 1;
     }
     return TRUE;
 }
 FX_BOOL CPDF_PatternCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
@@ skipping 402 matching lines @@
     ReleaseBuffer();
     ReleaseColorSpace();
 }
 void CPDF_Color::ReleaseBuffer()
 {
     if (!m_pBuffer) {
         return;
     }
     if (m_pCS->GetFamily() == PDFCS_PATTERN) {
         PatternValue* pvalue = (PatternValue*)m_pBuffer;
-        CPDF_Pattern* pPattern = pvalue->m_pPattern;
+        CPDF_Pattern* pPattern = pvalue->m_pCountedPattern ? pvalue->m_pCountedPattern->m_Obj : NULL;
         if (pPattern && pPattern->m_pDocument) {
             CPDF_DocPageData *pPageData = pPattern->m_pDocument->GetPageData();
-            if (pPageData && !pPageData->IsForceClear()) {
+            if (pPageData) {
                 pPageData->ReleasePattern(pPattern->m_pPatternObj);
             }
         }
     }
     FX_Free(m_pBuffer);
     m_pBuffer = NULL;
 }
 void CPDF_Color::ReleaseColorSpace()
 {
     if (m_pCS && m_pCS->m_pDocument && m_pCS->GetArray()) {
@@ skipping 33 matching lines @@
     if (ncomps > MAX_PATTERN_COLORCOMPS) {
         return;
     }
     if (m_pCS == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
         if (m_pBuffer) {
             FX_Free(m_pBuffer);
         }
         m_pCS = CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
         m_pBuffer = m_pCS->CreateBuf();
     }
+    CPDF_DocPageData *pDocPageData = NULL;
     PatternValue* pvalue = (PatternValue*)m_pBuffer;
     if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {
-        CPDF_DocPageData *pDocPageData = pvalue->m_pPattern->m_pDocument->GetPageData();
-        if (pDocPageData && !pDocPageData->IsForceClear()) {
+        pDocPageData = pvalue->m_pPattern->m_pDocument->GetPageData();
+        if (pDocPageData) {
             pDocPageData->ReleasePattern(pvalue->m_pPattern->m_pPatternObj);
         }
     }
     pvalue->m_nComps = ncomps;
     pvalue->m_pPattern = pPattern;
     if (ncomps) {
         FXSYS_memcpy32(pvalue->m_Comps, comps, ncomps * sizeof(FX_FLOAT));
     }
+    pvalue->m_pCountedPattern = NULL;
+    if (pPattern && pPattern->m_pDocument)
+    {
+        if (!pDocPageData) {
+            pDocPageData = pPattern->m_pDocument->GetPageData();
+        }
+        pvalue->m_pCountedPattern = pDocPageData->FindPatternPtr(pPattern->m_pPatternObj);
+    }
 }
 void CPDF_Color::Copy(const CPDF_Color* pSrc)
 {
     ReleaseBuffer();
     ReleaseColorSpace();
     m_pCS = pSrc->m_pCS;
     if (m_pCS && m_pCS->m_pDocument) {
         CPDF_Array* pArray = m_pCS->GetArray();
         if (pArray) {
             m_pCS = m_pCS->m_pDocument->GetPageData()->GetCopiedColorSpace(pArray);
@@ skipping 48 matching lines @@
     PatternValue* pvalue = (PatternValue*)m_pBuffer;
     return pvalue->m_nComps ? pvalue->m_Comps : NULL;
 }
 FX_BOOL CPDF_Color::IsEqual(const CPDF_Color& other) const
 {
     if (m_pCS != other.m_pCS || m_pCS == NULL) {
         return FALSE;
     }
     return FXSYS_memcmp32(m_pBuffer, other.m_pBuffer, m_pCS->GetBufSize()) == 0;
 }