Make CPDF_Array take unique_ptrs

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 41 matching lines @@
     // Number objects.
     CPDF_Number* number_int_obj = new CPDF_Number(1245);
     CPDF_Number* number_float_obj = new CPDF_Number(9.00345f);
     // String objects.
     CPDF_String* str_reg_obj = new CPDF_String(L"A simple test");
     CPDF_String* str_spec_obj = new CPDF_String(L"\t\n");
     // Name object.
     CPDF_Name* name_obj = new CPDF_Name("space");
     // Array object.
     m_ArrayObj = new CPDF_Array;
-    m_ArrayObj->InsertAt(0, new CPDF_Number(8902));
-    m_ArrayObj->InsertAt(1, new CPDF_Name("address"));
+    m_ArrayObj->InsertNewAt<CPDF_Number>(0, 8902);
+    m_ArrayObj->InsertNewAt<CPDF_Name>(1, "address");
     // Dictionary object.
     m_DictObj = new CPDF_Dictionary();
     m_DictObj->SetFor("bool", new CPDF_Boolean(false));
     m_DictObj->SetFor("num", new CPDF_Number(0.23f));
     // Stream object.
     const char content[] = "abcdefghijklmnopqrstuvwxyz";
     size_t buf_len = FX_ArraySize(content);
     uint8_t* buf = reinterpret_cast<uint8_t*>(malloc(buf_len));
     memcpy(buf, content, buf_len);
     m_StreamDictObj = new CPDF_Dictionary();
