Cleanup CPDF_DocPageData release methods and callers.

core/fpdfapi/fpdf_page/fpdf_page_doc.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_page/pageint.h"
 
+#include <algorithm>
+#include <set>
+
 #include "core/fdrm/crypto/include/fx_crypt.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type1font.h"
 #include "core/fpdfapi/fpdf_font/font_int.h"
 #include "core/fpdfapi/fpdf_page/cpdf_pagemodule.h"
 #include "core/fpdfapi/fpdf_page/cpdf_pattern.h"
 #include "core/fpdfapi/fpdf_page/cpdf_shadingpattern.h"
 #include "core/fpdfapi/fpdf_page/cpdf_tilingpattern.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_image.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
@@ skipping 74 matching lines @@
         }
       }
       delete ipData->get();
       delete ipData;
       m_IccProfileMap.erase(curr_it);
     }
   }
 
   for (auto it = m_FontFileMap.begin(); it != m_FontFileMap.end();) {
     auto curr_it = it++;
-    CPDF_CountedStreamAcc* ftData = curr_it->second;
-    if (!ftData->get())
+    CPDF_CountedStreamAcc* pCountedFont = curr_it->second;
+    if (!pCountedFont->get())
       continue;
 
-    if (bForceRelease || ftData->use_count() < 2) {
-      delete ftData->get();
-      delete ftData;
+    if (bForceRelease || pCountedFont->use_count() < 2) {
+      delete pCountedFont->get();
+      delete pCountedFont;
       m_FontFileMap.erase(curr_it);
     }
   }
 
   for (auto it = m_ImageMap.begin(); it != m_ImageMap.end();) {
     auto curr_it = it++;
-    CPDF_CountedImage* imageData = curr_it->second;
-    if (!imageData->get())
+    CPDF_CountedImage* pCountedImage = curr_it->second;
+    if (!pCountedImage->get())
       continue;
 
-    if (bForceRelease || imageData->use_count() < 2) {
-      delete imageData->get();
-      delete imageData;
+    if (bForceRelease || pCountedImage->use_count() < 2) {
+      delete pCountedImage->get();
+      delete pCountedImage;
       m_ImageMap.erase(curr_it);
     }
   }
 }
 
 CPDF_Font* CPDF_DocPageData::GetFont(CPDF_Dictionary* pFontDict,
                                      FX_BOOL findOnly) {
-  if (!pFontDict) {
+  if (!pFontDict)
     return nullptr;
-  }
-  if (findOnly) {
-    auto it = m_FontMap.find(pFontDict);
-    if (it != m_FontMap.end() && it->second->get()) {
-      return it->second->AddRef();
-    }
-    return nullptr;
-  }
 
-  CPDF_CountedFont* fontData = nullptr;
+  CPDF_CountedFont* pFontData = nullptr;
   auto it = m_FontMap.find(pFontDict);
   if (it != m_FontMap.end()) {
-    fontData = it->second;
-    if (fontData->get()) {
-      return fontData->AddRef();
+    pFontData = it->second;
+    if (pFontData->get()) {
+      return pFontData->AddRef();
     }
   }
 
+  if (findOnly)
+    return nullptr;
+
   CPDF_Font* pFont = CPDF_Font::CreateFontF(m_pPDFDoc, pFontDict);
-  if (!pFont) {
+  if (!pFont)
     return nullptr;
+
+  if (pFontData) {
+    pFontData->reset(pFont);
+  } else {
+    pFontData = new CPDF_CountedFont(pFont);
+    m_FontMap[pFontDict] = pFontData;
   }
-  if (!fontData) {
-    fontData = new CPDF_CountedFont(pFont);
-    m_FontMap[pFontDict] = fontData;
-  } else {
-    fontData->reset(pFont);
-  }
-  return fontData->AddRef();
+  return pFontData->AddRef();
 }
 
 CPDF_Font* CPDF_DocPageData::GetStandardFont(const CFX_ByteString& fontName,
                                              CPDF_FontEncoding* pEncoding) {
   if (fontName.IsEmpty())
     return nullptr;
 
   for (auto& it : m_FontMap) {
     CPDF_CountedFont* fontData = it.second;
     CPDF_Font* pFont = fontData->get();
@@ skipping 25 matching lines @@
   m_pPDFDoc->AddIndirectObject(pDict);
   CPDF_Font* pFont = CPDF_Font::CreateFontF(m_pPDFDoc, pDict);
   if (!pFont) {
     return nullptr;
   }
   CPDF_CountedFont* fontData = new CPDF_CountedFont(pFont);
   m_FontMap[pDict] = fontData;
   return fontData->AddRef();
 }
 
-void CPDF_DocPageData::ReleaseFont(CPDF_Dictionary* pFontDict) {
+void CPDF_DocPageData::ReleaseFont(const CPDF_Dictionary* pFontDict) {
   if (!pFontDict)
     return;
 
   auto it = m_FontMap.find(pFontDict);
   if (it == m_FontMap.end())
     return;
 
-  CPDF_CountedFont* fontData = it->second;
-  if (fontData->get()) {
-    fontData->RemoveRef();
-    if (fontData->use_count() == 0) {
-      fontData->clear();
-    }
-  }
+  CPDF_CountedFont* pFontData = it->second;
+  if (!pFontData->get())
+    return;
+
+  pFontData->RemoveRef();
+  if (pFontData->use_count() != 0)
+    return;
+
+  pFontData->clear();
 }
 
 CPDF_ColorSpace* CPDF_DocPageData::GetColorSpace(
     CPDF_Object* pCSObj,
     const CPDF_Dictionary* pResources) {
   std::set<CPDF_Object*> visited;
   return GetColorSpaceImpl(pCSObj, pResources, &visited);
 }
 
 CPDF_ColorSpace* CPDF_DocPageData::GetColorSpaceImpl(
@@ skipping 79 matching lines @@
   if (!pCSObj)
     return nullptr;
 
   auto it = m_ColorSpaceMap.find(pCSObj);
   if (it != m_ColorSpaceMap.end())
     return it->second->AddRef();
 
   return nullptr;
 }
 
-void CPDF_DocPageData::ReleaseColorSpace(CPDF_Object* pColorSpace) {
+void CPDF_DocPageData::ReleaseColorSpace(const CPDF_Object* pColorSpace) {
   if (!pColorSpace)
     return;
 
   auto it = m_ColorSpaceMap.find(pColorSpace);
   if (it == m_ColorSpaceMap.end())
     return;
 
-  CPDF_CountedColorSpace* csData = it->second;
-  if (csData->get()) {
-    csData->RemoveRef();
-    if (csData->use_count() == 0) {
-      csData->get()->ReleaseCS();
-      csData->reset(nullptr);
-    }
-  }
+  CPDF_CountedColorSpace* pCountedColorSpace = it->second;
+  if (!pCountedColorSpace->get())
+    return;
+
+  pCountedColorSpace->RemoveRef();
+  if (pCountedColorSpace->use_count() != 0)
+    return;
+
+  pCountedColorSpace->get()->ReleaseCS();
+  pCountedColorSpace->reset(nullptr);
 }
 
 CPDF_Pattern* CPDF_DocPageData::GetPattern(CPDF_Object* pPatternObj,
                                            FX_BOOL bShading,
                                            const CFX_Matrix& matrix) {
   if (!pPatternObj)
     return nullptr;
 
   CPDF_CountedPattern* ptData = nullptr;
   auto it = m_PatternMap.find(pPatternObj);
@@ skipping 23 matching lines @@
 
   if (!ptData) {
     ptData = new CPDF_CountedPattern(pPattern);
     m_PatternMap[pPatternObj] = ptData;
   } else {
     ptData->reset(pPattern);
   }
   return ptData->AddRef();
 }
 
-void CPDF_DocPageData::ReleasePattern(CPDF_Object* pPatternObj) {
+void CPDF_DocPageData::ReleasePattern(const CPDF_Object* pPatternObj) {
   if (!pPatternObj)
     return;
 
   auto it = m_PatternMap.find(pPatternObj);
   if (it == m_PatternMap.end())
     return;
 
-  CPDF_CountedPattern* ptData = it->second;
-  if (ptData->get()) {
-    ptData->RemoveRef();
-    if (ptData->use_count() == 0) {
-      ptData->clear();
-    }
-  }
+  CPDF_CountedPattern* pPattern = it->second;
+  if (!pPattern->get())
+    return;
+
+  pPattern->RemoveRef();
+  if (pPattern->use_count() != 0)
+    return;
+
+  pPattern->clear();
 }
 
 CPDF_Image* CPDF_DocPageData::GetImage(CPDF_Object* pImageStream) {
   if (!pImageStream)
     return nullptr;
 
   const uint32_t dwImageObjNum = pImageStream->GetObjNum();
   auto it = m_ImageMap.find(dwImageObjNum);
-  if (it != m_ImageMap.end()) {
+  if (it != m_ImageMap.end())
     return it->second->AddRef();
-  }
 
   CPDF_Image* pImage = new CPDF_Image(m_pPDFDoc);
-  pImage->LoadImageF(pImageStream->AsStream(), FALSE);
+  pImage->LoadImageF(pImageStream->AsStream(), false);
 
-  CPDF_CountedImage* imageData = new CPDF_CountedImage(pImage);
-  m_ImageMap[dwImageObjNum] = imageData;
-  return imageData->AddRef();
+  CPDF_CountedImage* pCountedImage = new CPDF_CountedImage(pImage);
+  m_ImageMap[dwImageObjNum] = pCountedImage;
+  return pCountedImage->AddRef();
 }
 
-void CPDF_DocPageData::ReleaseImage(CPDF_Object* pImageStream) {
-  if (!pImageStream || !pImageStream->GetObjNum())
+void CPDF_DocPageData::ReleaseImage(const CPDF_Object* pImageStream) {
+  if (!pImageStream)
     return;
 
-  auto it = m_ImageMap.find(pImageStream->GetObjNum());
+  uint32_t dwObjNum = pImageStream->GetObjNum();
+  if (!dwObjNum)
+    return;
+
+  auto it = m_ImageMap.find(dwObjNum);
   if (it == m_ImageMap.end())
     return;
 
-  CPDF_CountedImage* image = it->second;
-  if (!image)
+  CPDF_CountedImage* pCountedImage = it->second;
+  if (!pCountedImage)
     return;
 
-  image->RemoveRef();
-  if (image->use_count() == 0) {
-    delete image->get();
-    delete image;
-    m_ImageMap.erase(it);
-  }
+  pCountedImage->RemoveRef();
+  if (pCountedImage->use_count() != 0)
+    return;
+
+  delete pCountedImage->get();
+  delete pCountedImage;
+  m_ImageMap.erase(it);
 }
 
 CPDF_IccProfile* CPDF_DocPageData::GetIccProfile(
     CPDF_Stream* pIccProfileStream) {
   if (!pIccProfileStream)
     return nullptr;
 
   auto it = m_IccProfileMap.find(pIccProfileStream);
-  if (it != m_IccProfileMap.end()) {
+  if (it != m_IccProfileMap.end())
     return it->second->AddRef();
-  }
 
   CPDF_StreamAcc stream;
   stream.LoadAllData(pIccProfileStream, FALSE);
   uint8_t digest[20];
   CRYPT_SHA1Generate(stream.GetData(), stream.GetSize(), digest);
   CFX_ByteString bsDigest(digest, 20);
   auto hash_it = m_HashProfileMap.find(bsDigest);
   if (hash_it != m_HashProfileMap.end()) {
     auto it_copied_stream = m_IccProfileMap.find(hash_it->second);
     return it_copied_stream->second->AddRef();
   }
   CPDF_IccProfile* pProfile =
       new CPDF_IccProfile(stream.GetData(), stream.GetSize());
   CPDF_CountedIccProfile* ipData = new CPDF_CountedIccProfile(pProfile);
   m_IccProfileMap[pIccProfileStream] = ipData;
   m_HashProfileMap[bsDigest] = pIccProfileStream;
   return ipData->AddRef();
 }
 
-void CPDF_DocPageData::ReleaseIccProfile(CPDF_IccProfile* pIccProfile) {
+void CPDF_DocPageData::ReleaseIccProfile(const CPDF_IccProfile* pIccProfile) {
   ASSERT(pIccProfile);
 
   for (auto it = m_IccProfileMap.begin(); it != m_IccProfileMap.end(); ++it) {
     CPDF_CountedIccProfile* profile = it->second;
     if (profile->get() != pIccProfile)
       continue;
 
     profile->RemoveRef();
     if (profile->use_count() == 0) {
       delete profile->get();
       delete profile;
       m_IccProfileMap.erase(it);
       return;
     }
   }
 }
 
 CPDF_StreamAcc* CPDF_DocPageData::GetFontFileStreamAcc(
     CPDF_Stream* pFontStream) {
   ASSERT(pFontStream);
 
   auto it = m_FontFileMap.find(pFontStream);
   if (it != m_FontFileMap.end())
     return it->second->AddRef();
 
   CPDF_Dictionary* pFontDict = pFontStream->GetDict();
   int32_t org_size = pFontDict->GetIntegerBy("Length1") +
                      pFontDict->GetIntegerBy("Length2") +
                      pFontDict->GetIntegerBy("Length3");
-  if (org_size < 0)
-    org_size = 0;
+  org_size = std::max(org_size, 0);
 
   CPDF_StreamAcc* pFontFile = new CPDF_StreamAcc;
   pFontFile->LoadAllData(pFontStream, FALSE, org_size);
 
-  CPDF_CountedStreamAcc* ftData = new CPDF_CountedStreamAcc(pFontFile);
-  m_FontFileMap[pFontStream] = ftData;
-  return ftData->AddRef();
+  CPDF_CountedStreamAcc* pCountedFont = new CPDF_CountedStreamAcc(pFontFile);
+  m_FontFileMap[pFontStream] = pCountedFont;
+  return pCountedFont->AddRef();
 }
 
-void CPDF_DocPageData::ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream,
-                                                FX_BOOL bForce) {
+void CPDF_DocPageData::ReleaseFontFileStreamAcc(
+    const CPDF_Stream* pFontStream) {
   if (!pFontStream)
     return;
 
   auto it = m_FontFileMap.find(pFontStream);
   if (it == m_FontFileMap.end())
     return;
 
-  CPDF_CountedStreamAcc* findData = it->second;
-  if (!findData)
+  CPDF_CountedStreamAcc* pCountedStream = it->second;
+  if (!pCountedStream)
     return;
 
-  findData->RemoveRef();
-  if (findData->use_count() == 0 || bForce) {
-    delete findData->get();
-    delete findData;
-    m_FontFileMap.erase(it);
-  }
+  pCountedStream->RemoveRef();
+  if (pCountedStream->use_count() != 0)
+    return;
+
+  delete pCountedStream->get();
+  delete pCountedStream;
+  m_FontFileMap.erase(it);
 }
 
 CPDF_CountedColorSpace* CPDF_DocPageData::FindColorSpacePtr(
     CPDF_Object* pCSObj) const {
   if (!pCSObj)
     return nullptr;
 
   auto it = m_ColorSpaceMap.find(pCSObj);
   return it != m_ColorSpaceMap.end() ? it->second : nullptr;
 }
 
 CPDF_CountedPattern* CPDF_DocPageData::FindPatternPtr(
     CPDF_Object* pPatternObj) const {
   if (!pPatternObj)
     return nullptr;
 
   auto it = m_PatternMap.find(pPatternObj);
   return it != m_PatternMap.end() ? it->second : nullptr;
 }