Fix build of pdf_hint_table_fuzzer.

core/fpdfapi/fpdf_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/fpdf_parser/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/cpdf_boolean.h"
 #include "core/fpdfapi/fpdf_parser/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/cpdf_name.h"
 #include "core/fpdfapi/fpdf_parser/cpdf_null.h"
 #include "core/fpdfapi/fpdf_parser/cpdf_number.h"
@@ skipping 48 matching lines @@
     // 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"));
     // Dictionary object.
-    m_DictObj = new CPDF_Dictionary(CFX_WeakPtr<CFX_ByteStringPool>());
+    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(CFX_WeakPtr<CFX_ByteStringPool>());
+    m_StreamDictObj = new CPDF_Dictionary();
     m_StreamDictObj->SetFor("key1", new CPDF_String(L" test dict"));
     m_StreamDictObj->SetFor("key2", new CPDF_Number(-1));
     CPDF_Stream* stream_obj = new CPDF_Stream(buf, buf_len, m_StreamDictObj);
     // Null Object.
     CPDF_Null* null_obj = new CPDF_Null;
     // All direct objects.
     CPDF_Object* objs[] = {boolean_false_obj, boolean_true_obj, number_int_obj,
                            number_float_obj,  str_reg_obj,      str_spec_obj,
                            name_obj,          m_ArrayObj,       m_DictObj,
                            stream_obj,        null_obj};
@@ skipping 458 matching lines @@
                          vals[i],       // Array value.
                          nullptr,       // Dictionary value.
                          nullptr);      // Stream value.
     }
   }
   {
     // Dictionary array.
     CPDF_Dictionary* vals[3];
     ScopedArray arr(new CPDF_Array);
     for (size_t i = 0; i < 3; ++i) {
-      vals[i] = new CPDF_Dictionary(CFX_WeakPtr<CFX_ByteStringPool>());
+      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));
       }
       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];
     ScopedArray arr(new CPDF_Array);
     for (size_t i = 0; i < 3; ++i) {
-      vals[i] = new CPDF_Dictionary(CFX_WeakPtr<CFX_ByteStringPool>());
+      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));
@@ skipping 24 matching lines @@
     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(CFX_WeakPtr<CFX_ByteStringPool>());
+    CPDF_Dictionary* dict_val = new CPDF_Dictionary();
     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(CFX_WeakPtr<CFX_ByteStringPool>());
+    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);
@@ skipping 118 matching lines @@
   ASSERT_TRUE(cloned_array_object->IsArray());
 
   ScopedArray cloned_array(cloned_array_object->AsArray());
   ASSERT_EQ(1U, cloned_array->GetCount());
   CPDF_Object* cloned_obj = cloned_array->GetObjectAt(0);
   EXPECT_FALSE(cloned_obj);
 }
 
 TEST(PDFDictionaryTest, CloneDirectObject) {
   CPDF_IndirectObjectHolder objects_holder;
-  ScopedDict dict(new CPDF_Dictionary(CFX_WeakPtr<CFX_ByteStringPool>()));
+  ScopedDict dict(new CPDF_Dictionary());
   dict->SetReferenceFor("foo", &objects_holder, 1234);
   ASSERT_EQ(1U, dict->GetCount());
   CPDF_Object* obj = dict->GetObjectFor("foo");
   ASSERT_TRUE(obj);
   EXPECT_TRUE(obj->IsReference());
 
   CPDF_Object* cloned_dict_object = dict->CloneDirectObject();
   ASSERT_TRUE(cloned_dict_object);
   ASSERT_TRUE(cloned_dict_object->IsDictionary());
 
   ScopedDict cloned_dict(cloned_dict_object->AsDictionary());
   ASSERT_EQ(1U, cloned_dict->GetCount());
   CPDF_Object* cloned_obj = cloned_dict->GetObjectFor("foo");
   EXPECT_FALSE(cloned_obj);
 }
 
 TEST(PDFObjectTest, CloneCheckLoop) {
   {
     // Create an object with a reference loop.
     ScopedArray arr_obj(new CPDF_Array);
     // Dictionary object.
-    CPDF_Dictionary* dict_obj =
-        new CPDF_Dictionary(CFX_WeakPtr<CFX_ByteStringPool>());
+    CPDF_Dictionary* dict_obj = new CPDF_Dictionary();
     dict_obj->SetFor("arr", arr_obj.get());
     arr_obj->InsertAt(0, dict_obj);
 
     // Clone this object to see whether stack overflow will be triggered.
     ScopedArray cloned_array(arr_obj->Clone()->AsArray());
     // 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"));
   }
   {
     CPDF_IndirectObjectHolder objects_holder;
     // Create an object with a reference loop.
-    CPDF_Dictionary* dict_obj =
-        new CPDF_Dictionary(CFX_WeakPtr<CFX_ByteStringPool>());
+    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);
     arr_obj->InsertAt(
         0, new CPDF_Reference(&objects_holder, dict_obj->GetObjNum()));
     CPDF_Object* elem0 = arr_obj->GetObjectAt(0);
     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.
     ScopedDict cloned_dict(ToDictionary(dict_obj->CloneDirectObject()));
     // Cloned object should be the same as the original.
     ASSERT_TRUE(cloned_dict);
     CPDF_Object* cloned_arr = cloned_dict->GetObjectFor("arr");
     ASSERT_TRUE(cloned_arr);
     ASSERT_TRUE(cloned_arr->IsArray());
     EXPECT_EQ(1u, cloned_arr->AsArray()->GetCount());
     // Recursively referenced object is not cloned.
     EXPECT_EQ(nullptr, cloned_arr->AsArray()->GetObjectAt(0));
   }
 }