Make AddIndirectObject() take a unique_ptr.

core/fpdfapi/parser/cpdf_object_unittest.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.
 
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_boolean.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_null.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
@@ skipping 72 matching lines @@
                            stream_obj,        null_obj};
     m_DirectObjTypes = {
         CPDF_Object::BOOLEAN, CPDF_Object::BOOLEAN, CPDF_Object::NUMBER,
         CPDF_Object::NUMBER,  CPDF_Object::STRING,  CPDF_Object::STRING,
         CPDF_Object::NAME,    CPDF_Object::ARRAY,   CPDF_Object::DICTIONARY,
         CPDF_Object::STREAM,  CPDF_Object::NULLOBJ};
     for (size_t i = 0; i < FX_ArraySize(objs); ++i)
       m_DirectObjs.emplace_back(objs[i]);
 
     // Indirect references to indirect objects.
-    m_ObjHolder.reset(new CPDF_IndirectObjectHolder());
-    m_IndirectObjs = {
-        boolean_true_obj->Clone().release(), number_int_obj->Clone().release(),
-        str_spec_obj->Clone().release(),     name_obj->Clone().release(),
-        m_ArrayObj->Clone().release(),       m_DictObj->Clone().release(),
-        stream_obj->Clone().release()};
-    for (size_t i = 0; i < m_IndirectObjs.size(); ++i) {
-      m_ObjHolder->AddIndirectObject(m_IndirectObjs[i]);
-      m_RefObjs.emplace_back(new CPDF_Reference(
-          m_ObjHolder.get(), m_IndirectObjs[i]->GetObjNum()));
+    m_ObjHolder = pdfium::MakeUnique<CPDF_IndirectObjectHolder>();
+    m_IndirectObjs = {m_ObjHolder->AddIndirectObject(boolean_true_obj->Clone()),
+                      m_ObjHolder->AddIndirectObject(number_int_obj->Clone()),
+                      m_ObjHolder->AddIndirectObject(str_spec_obj->Clone()),
+                      m_ObjHolder->AddIndirectObject(name_obj->Clone()),
+                      m_ObjHolder->AddIndirectObject(m_ArrayObj->Clone()),
+                      m_ObjHolder->AddIndirectObject(m_DictObj->Clone()),
+                      m_ObjHolder->AddIndirectObject(stream_obj->Clone())};
+    for (CPDF_Object* pObj : m_IndirectObjs) {
+      m_RefObjs.emplace_back(
+          new CPDF_Reference(m_ObjHolder.get(), pObj->GetObjNum()));
     }
   }
 
   bool Equal(const CPDF_Object* obj1, const CPDF_Object* obj2) {
     if (obj1 == obj2)
       return true;
     if (!obj1 || !obj2 || obj1->GetType() != obj2->GetType())
       return false;
     switch (obj1->GetType()) {
       case CPDF_Object::BOOLEAN:
@@ skipping 717 matching lines @@
     ASSERT_TRUE(cloned_stream);
     CPDF_Object* cloned_dict = cloned_stream->GetDict();
     ASSERT_TRUE(cloned_dict);
     ASSERT_TRUE(cloned_dict->IsDictionary());
     // Recursively referenced object is not cloned.
     EXPECT_EQ(nullptr, cloned_dict->AsDictionary()->GetObjectFor("stream"));
   }
   {
     CPDF_IndirectObjectHolder objects_holder;
     // Create an object with a reference loop.
-    CPDF_Dictionary* dict_obj = new CPDF_Dictionary();
-    CPDF_Array* arr_obj = new CPDF_Array;
-    objects_holder.AddIndirectObject(dict_obj);
-    EXPECT_EQ(1u, dict_obj->GetObjNum());
-    dict_obj->SetFor("arr", arr_obj);
+    CPDF_Dictionary* dict_obj = objects_holder.NewIndirect<CPDF_Dictionary>();
+    std::unique_ptr<CPDF_Array> arr_obj = pdfium::MakeUnique<CPDF_Array>();
     arr_obj->InsertAt(
         0, new CPDF_Reference(&objects_holder, dict_obj->GetObjNum()));
     CPDF_Object* elem0 = arr_obj->GetObjectAt(0);
+    dict_obj->SetFor("arr", arr_obj.release());
+    EXPECT_EQ(1u, dict_obj->GetObjNum());
     ASSERT_TRUE(elem0);
     ASSERT_TRUE(elem0->IsReference());
     EXPECT_EQ(1u, elem0->AsReference()->GetRefObjNum());
     EXPECT_EQ(dict_obj, elem0->AsReference()->GetDirect());
 
     // Clone this object to see whether stack overflow will be triggered.
     std::unique_ptr<CPDF_Dictionary> cloned_dict =
         ToDictionary(dict_obj->CloneDirectObject());
     // Cloned object should be the same as the original.
     ASSERT_TRUE(cloned_dict);
@@ skipping 13 matching lines @@
   dict->SetFor("clams", pObj);
   dict->ConvertToIndirectObjectFor("clams", &objects_holder);
   CPDF_Object* pRef = dict->GetObjectFor("clams");
   CPDF_Object* pNum = dict->GetDirectObjectFor("clams");
   EXPECT_TRUE(pRef->IsReference());
   EXPECT_TRUE(pNum->IsNumber());
   EXPECT_NE(pObj, pRef);
   EXPECT_EQ(pObj, pNum);
   EXPECT_EQ(42, dict->GetIntegerFor("clams"));
 }