@@ skipping 307 matching lines @@
     EXPECT_EQ(m_RefObjs[i].get(), m_RefObjs[i]->AsReference());
   }
 }
 
 TEST(PDFArrayTest, GetMatrix) {
   float elems[][6] = {{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f},
                       {1, 2, 3, 4, 5, 6},
                       {2.3f, 4.05f, 3, -2, -3, 0.0f},
                       {0.05f, 0.1f, 0.56f, 0.67f, 1.34f, 99.9f}};
   for (size_t i = 0; i < FX_ArraySize(elems); ++i) {
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
     CFX_Matrix matrix(elems[i][0], elems[i][1], elems[i][2], elems[i][3],
                       elems[i][4], elems[i][5]);
     for (size_t j = 0; j < 6; ++j)
-      arr->AddNumber(elems[i][j]);
+      arr->AddNew<CPDF_Number>(elems[i][j]);
     CFX_Matrix arr_matrix = arr->GetMatrix();
     EXPECT_EQ(matrix.GetA(), arr_matrix.GetA());
     EXPECT_EQ(matrix.GetB(), arr_matrix.GetB());
     EXPECT_EQ(matrix.GetC(), arr_matrix.GetC());
     EXPECT_EQ(matrix.GetD(), arr_matrix.GetD());
     EXPECT_EQ(matrix.GetE(), arr_matrix.GetE());
     EXPECT_EQ(matrix.GetF(), arr_matrix.GetF());
   }
 }
 
 TEST(PDFArrayTest, GetRect) {
   float elems[][4] = {{0.0f, 0.0f, 0.0f, 0.0f},
                       {1, 2, 5, 6},
                       {2.3f, 4.05f, -3, 0.0f},
                       {0.05f, 0.1f, 1.34f, 99.9f}};
   for (size_t i = 0; i < FX_ArraySize(elems); ++i) {
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
     CFX_FloatRect rect(elems[i]);
     for (size_t j = 0; j < 4; ++j)
-      arr->AddNumber(elems[i][j]);
+      arr->AddNew<CPDF_Number>(elems[i][j]);
     CFX_FloatRect arr_rect = arr->GetRect();
     EXPECT_EQ(rect.left, arr_rect.left);
     EXPECT_EQ(rect.right, arr_rect.right);
     EXPECT_EQ(rect.bottom, arr_rect.bottom);
     EXPECT_EQ(rect.top, arr_rect.top);
   }
 }
 
 TEST(PDFArrayTest, GetTypeAt) {
   {
     // Boolean array.
     const bool vals[] = {true, false, false, true, true};
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
     for (size_t i = 0; i < FX_ArraySize(vals); ++i)
-      arr->InsertAt(i, new CPDF_Boolean(vals[i]));
+      arr->InsertNewAt<CPDF_Boolean>(i, vals[i]);
     for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
       TestArrayAccessors(arr.get(), i,                // Array and index.
                          vals[i] ? "true" : "false",  // String value.
                          nullptr,                     // Const string value.
                          vals[i] ? 1 : 0,             // Integer value.
                          0,                           // Float value.
                          nullptr,                     // Array value.
                          nullptr,                     // Dictionary value.
                          nullptr);                    // Stream value.
     }
   }
   {
     // Integer array.
     const int vals[] = {10, 0, -345, 2089345456, -1000000000, 567, 93658767};
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
     for (size_t i = 0; i < FX_ArraySize(vals); ++i)
-      arr->InsertAt(i, new CPDF_Number(vals[i]));
+      arr->InsertNewAt<CPDF_Number>(i, vals[i]);
     for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
       char buf[33];
       TestArrayAccessors(arr.get(), i,                  // Array and index.
                          FXSYS_itoa(vals[i], buf, 10),  // String value.
                          nullptr,                       // Const string value.
                          vals[i],                       // Integer value.
                          vals[i],                       // Float value.
                          nullptr,                       // Array value.
                          nullptr,                       // Dictionary value.
                          nullptr);                      // Stream value.
     }
   }
   {
     // Float array.
     const float vals[] = {0.0f,    0,     10,    10.0f,   0.0345f,
                           897.34f, -2.5f, -1.0f, -345.0f, -0.0f};
     const char* const expected_str[] = {
         "0", "0", "10", "10", "0.0345", "897.34", "-2.5", "-1", "-345", "0"};
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
-    for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
-      arr->InsertAt(i, new CPDF_Number(vals[i]));
-    }
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
+    for (size_t i = 0; i < FX_ArraySize(vals); ++i)
+      arr->InsertNewAt<CPDF_Number>(i, vals[i]);
     for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
       TestArrayAccessors(arr.get(), i,     // Array and index.
                          expected_str[i],  // String value.
                          nullptr,          // Const string value.
                          vals[i],          // Integer value.
                          vals[i],          // Float value.
                          nullptr,          // Array value.
                          nullptr,          // Dictionary value.
                          nullptr);         // Stream value.
     }
   }
   {
     // String and name array
     const char* const vals[] = {"this", "adsde$%^", "\r\t",           "\"012",
                                 ".",    "EYREW",    "It is a joke :)"};
     std::unique_ptr<CPDF_Array> string_array(new CPDF_Array);
     std::unique_ptr<CPDF_Array> name_array(new CPDF_Array);
     for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
-      string_array->InsertAt(i, new CPDF_String(vals[i], false));
-      name_array->InsertAt(i, new CPDF_Name(vals[i]));
+      string_array->InsertNewAt<CPDF_String>(i, vals[i], false);
+      name_array->InsertNewAt<CPDF_Name>(i, vals[i]);
     }
     for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
       TestArrayAccessors(string_array.get(), i,  // Array and index.
                          vals[i],                // String value.
                          vals[i],                // Const string value.
                          0,                      // Integer value.
                          0,                      // Float value.
                          nullptr,                // Array value.
                          nullptr,                // Dictionary value.
                          nullptr);               // Stream value.
       TestArrayAccessors(name_array.get(), i,    // Array and index.
                          vals[i],                // String value.
                          vals[i],                // Const string value.
                          0,                      // Integer value.
                          0,                      // Float value.
                          nullptr,                // Array value.
                          nullptr,                // Dictionary value.
                          nullptr);               // Stream value.
     }
   }
   {
     // Null element array.
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
     for (size_t i = 0; i < 3; ++i)
-      arr->InsertAt(i, new CPDF_Null);
+      arr->InsertNewAt<CPDF_Null>(i);
     for (size_t i = 0; i < 3; ++i) {
       TestArrayAccessors(arr.get(), i,  // Array and index.
                          "",            // String value.
                          nullptr,       // Const string value.
                          0,             // Integer value.
                          0,             // Float value.
                          nullptr,       // Array value.
                          nullptr,       // Dictionary value.
                          nullptr);      // Stream value.
     }
   }
   {
     // Array of array.
     CPDF_Array* vals[3];
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
     for (size_t i = 0; i < 3; ++i) {
-      vals[i] = new CPDF_Array;
+      vals[i] = arr->AddNew<CPDF_Array>();
       for (size_t j = 0; j < 3; ++j) {
         int value = j + 100;
-        vals[i]->InsertAt(i, new CPDF_Number(value));
+        vals[i]->InsertNewAt<CPDF_Number>(i, value);
       }
-      arr->InsertAt(i, vals[i]);
     }
     for (size_t i = 0; i < 3; ++i) {
       TestArrayAccessors(arr.get(), i,  // Array and index.
                          "",            // String value.
                          nullptr,       // Const string value.
                          0,             // Integer value.
                          0,             // Float value.
                          vals[i],       // Array value.
                          nullptr,       // Dictionary value.
                          nullptr);      // Stream value.
     }
   }
   {
     // Dictionary array.
     CPDF_Dictionary* vals[3];
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
     for (size_t i = 0; i < 3; ++i) {
-      vals[i] = new CPDF_Dictionary();
+      vals[i] = arr->AddNew<CPDF_Dictionary>();
       for (size_t j = 0; j < 3; ++j) {
         std::string key("key");
         char buf[33];
         key.append(FXSYS_itoa(j, buf, 10));
         int value = j + 200;
         vals[i]->SetFor(key.c_str(), new CPDF_Number(value));
       }
-      arr->InsertAt(i, vals[i]);
     }
     for (size_t i = 0; i < 3; ++i) {
       TestArrayAccessors(arr.get(), i,  // Array and index.
                          "",            // String value.
                          nullptr,       // Const string value.
                          0,             // Integer value.
                          0,             // Float value.
                          nullptr,       // Array value.
                          vals[i],       // Dictionary value.
                          nullptr);      // Stream value.
     }
   }
   {
     // Stream array.
     CPDF_Dictionary* vals[3];
     CPDF_Stream* stream_vals[3];
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
     for (size_t i = 0; i < 3; ++i) {
       vals[i] = new CPDF_Dictionary();
       for (size_t j = 0; j < 3; ++j) {
         std::string key("key");
         char buf[33];
         key.append(FXSYS_itoa(j, buf, 10));
         int value = j + 200;
         vals[i]->SetFor(key.c_str(), new CPDF_Number(value));
       }
       uint8_t content[] = "content: this is a stream";
       size_t data_size = FX_ArraySize(content);
       uint8_t* data = reinterpret_cast<uint8_t*>(malloc(data_size));
       memcpy(data, content, data_size);
-      stream_vals[i] = new CPDF_Stream(data, data_size, vals[i]);
-      arr->InsertAt(i, stream_vals[i]);
+      stream_vals[i] = arr->AddNew<CPDF_Stream>(data, data_size, vals[i]);
     }
     for (size_t i = 0; i < 3; ++i) {
       TestArrayAccessors(arr.get(), i,     // Array and index.
                          "",               // String value.
                          nullptr,          // Const string value.
                          0,                // Integer value.
                          0,                // Float value.
                          nullptr,          // Array value.
                          vals[i],          // Dictionary value.
                          stream_vals[i]);  // Stream value.
     }
   }
   {
     // Mixed array.
-    std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
-    // Array arr will take ownership of all the objects inserted.
-    arr->InsertAt(0, new CPDF_Boolean(true));
-    arr->InsertAt(1, new CPDF_Boolean(false));
-    arr->InsertAt(2, new CPDF_Number(0));
-    arr->InsertAt(3, new CPDF_Number(-1234));
-    arr->InsertAt(4, new CPDF_Number(2345.0f));
-    arr->InsertAt(5, new CPDF_Number(0.05f));
-    arr->InsertAt(6, new CPDF_String("", false));
-    arr->InsertAt(7, new CPDF_String("It is a test!", false));
-    arr->InsertAt(8, new CPDF_Name("NAME"));
-    arr->InsertAt(9, new CPDF_Name("test"));
-    arr->InsertAt(10, new CPDF_Null());
-    CPDF_Array* arr_val = new CPDF_Array;
-    arr_val->AddNumber(1);
-    arr_val->AddNumber(2);
-    arr->InsertAt(11, arr_val);
-    CPDF_Dictionary* dict_val = new CPDF_Dictionary();
+    auto arr = pdfium::MakeUnique<CPDF_Array>();
+    arr->InsertNewAt<CPDF_Boolean>(0, true);
+    arr->InsertNewAt<CPDF_Boolean>(1, false);
+    arr->InsertNewAt<CPDF_Number>(2, 0);
+    arr->InsertNewAt<CPDF_Number>(3, -1234);
+    arr->InsertNewAt<CPDF_Number>(4, 2345.0f);
+    arr->InsertNewAt<CPDF_Number>(5, 0.05f);
+    arr->InsertNewAt<CPDF_String>(6, "", false);
+    arr->InsertNewAt<CPDF_String>(7, "It is a test!", false);
+    arr->InsertNewAt<CPDF_Name>(8, "NAME");
+    arr->InsertNewAt<CPDF_Name>(9, "test");
+    arr->InsertNewAt<CPDF_Null>(10);
+
+    CPDF_Array* arr_val = arr->InsertNewAt<CPDF_Array>(11);
+    arr_val->AddNew<CPDF_Number>(1);
+    arr_val->AddNew<CPDF_Number>(2);
+
+    CPDF_Dictionary* dict_val = arr->InsertNewAt<CPDF_Dictionary>(12);
     dict_val->SetFor("key1", new CPDF_String("Linda", false));
     dict_val->SetFor("key2", new CPDF_String("Zoe", false));
-    arr->InsertAt(12, dict_val);
+
     CPDF_Dictionary* stream_dict = new CPDF_Dictionary();
     stream_dict->SetFor("key1", new CPDF_String("John", false));
     stream_dict->SetFor("key2", new CPDF_String("King", false));
     uint8_t data[] = "A stream for test";
     // The data buffer will be owned by stream object, so it needs to be
     // dynamically allocated.
     size_t buf_size = sizeof(data);
     uint8_t* buf = reinterpret_cast<uint8_t*>(malloc(buf_size));
     memcpy(buf, data, buf_size);
-    CPDF_Stream* stream_val = new CPDF_Stream(buf, buf_size, stream_dict);
-    arr->InsertAt(13, stream_val);
+    CPDF_Stream* stream_val =
+        arr->InsertNewAt<CPDF_Stream>(13, buf, buf_size, stream_dict);
     const char* const expected_str[] = {
         "true",          "false", "0",    "-1234", "2345", "0.05", "",
         "It is a test!", "NAME",  "test", "",      "",     "",     ""};
     const int expected_int[] = {1, 0, 0, -1234, 2345, 0, 0,
                                 0, 0, 0, 0,     0,    0, 0};
     const float expected_float[] = {0, 0, 0, -1234, 2345, 0.05f, 0,
                                     0, 0, 0, 0,     0,    0,     0};
     for (size_t i = 0; i < arr->GetCount(); ++i) {
       EXPECT_STREQ(expected_str[i], arr->GetStringAt(i).c_str());
       EXPECT_EQ(expected_int[i], arr->GetIntegerAt(i));
@@ skipping 13 matching lines @@
         else
           EXPECT_EQ(nullptr, arr->GetDictAt(i));
       }
     }
   }
 }
 
 TEST(PDFArrayTest, AddNumber) {
   float vals[] = {1.0f,         -1.0f, 0,    0.456734f,
                   12345.54321f, 0.5f,  1000, 0.000045f};
-  std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+  auto arr = pdfium::MakeUnique<CPDF_Array>();
   for (size_t i = 0; i < FX_ArraySize(vals); ++i)
-    arr->AddNumber(vals[i]);
+    arr->AddNew<CPDF_Number>(vals[i]);
   for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
     EXPECT_EQ(CPDF_Object::NUMBER, arr->GetObjectAt(i)->GetType());
     EXPECT_EQ(vals[i], arr->GetObjectAt(i)->GetNumber());
   }
 }
 
 TEST(PDFArrayTest, AddInteger) {
   int vals[] = {0, 1, 934435456, 876, 10000, -1, -24354656, -100};
-  std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+  auto arr = pdfium::MakeUnique<CPDF_Array>();
   for (size_t i = 0; i < FX_ArraySize(vals); ++i)
-    arr->AddInteger(vals[i]);
+    arr->AddNew<CPDF_Number>(vals[i]);
   for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
     EXPECT_EQ(CPDF_Object::NUMBER, arr->GetObjectAt(i)->GetType());
     EXPECT_EQ(vals[i], arr->GetObjectAt(i)->GetNumber());
   }
 }
 
 TEST(PDFArrayTest, AddStringAndName) {
   const char* vals[] = {"",        "a", "ehjhRIOYTTFdfcdnv",  "122323",
                         "$#%^&**", " ", "This is a test.\r\n"};
   std::unique_ptr<CPDF_Array> string_array(new CPDF_Array);
   std::unique_ptr<CPDF_Array> name_array(new CPDF_Array);
   for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
-    string_array->AddString(vals[i]);
-    name_array->AddName(vals[i]);
+    string_array->AddNew<CPDF_String>(vals[i], false);
+    name_array->AddNew<CPDF_Name>(vals[i]);
   }
   for (size_t i = 0; i < FX_ArraySize(vals); ++i) {
     EXPECT_EQ(CPDF_Object::STRING, string_array->GetObjectAt(i)->GetType());
     EXPECT_STREQ(vals[i], string_array->GetObjectAt(i)->GetString().c_str());
     EXPECT_EQ(CPDF_Object::NAME, name_array->GetObjectAt(i)->GetType());
     EXPECT_STREQ(vals[i], name_array->GetObjectAt(i)->GetString().c_str());
   }
 }
 
 TEST(PDFArrayTest, AddReferenceAndGetObjectAt) {
   std::unique_ptr<CPDF_IndirectObjectHolder> holder(
       new CPDF_IndirectObjectHolder());
   CPDF_Boolean* boolean_obj = new CPDF_Boolean(true);
   CPDF_Number* int_obj = new CPDF_Number(-1234);
   CPDF_Number* float_obj = new CPDF_Number(2345.089f);
   CPDF_String* str_obj = new CPDF_String("Adsfdsf 343434 %&&*\n", false);
   CPDF_Name* name_obj = new CPDF_Name("Title:");
   CPDF_Null* null_obj = new CPDF_Null();
   CPDF_Object* indirect_objs[] = {boolean_obj, int_obj,  float_obj,
                                   str_obj,     name_obj, null_obj};
   unsigned int obj_nums[] = {2, 4, 7, 2345, 799887, 1};
-  std::unique_ptr<CPDF_Array> arr(new CPDF_Array);
+  auto arr = pdfium::MakeUnique<CPDF_Array>();
   std::unique_ptr<CPDF_Array> arr1(new CPDF_Array);
   // Create two arrays of references by different AddReference() APIs.
   for (size_t i = 0; i < FX_ArraySize(indirect_objs); ++i) {
     holder->ReplaceIndirectObjectIfHigherGeneration(
         obj_nums[i], pdfium::WrapUnique<CPDF_Object>(indirect_objs[i]));
-    arr->AddReference(holder.get(), obj_nums[i]);
-    arr1->AddReference(holder.get(), indirect_objs[i]->GetObjNum());
+    arr->AddNew<CPDF_Reference>(holder.get(), obj_nums[i]);
+    arr1->AddNew<CPDF_Reference>(holder.get(), indirect_objs[i]->GetObjNum());
   }
   // Check indirect objects.
   for (size_t i = 0; i < FX_ArraySize(obj_nums); ++i)
     EXPECT_EQ(indirect_objs[i], holder->GetOrParseIndirectObject(obj_nums[i]));
   // Check arrays.
   EXPECT_EQ(arr->GetCount(), arr1->GetCount());
   for (size_t i = 0; i < arr->GetCount(); ++i) {
     EXPECT_EQ(CPDF_Object::REFERENCE, arr->GetObjectAt(i)->GetType());
     EXPECT_EQ(indirect_objs[i], arr->GetObjectAt(i)->GetDirect());
     EXPECT_EQ(indirect_objs[i], arr->GetDirectObjectAt(i));
     EXPECT_EQ(CPDF_Object::REFERENCE, arr1->GetObjectAt(i)->GetType());
     EXPECT_EQ(indirect_objs[i], arr1->GetObjectAt(i)->GetDirect());
     EXPECT_EQ(indirect_objs[i], arr1->GetDirectObjectAt(i));
   }
 }
 
 TEST(PDFArrayTest, CloneDirectObject) {
   CPDF_IndirectObjectHolder objects_holder;
   std::unique_ptr<CPDF_Array> array(new CPDF_Array);
-  array->AddReference(&objects_holder, 1234);
+  array->AddNew<CPDF_Reference>(&objects_holder, 1234);
   ASSERT_EQ(1U, array->GetCount());
   CPDF_Object* obj = array->GetObjectAt(0);
   ASSERT_TRUE(obj);
   EXPECT_TRUE(obj->IsReference());
 
   std::unique_ptr<CPDF_Object> cloned_array_object = array->CloneDirectObject();
   ASSERT_TRUE(cloned_array_object);
   ASSERT_TRUE(cloned_array_object->IsArray());
 
   std::unique_ptr<CPDF_Array> cloned_array =
       ToArray(std::move(cloned_array_object));
   ASSERT_EQ(1U, cloned_array->GetCount());
   CPDF_Object* cloned_obj = cloned_array->GetObjectAt(0);
   EXPECT_FALSE(cloned_obj);
 }
 
 TEST(PDFArrayTest, ConvertIndirect) {
   CPDF_IndirectObjectHolder objects_holder;
-  std::unique_ptr<CPDF_Array> array(new CPDF_Array);
-  CPDF_Object* pObj = new CPDF_Number(42);
-  array->Add(pObj);
+  auto array = pdfium::MakeUnique<CPDF_Array>();
+  CPDF_Object* pObj = array->AddNew<CPDF_Number>(42);
   array->ConvertToIndirectObjectAt(0, &objects_holder);
   CPDF_Object* pRef = array->GetObjectAt(0);
   CPDF_Object* pNum = array->GetDirectObjectAt(0);
   EXPECT_TRUE(pRef->IsReference());
   EXPECT_TRUE(pNum->IsNumber());
   EXPECT_NE(pObj, pRef);
   EXPECT_EQ(pObj, pNum);
   EXPECT_EQ(42, array->GetIntegerAt(0));
 }
 
