Make CPDF_ColorSpace::Load() return a unique_ptr

core/fpdfapi/fpdf_page/cpdf_colorspace.cpp

 // Copyright 2016 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/include/cpdf_colorspace.h"
 
 #include <memory>
 
@@ skipping 203 matching lines @@
                        FX_FLOAT& value,
                        FX_FLOAT& min,
                        FX_FLOAT& max) const override;
   FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
   FX_BOOL GetRGB(FX_FLOAT* pBuf,
                  FX_FLOAT& R,
                  FX_FLOAT& G,
                  FX_FLOAT& B) const override;
   void EnableStdConversion(FX_BOOL bEnabled) override;
 
-  CPDF_ColorSpace* m_pAltCS;
+  std::unique_ptr<CPDF_ColorSpace> m_pAltCS;
   std::unique_ptr<CPDF_Function> m_pFunc;
   enum { None, All, Colorant } m_Type;
 };
 
 class CPDF_DeviceNCS : public CPDF_ColorSpace {
  public:
   explicit CPDF_DeviceNCS(CPDF_Document* pDoc);
   ~CPDF_DeviceNCS() override;
 
   // CPDF_ColorSpace:
   void GetDefaultValue(int iComponent,
                        FX_FLOAT& value,
                        FX_FLOAT& min,
                        FX_FLOAT& max) const override;
   FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
   FX_BOOL GetRGB(FX_FLOAT* pBuf,
                  FX_FLOAT& R,
                  FX_FLOAT& G,
                  FX_FLOAT& B) const override;
   void EnableStdConversion(FX_BOOL bEnabled) override;
 
-  CPDF_ColorSpace* m_pAltCS;
+  std::unique_ptr<CPDF_ColorSpace> m_pAltCS;
   std::unique_ptr<CPDF_Function> m_pFunc;
 };
 
 FX_FLOAT RGB_Conversion(FX_FLOAT colorComponent) {
   if (colorComponent > 1)
     colorComponent = 1;
   if (colorComponent < 0)
     colorComponent = 0;
 
   int scale = (int)(colorComponent * 1023);
@@ skipping 49 matching lines @@
 
   R = RGB_Conversion(RGB.a);
   G = RGB_Conversion(RGB.b);
   B = RGB_Conversion(RGB.c);
 }
 
 }  // namespace
 
 CPDF_ColorSpace* CPDF_ColorSpace::ColorspaceFromName(
     const CFX_ByteString& name) {
-  if (name == "DeviceRGB" || name == "RGB") {
+  if (name == "DeviceRGB" || name == "RGB")
     return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
-  }
-  if (name == "DeviceGray" || name == "G") {
+  if (name == "DeviceGray" || name == "G")
     return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
-  }
-  if (name == "DeviceCMYK" || name == "CMYK") {
+  if (name == "DeviceCMYK" || name == "CMYK")
     return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
-  }
-  if (name == "Pattern") {
+  if (name == "Pattern")
     return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
-  }
   return nullptr;
 }
 
 CPDF_ColorSpace* CPDF_ColorSpace::GetStockCS(int family) {
   return CPDF_ModuleMgr::Get()->GetPageModule()->GetStockCS(family);
 }
 
