Make CPDF_Dictionary use unique pointers.

fpdfsdk/fpdfppo.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 "public/fpdf_ppo.h"
 
 #include <map>
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
 #include "core/fpdfapi/parser/cpdf_reference.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/cpdf_string.h"
 #include "fpdfsdk/fsdk_define.h"
@@ skipping 36 matching lines @@
 bool CopyInheritable(CPDF_Dictionary* pCurPageDict,
                      CPDF_Dictionary* pSrcPageDict,
                      const CFX_ByteString& key) {
   if (pCurPageDict->KeyExist(key))
     return true;
 
   CPDF_Object* pInheritable = PageDictGetInheritableTag(pSrcPageDict, key);
   if (!pInheritable)
     return false;
 
-  pCurPageDict->SetFor(key, pInheritable->Clone().release());
+  pCurPageDict->SetFor(key, pInheritable->Clone());
   return true;
 }
 
 bool ParserPageRangeString(CFX_ByteString rangstring,
                            std::vector<uint16_t>* pageArray,
                            int nCount) {
   if (rangstring.IsEmpty())
     return true;
 
   rangstring.Remove(' ');
@@ skipping 73 matching lines @@
   ASSERT(m_pSrcPDFDoc);
 
   CPDF_Dictionary* pNewRoot = m_pDestPDFDoc->GetRoot();
   if (!pNewRoot)
     return false;
 
   CPDF_Dictionary* pDocInfoDict = m_pDestPDFDoc->GetInfo();
   if (!pDocInfoDict)
     return false;
 
-  CFX_ByteString producerstr;
-  producerstr.Format("PDFium");
-  pDocInfoDict->SetFor("Producer",
-                       new CPDF_String(nullptr, producerstr, false));
+  pDocInfoDict->SetNewFor<CPDF_String>("Producer", "PDFium", false);
 
   CFX_ByteString cbRootType = pNewRoot->GetStringFor("Type", "");
   if (cbRootType.IsEmpty())
-    pNewRoot->SetFor("Type", new CPDF_Name(nullptr, "Catalog"));
+    pNewRoot->SetNewFor<CPDF_Name>("Type", "Catalog");
 
   CPDF_Object* pElement = pNewRoot->GetObjectFor("Pages");
   CPDF_Dictionary* pNewPages =
       pElement ? ToDictionary(pElement->GetDirect()) : nullptr;
   if (!pNewPages) {
     pNewPages = m_pDestPDFDoc->NewIndirect<CPDF_Dictionary>();
-    pNewRoot->SetReferenceFor("Pages", m_pDestPDFDoc, pNewPages);
+    pNewRoot->SetNewFor<CPDF_Reference>("Pages", m_pDestPDFDoc,
+                                        pNewPages->GetObjNum());
   }
 
   CFX_ByteString cbPageType = pNewPages->GetStringFor("Type", "");
   if (cbPageType.IsEmpty())
-    pNewPages->SetFor("Type", new CPDF_Name(nullptr, "Pages"));
+    pNewPages->SetNewFor<CPDF_Name>("Type", "Pages");
 
   if (!pNewPages->GetArrayFor("Kids")) {
-    pNewPages->SetIntegerFor("Count", 0);
-    pNewPages->SetReferenceFor("Kids", m_pDestPDFDoc,
-                               m_pDestPDFDoc->NewIndirect<CPDF_Array>());
+    pNewPages->SetNewFor<CPDF_Number>("Count", 0);
+    pNewPages->SetNewFor<CPDF_Reference>(
+        "Kids", m_pDestPDFDoc,
+        m_pDestPDFDoc->NewIndirect<CPDF_Array>()->GetObjNum());
   }
 
   return true;
 }
 
 bool CPDF_PageOrganizer::ExportPage(const std::vector<uint16_t>& pageNums,
                                     int nIndex) {
   int curpage = nIndex;
   auto pObjNumberMap = pdfium::MakeUnique<ObjectNumberMap>();
   int nSize = pdfium::CollectionSize<int>(pageNums);
   for (int i = 0; i < nSize; ++i) {
     CPDF_Dictionary* pCurPageDict = m_pDestPDFDoc->CreateNewPage(curpage);
     CPDF_Dictionary* pSrcPageDict = m_pSrcPDFDoc->GetPage(pageNums[i] - 1);
     if (!pSrcPageDict || !pCurPageDict)
       return false;
 
     // Clone the page dictionary
     for (const auto& it : *pSrcPageDict) {
       const CFX_ByteString& cbSrcKeyStr = it.first;
-      CPDF_Object* pObj = it.second;
       if (cbSrcKeyStr == "Type" || cbSrcKeyStr == "Parent")
         continue;
 
-      pCurPageDict->SetFor(cbSrcKeyStr, pObj->Clone().release());
+      CPDF_Object* pObj = it.second.get();
+      pCurPageDict->SetFor(cbSrcKeyStr, pObj->Clone());
     }
 
     // inheritable item
     // 1 MediaBox - required
     if (!CopyInheritable(pCurPageDict, pSrcPageDict, "MediaBox")) {
       // Search for "CropBox" in the source page dictionary,
       // if it does not exists, use the default letter size.
       CPDF_Object* pInheritable =
           PageDictGetInheritableTag(pSrcPageDict, "CropBox");
       if (pInheritable) {
-        pCurPageDict->SetFor("MediaBox", pInheritable->Clone().release());
+        pCurPageDict->SetFor("MediaBox", pInheritable->Clone());
       } else {
         // Make the default size to be letter size (8.5'x11')
-        CPDF_Array* pArray = new CPDF_Array;
+        CPDF_Array* pArray = pCurPageDict->SetNewFor<CPDF_Array>("MediaBox");
         pArray->AddNew<CPDF_Number>(0);
         pArray->AddNew<CPDF_Number>(0);
         pArray->AddNew<CPDF_Number>(612);
         pArray->AddNew<CPDF_Number>(792);
-        pCurPageDict->SetFor("MediaBox", pArray);
       }
     }
 
     // 2 Resources - required
     if (!CopyInheritable(pCurPageDict, pSrcPageDict, "Resources"))
       return false;
 
     // 3 CropBox - optional
     CopyInheritable(pCurPageDict, pSrcPageDict, "CropBox");
     // 4 Rotate - optional
@@ skipping 19 matching lines @@
       if (newobjnum == 0)
         return false;
       pReference->SetRef(m_pDestPDFDoc, newobjnum);
       break;
     }
     case CPDF_Object::DICTIONARY: {
       CPDF_Dictionary* pDict = pObj->AsDictionary();
       auto it = pDict->begin();
       while (it != pDict->end()) {
         const CFX_ByteString& key = it->first;
-        CPDF_Object* pNextObj = it->second;
+        CPDF_Object* pNextObj = it->second.get();
         ++it;
         if (key == "Parent" || key == "Prev" || key == "First")
           continue;
         if (!pNextObj)
           return false;
         if (!UpdateReference(pNextObj, pObjNumberMap))
           pDict->RemoveFor(key);
       }
       break;
     }
@@ skipping 100 matching lines @@
 
   CPDF_Dictionary* pSrcDict = pSrcDoc->GetRoot();
   pSrcDict = pSrcDict->GetDictFor("ViewerPreferences");
   if (!pSrcDict)
     return false;
 
   CPDF_Dictionary* pDstDict = pDstDoc->GetRoot();
   if (!pDstDict)
     return false;
 
-  pDstDict->SetFor("ViewerPreferences",
-                   pSrcDict->CloneDirectObject().release());
+  pDstDict->SetFor("ViewerPreferences", pSrcDict->CloneDirectObject());
   return true;
 }