@@ skipping 13 matching lines @@
   std::unique_ptr<CPDF_Dictionary> cloned_dict =
       ToDictionary(std::move(cloned_dict_object));
   ASSERT_EQ(1U, cloned_dict->GetCount());
   CPDF_Object* cloned_obj = cloned_dict->GetObjectFor("foo");
   EXPECT_FALSE(cloned_obj);
 }
 
 TEST(PDFObjectTest, CloneCheckLoop) {
   {
     // Create a dictionary/array pair with a reference loop.
-    CPDF_Dictionary* dict_obj = new CPDF_Dictionary();
-    std::unique_ptr<CPDF_Array> arr_obj(new CPDF_Array);
+    auto arr_obj = pdfium::MakeUnique<CPDF_Array>();
+    CPDF_Dictionary* dict_obj = arr_obj->InsertNewAt<CPDF_Dictionary>(0);
     dict_obj->SetFor("arr", arr_obj.get());
-    arr_obj->InsertAt(0, dict_obj);
-
     // Clone this object to see whether stack overflow will be triggered.
     std::unique_ptr<CPDF_Array> cloned_array = ToArray(arr_obj->Clone());
     // Cloned object should be the same as the original.
     ASSERT_TRUE(cloned_array);
     EXPECT_EQ(1u, cloned_array->GetCount());
     CPDF_Object* cloned_dict = cloned_array->GetObjectAt(0);
     ASSERT_TRUE(cloned_dict);
     ASSERT_TRUE(cloned_dict->IsDictionary());
     // Recursively referenced object is not cloned.
     EXPECT_EQ(nullptr, cloned_dict->AsDictionary()->GetObjectFor("arr"));
@@ skipping 13 matching lines @@
     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 = 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()));
+    arr_obj->InsertNewAt<CPDF_Reference>(0, &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 =
@@ skipping 16 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"));
 }