-CPDF_ColorSpace* CPDF_ColorSpace::Load(CPDF_Document* pDoc, CPDF_Object* pObj) {
+std::unique_ptr<CPDF_ColorSpace> CPDF_ColorSpace::Load(CPDF_Document* pDoc,
+                                                       CPDF_Object* pObj) {
   if (!pObj)
-    return nullptr;
-  if (pObj->IsName())
-    return ColorspaceFromName(pObj->GetString());
+    return std::unique_ptr<CPDF_ColorSpace>();
 
+  if (pObj->IsName()) {
+    return std::unique_ptr<CPDF_ColorSpace>(
+        ColorspaceFromName(pObj->GetString()));
+  }
   if (CPDF_Stream* pStream = pObj->AsStream()) {
     CPDF_Dictionary* pDict = pStream->GetDict();
     if (!pDict)
-      return nullptr;
+      return std::unique_ptr<CPDF_ColorSpace>();
 
     for (const auto& it : *pDict) {
-      CPDF_ColorSpace* pRet = nullptr;
+      std::unique_ptr<CPDF_ColorSpace> pRet;
       CPDF_Object* pValue = it.second;
       if (ToName(pValue))
-        pRet = ColorspaceFromName(pValue->GetString());
+        pRet.reset(ColorspaceFromName(pValue->GetString()));
       if (pRet)
         return pRet;
     }
-    return nullptr;
+    return std::unique_ptr<CPDF_ColorSpace>();
   }
 
   CPDF_Array* pArray = pObj->AsArray();
   if (!pArray || pArray->IsEmpty())
-    return nullptr;
+    return std::unique_ptr<CPDF_ColorSpace>();
 
   CPDF_Object* pFamilyObj = pArray->GetDirectObjectAt(0);
   if (!pFamilyObj)
-    return nullptr;
+    return std::unique_ptr<CPDF_ColorSpace>();
 
   CFX_ByteString familyname = pFamilyObj->GetString();
   if (pArray->GetCount() == 1)
-    return ColorspaceFromName(familyname);
+    return std::unique_ptr<CPDF_ColorSpace>(ColorspaceFromName(familyname));
 
-  CPDF_ColorSpace* pCS = nullptr;
+  std::unique_ptr<CPDF_ColorSpace> pCS;
   uint32_t id = familyname.GetID();
   if (id == FXBSTR_ID('C', 'a', 'l', 'G')) {
-    pCS = new CPDF_CalGray(pDoc);
+    pCS.reset(new CPDF_CalGray(pDoc));
   } else if (id == FXBSTR_ID('C', 'a', 'l', 'R')) {
-    pCS = new CPDF_CalRGB(pDoc);
+    pCS.reset(new CPDF_CalRGB(pDoc));
   } else if (id == FXBSTR_ID('L', 'a', 'b', 0)) {
-    pCS = new CPDF_LabCS(pDoc);
+    pCS.reset(new CPDF_LabCS(pDoc));
   } else if (id == FXBSTR_ID('I', 'C', 'C', 'B')) {
-    pCS = new CPDF_ICCBasedCS(pDoc);
+    pCS.reset(new CPDF_ICCBasedCS(pDoc));
   } else if (id == FXBSTR_ID('I', 'n', 'd', 'e') ||
              id == FXBSTR_ID('I', 0, 0, 0)) {
-    pCS = new CPDF_IndexedCS(pDoc);
+    pCS.reset(new CPDF_IndexedCS(pDoc));
   } else if (id == FXBSTR_ID('S', 'e', 'p', 'a')) {
-    pCS = new CPDF_SeparationCS(pDoc);
+    pCS.reset(new CPDF_SeparationCS(pDoc));
   } else if (id == FXBSTR_ID('D', 'e', 'v', 'i')) {
-    pCS = new CPDF_DeviceNCS(pDoc);
+    pCS.reset(new CPDF_DeviceNCS(pDoc));
   } else if (id == FXBSTR_ID('P', 'a', 't', 't')) {
-    pCS = new CPDF_PatternCS(pDoc);
+    pCS.reset(new CPDF_PatternCS(pDoc));
   } else {
-    return nullptr;
+    return std::unique_ptr<CPDF_ColorSpace>();
   }
   pCS->m_pArray = pArray;
-  if (!pCS->v_Load(pDoc, pArray)) {
-    pCS->ReleaseCS();
-    return nullptr;
-  }
+  if (!pCS->v_Load(pDoc, pArray))
+    return std::unique_ptr<CPDF_ColorSpace>();
+
   return pCS;
 }
 
-void CPDF_ColorSpace::ReleaseCS() {
-  if (this == GetStockCS(PDFCS_DEVICERGB)) {
-    return;
-  }
-  if (this == GetStockCS(PDFCS_DEVICEGRAY)) {
-    return;
-  }
-  if (this == GetStockCS(PDFCS_DEVICECMYK)) {
-    return;
-  }
-  if (this == GetStockCS(PDFCS_PATTERN)) {
+void CPDF_ColorSpace::Release() {
+  if (this == GetStockCS(PDFCS_DEVICERGB) ||
+      this == GetStockCS(PDFCS_DEVICEGRAY) ||
+      this == GetStockCS(PDFCS_DEVICECMYK) ||
+      this == GetStockCS(PDFCS_PATTERN)) {
     return;
   }
   delete this;
 }
 
 int CPDF_ColorSpace::GetBufSize() const {
   if (m_Family == PDFCS_PATTERN) {
     return sizeof(PatternValue);
   }
   return m_nComponents * sizeof(FX_FLOAT);
@@ skipping 405 matching lines @@
       m_pAlterCS(nullptr),
       m_pProfile(nullptr),
       m_pCache(nullptr),
       m_pRanges(nullptr),
       m_bOwn(FALSE) {}
 
 CPDF_ICCBasedCS::~CPDF_ICCBasedCS() {
   FX_Free(m_pCache);
   FX_Free(m_pRanges);
   if (m_pAlterCS && m_bOwn)
-    m_pAlterCS->ReleaseCS();
+    m_pAlterCS->Release();
   if (m_pProfile && m_pDocument)
     m_pDocument->GetPageData()->ReleaseIccProfile(m_pProfile);
 }
 
 FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) {
   CPDF_Stream* pStream = pArray->GetStreamAt(1);
   if (!pStream)
     return FALSE;
 
   m_pProfile = pDoc->LoadIccProfile(pStream);
   if (!m_pProfile)
     return FALSE;
 
   m_nComponents =
       m_pProfile
           ->GetComponents();  // Try using the nComponents from ICC profile
   CPDF_Dictionary* pDict = pStream->GetDict();
   if (!m_pProfile->m_pTransform) {  // No valid ICC profile or using sRGB
     CPDF_Object* pAlterCSObj =
         pDict ? pDict->GetDirectObjectFor("Alternate") : nullptr;
     if (pAlterCSObj) {
-      CPDF_ColorSpace* pAlterCS = CPDF_ColorSpace::Load(pDoc, pAlterCSObj);
+      std::unique_ptr<CPDF_ColorSpace> pAlterCS =
+          CPDF_ColorSpace::Load(pDoc, pAlterCSObj);
       if (pAlterCS) {
         if (m_nComponents == 0) {                 // NO valid ICC profile
           if (pAlterCS->CountComponents() > 0) {  // Use Alternative colorspace
             m_nComponents = pAlterCS->CountComponents();
-            m_pAlterCS = pAlterCS;
+            m_pAlterCS = pAlterCS.release();
             m_bOwn = TRUE;
           } else {  // No valid alternative colorspace
-            pAlterCS->ReleaseCS();
             int32_t nDictComponents = pDict ? pDict->GetIntegerFor("N") : 0;
             if (nDictComponents != 1 && nDictComponents != 3 &&
                 nDictComponents != 4) {
               return FALSE;
             }
             m_nComponents = nDictComponents;
           }
-
         } else {  // Using sRGB
-          if (pAlterCS->CountComponents() != m_nComponents) {
-            pAlterCS->ReleaseCS();
-          } else {
-            m_pAlterCS = pAlterCS;
+          if (pAlterCS->CountComponents() == m_nComponents) {
+            m_pAlterCS = pAlterCS.release();
             m_bOwn = TRUE;
           }
         }
       }
     }
     if (!m_pAlterCS) {
       if (m_nComponents == 1)
         m_pAlterCS = GetStockCS(PDFCS_DEVICEGRAY);
       else if (m_nComponents == 3)
         m_pAlterCS = GetStockCS(PDFCS_DEVICERGB);
@@ skipping 259 matching lines @@
   }
   R = G = B = 0.75f;
   return FALSE;
 }
 
 CPDF_ColorSpace* CPDF_PatternCS::GetBaseCS() const {
   return m_pBaseCS;
 }
 
 CPDF_SeparationCS::CPDF_SeparationCS(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_SEPARATION, 1), m_pAltCS(nullptr) {}
+    : CPDF_ColorSpace(pDoc, PDFCS_SEPARATION, 1) {}
 
-CPDF_SeparationCS::~CPDF_SeparationCS() {
-  if (m_pAltCS)
-    m_pAltCS->ReleaseCS();
-}
+CPDF_SeparationCS::~CPDF_SeparationCS() {}
 
 void CPDF_SeparationCS::GetDefaultValue(int iComponent,
                                         FX_FLOAT& value,
                                         FX_FLOAT& min,
                                         FX_FLOAT& max) const {
   value = 1.0f;
   min = 0;
   max = 1.0f;
 }
 
@@ skipping 55 matching lines @@
   return FALSE;
 }
 
 void CPDF_SeparationCS::EnableStdConversion(FX_BOOL bEnabled) {
   CPDF_ColorSpace::EnableStdConversion(bEnabled);
   if (m_pAltCS)
     m_pAltCS->EnableStdConversion(bEnabled);
 }
 
 CPDF_DeviceNCS::CPDF_DeviceNCS(CPDF_Document* pDoc)
-    : CPDF_ColorSpace(pDoc, PDFCS_DEVICEN, 0), m_pAltCS(nullptr) {}
+    : CPDF_ColorSpace(pDoc, PDFCS_DEVICEN, 0) {}
 
-CPDF_DeviceNCS::~CPDF_DeviceNCS() {
-  if (m_pAltCS)
-    m_pAltCS->ReleaseCS();
-}
+CPDF_DeviceNCS::~CPDF_DeviceNCS() {}
 
 void CPDF_DeviceNCS::GetDefaultValue(int iComponent,
                                      FX_FLOAT& value,
                                      FX_FLOAT& min,
                                      FX_FLOAT& max) const {
   value = 1.0f;
   min = 0;
   max = 1.0f;
 }
 
@@ skipping 30 matching lines @@
 
   return m_pAltCS->GetRGB(results, R, G, B);
 }
 
 void CPDF_DeviceNCS::EnableStdConversion(FX_BOOL bEnabled) {
   CPDF_ColorSpace::EnableStdConversion(bEnabled);
   if (m_pAltCS) {
     m_pAltCS->EnableStdConversion(bEnabled);
   }
 }