Rename dictionary set and get methods

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_boolean.h"
 #include "core/fpdfapi/fpdf_parser/cpdf_null.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_name.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_number.h"
@@ skipping 49 matching lines @@
     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;
-    m_DictObj->SetAt("bool", new CPDF_Boolean(false));
-    m_DictObj->SetAt("num", new CPDF_Number(0.23f));
+    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;
-    m_StreamDictObj->SetAt("key1", new CPDF_String(L" test dict"));
-    m_StreamDictObj->SetAt("key2", new CPDF_Number(-1));
+    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};
     m_DirectObjTypes = {
         CPDF_Object::BOOLEAN, CPDF_Object::BOOLEAN, CPDF_Object::NUMBER,
@@ skipping 39 matching lines @@
         }
         return true;
       }
       case CPDF_Object::DICTIONARY: {
         const CPDF_Dictionary* dict1 = obj1->AsDictionary();
         const CPDF_Dictionary* dict2 = obj2->AsDictionary();
         if (dict1->GetCount() != dict2->GetCount())
           return false;
         for (CPDF_Dictionary::const_iterator it = dict1->begin();
              it != dict1->end(); ++it) {
-          if (!Equal(it->second, dict2->GetObjectBy(it->first)))
+          if (!Equal(it->second, dict2->GetObjectFor(it->first)))
             return false;
         }
         return true;
       }
       case CPDF_Object::NULLOBJ:
         return true;
       case CPDF_Object::STREAM: {
         const CPDF_Stream* stream1 = obj1->AsStream();
         const CPDF_Stream* stream2 = obj2->AsStream();
         if (!stream1->GetDict() && !stream2->GetDict())
@@ skipping 402 matching lines @@
     // Dictionary array.
     CPDF_Dictionary* vals[3];
     ScopedArray arr(new 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]->SetAt(key.c_str(), new CPDF_Number(value));
+        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;
       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]->SetAt(key.c_str(), new CPDF_Number(value));
+        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]);
     }
     for (size_t i = 0; i < 3; ++i) {
       TestArrayAccessors(arr.get(), i,     // Array and index.
@@ skipping 19 matching lines @@
     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;
-    dict_val->SetAt("key1", new CPDF_String("Linda", false));
-    dict_val->SetAt("key2", new CPDF_String("Zoe", false));
+    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->SetAt("key1", new CPDF_String("John", false));
-    stream_dict->SetAt("key2", new CPDF_String("King", false));
+    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);
     const char* const expected_str[] = {
         "true",          "false", "0",    "-1234", "2345", "0.05", "",
@@ skipping 117 matching lines @@
 
   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);
-  dict->SetAtReference("foo", &objects_holder, 1234);
+  dict->SetReferenceFor("foo", &objects_holder, 1234);
   ASSERT_EQ(1U, dict->GetCount());
-  CPDF_Object* obj = dict->GetObjectBy("foo");
+  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->GetObjectBy("foo");
+  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;
-    dict_obj->SetAt("arr", arr_obj.get());
+    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()->GetObjectBy("arr"));
+    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;
     CPDF_Array* arr_obj = new CPDF_Array;
     objects_holder.AddIndirectObject(dict_obj);
     EXPECT_EQ(1u, dict_obj->GetObjNum());
-    dict_obj->SetAt("arr", arr_obj);
+    dict_obj->SetFor("arr", arr_obj);
     arr_obj->InsertAt(0, dict_obj, &objects_holder);
     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->GetObjectBy("arr");
+    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));
   }
 }