Rename dictionary set and get methods

core/fpdfdoc/cpdf_interform.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.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include <vector>
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_font/include/cpdf_fontencoding.h"
@@ skipping 18 matching lines @@
   uint16_t m_codePage;
 } g_fieldEncoding[] = {
     {"BigFive", 950},
     {"GBK", 936},
     {"Shift-JIS", 932},
     {"UHC", 949},
 };
 
 CFX_WideString GetFieldValue(const CPDF_Dictionary& pFieldDict,
                              const CFX_ByteString& bsEncoding) {
-  const CFX_ByteString csBValue = pFieldDict.GetStringBy("V");
+  const CFX_ByteString csBValue = pFieldDict.GetStringFor("V");
   for (const auto& encoding : g_fieldEncoding) {
     if (bsEncoding == encoding.m_name)
       return CFX_WideString::FromCodePage(csBValue.AsStringC(),
                                           encoding.m_codePage);
   }
   CFX_ByteString csTemp = csBValue.Left(2);
   if (csTemp == "\xFF\xFE" || csTemp == "\xFE\xFF")
     return PDF_DecodeText(csBValue);
   return CFX_WideString::FromLocal(csBValue.AsStringC());
 }
 
 void AddFont(CPDF_Dictionary*& pFormDict,
              CPDF_Document* pDocument,
              const CPDF_Font* pFont,
              CFX_ByteString& csNameTag);
 
 void InitDict(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument) {
   if (!pDocument)
     return;
 
   if (!pFormDict) {
     pFormDict = new CPDF_Dictionary;
     uint32_t dwObjNum = pDocument->AddIndirectObject(pFormDict);
     CPDF_Dictionary* pRoot = pDocument->GetRoot();
-    pRoot->SetAtReference("AcroForm", pDocument, dwObjNum);
+    pRoot->SetReferenceFor("AcroForm", pDocument, dwObjNum);
   }
 
   CFX_ByteString csDA;
   if (!pFormDict->KeyExist("DR")) {
     CFX_ByteString csBaseName;
     CFX_ByteString csDefault;
     uint8_t charSet = CPDF_InterForm::GetNativeCharSet();
     CPDF_Font* pFont = CPDF_InterForm::AddStandardFont(pDocument, "Helvetica");
     if (pFont) {
       AddFont(pFormDict, pDocument, pFont, csBaseName);
@@ skipping 12 matching lines @@
       }
     }
     if (pFont)
       csDA = "/" + PDF_NameEncode(csDefault) + " 0 Tf";
   }
   if (!csDA.IsEmpty())
     csDA += " ";
 
   csDA += "0 g";
   if (!pFormDict->KeyExist("DA"))
-    pFormDict->SetAtString("DA", csDA);
+    pFormDict->SetStringFor("DA", csDA);
 }
 
 uint32_t CountFonts(CPDF_Dictionary* pFormDict) {
   if (!pFormDict)
     return 0;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
     return 0;
 
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
     return 0;
 
   uint32_t dwCount = 0;
   for (const auto& it : *pFonts) {
     CPDF_Object* pObj = it.second;
     if (!pObj)
       continue;
 
     if (CPDF_Dictionary* pDirect = ToDictionary(pObj->GetDirect())) {
-      if (pDirect->GetStringBy("Type") == "Font")
+      if (pDirect->GetStringFor("Type") == "Font")
         dwCount++;
     }
   }
   return dwCount;
 }
 
 CPDF_Font* GetFont(CPDF_Dictionary* pFormDict,
                    CPDF_Document* pDocument,
                    uint32_t index,
                    CFX_ByteString& csNameTag) {
   if (!pFormDict)
     return nullptr;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
     return nullptr;
 
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
     return nullptr;
 
   uint32_t dwCount = 0;
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj)
       continue;
 
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
-    if (pElement->GetStringBy("Type") != "Font")
+    if (pElement->GetStringFor("Type") != "Font")
       continue;
     if (dwCount == index) {
       csNameTag = csKey;
       return pDocument->LoadFont(pElement);
     }
     dwCount++;
   }
   return nullptr;
 }
 
 CPDF_Font* GetFont(CPDF_Dictionary* pFormDict,
                    CPDF_Document* pDocument,
                    CFX_ByteString csNameTag) {
   CFX_ByteString csAlias = PDF_NameDecode(csNameTag);
   if (!pFormDict || csAlias.IsEmpty())
     return nullptr;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
     return nullptr;
 
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
     return nullptr;
 
-  CPDF_Dictionary* pElement = pFonts->GetDictBy(csAlias);
+  CPDF_Dictionary* pElement = pFonts->GetDictFor(csAlias);
   if (!pElement)
     return nullptr;
 
-  if (pElement->GetStringBy("Type") == "Font")
+  if (pElement->GetStringFor("Type") == "Font")
     return pDocument->LoadFont(pElement);
   return nullptr;
 }
 
 CPDF_Font* GetFont(CPDF_Dictionary* pFormDict,
                    CPDF_Document* pDocument,
                    CFX_ByteString csFontName,
                    CFX_ByteString& csNameTag) {
   if (!pFormDict || csFontName.IsEmpty())
     return nullptr;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
     return nullptr;
 
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
     return nullptr;
 
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj)
       continue;
 
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
-    if (pElement->GetStringBy("Type") != "Font")
+    if (pElement->GetStringFor("Type") != "Font")
       continue;
 
     CPDF_Font* pFind = pDocument->LoadFont(pElement);
     if (!pFind)
       continue;
 
     CFX_ByteString csBaseFont;
     csBaseFont = pFind->GetBaseFont();
     csBaseFont.Remove(' ');
     if (csBaseFont == csFontName) {
       csNameTag = csKey;
       return pFind;
     }
   }
   return nullptr;
 }
 
 CPDF_Font* GetNativeFont(CPDF_Dictionary* pFormDict,
                          CPDF_Document* pDocument,
                          uint8_t charSet,
                          CFX_ByteString& csNameTag) {
   if (!pFormDict)
     return nullptr;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
     return nullptr;
 
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
     return nullptr;
 
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj)
       continue;
 
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
-    if (pElement->GetStringBy("Type") != "Font")
+    if (pElement->GetStringFor("Type") != "Font")
       continue;
     CPDF_Font* pFind = pDocument->LoadFont(pElement);
     if (!pFind)
       continue;
 
     CFX_SubstFont* pSubst = pFind->GetSubstFont();
     if (!pSubst)
       continue;
 
     if (pSubst->m_Charset == (int)charSet) {
       csNameTag = csKey;
       return pFind;
     }
   }
   return nullptr;
 }
 
 CPDF_Font* GetDefaultFont(CPDF_Dictionary* pFormDict,
                           CPDF_Document* pDocument) {
   if (!pFormDict)
     return nullptr;
 
-  CPDF_DefaultAppearance cDA(pFormDict->GetStringBy("DA"));
+  CPDF_DefaultAppearance cDA(pFormDict->GetStringFor("DA"));
   CFX_ByteString csFontNameTag;
   FX_FLOAT fFontSize;
   cDA.GetFont(csFontNameTag, fFontSize);
   return GetFont(pFormDict, pDocument, csFontNameTag);
 }
 
 FX_BOOL FindFont(CPDF_Dictionary* pFormDict,
                  const CPDF_Font* pFont,
                  CFX_ByteString& csNameTag) {
   if (!pFormDict || !pFont)
     return FALSE;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
     return FALSE;
 
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
     return FALSE;
 
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj)
       continue;
 
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
-    if (pElement->GetStringBy("Type") != "Font")
+    if (pElement->GetStringFor("Type") != "Font")
       continue;
     if (pFont->GetFontDict() == pElement) {
       csNameTag = csKey;
       return TRUE;
     }
   }
   return FALSE;
 }
 
 CPDF_Font* GetNativeFont(CPDF_Dictionary* pFormDict,
@@ skipping 13 matching lines @@
 }
 
 FX_BOOL FindFont(CPDF_Dictionary* pFormDict,
                  CPDF_Document* pDocument,
                  CFX_ByteString csFontName,
                  CPDF_Font*& pFont,
                  CFX_ByteString& csNameTag) {
   if (!pFormDict)
     return FALSE;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
     return FALSE;
 
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
     return FALSE;
   if (csFontName.GetLength() > 0)
     csFontName.Remove(' ');
 
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj)
       continue;
 
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
-    if (pElement->GetStringBy("Type") != "Font")
+    if (pElement->GetStringFor("Type") != "Font")
       continue;
 
     pFont = pDocument->LoadFont(pElement);
     if (!pFont)
       continue;
 
     CFX_ByteString csBaseFont;
     csBaseFont = pFont->GetBaseFont();
     csBaseFont.Remove(' ');
     if (csBaseFont == csFontName) {
@@ skipping 14 matching lines @@
     InitDict(pFormDict, pDocument);
 
   CFX_ByteString csTag;
   if (FindFont(pFormDict, pFont, csTag)) {
     csNameTag = csTag;
     return;
   }
   if (!pFormDict)
     InitDict(pFormDict, pDocument);
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR) {
     pDR = new CPDF_Dictionary;
-    pFormDict->SetAt("DR", pDR);
+    pFormDict->SetFor("DR", pDR);
   }
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts) {
     pFonts = new CPDF_Dictionary;
-    pDR->SetAt("Font", pFonts);
+    pDR->SetFor("Font", pFonts);
   }
   if (csNameTag.IsEmpty())
     csNameTag = pFont->GetBaseFont();
 
   csNameTag.Remove(' ');
   csNameTag = CPDF_InterForm::GenerateNewResourceName(pDR, "Font", 4,
                                                       csNameTag.c_str());
-  pFonts->SetAtReference(csNameTag, pDocument, pFont->GetFontDict());
+  pFonts->SetReferenceFor(csNameTag, pDocument, pFont->GetFontDict());
 }
 
 CPDF_Font* AddNativeFont(CPDF_Dictionary*& pFormDict,
                          CPDF_Document* pDocument,
                          uint8_t charSet,
                          CFX_ByteString& csNameTag) {
   if (!pFormDict)
     InitDict(pFormDict, pDocument);
 
   CFX_ByteString csTemp;
@@ skipping 15 matching lines @@
 }
 
 void RemoveFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont) {
   if (!pFormDict || !pFont)
     return;
 
   CFX_ByteString csTag;
   if (!FindFont(pFormDict, pFont, csTag))
     return;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
-  pFonts->RemoveAt(csTag);
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
+  pFonts->RemoveFor(csTag);
 }
 
 void RemoveFont(CPDF_Dictionary* pFormDict, CFX_ByteString csNameTag) {
   if (!pFormDict || csNameTag.IsEmpty())
     return;
 
-  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
     return;
 
-  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
     return;
 
-  pFonts->RemoveAt(csNameTag);
+  pFonts->RemoveFor(csNameTag);
 }
 
 class CFieldNameExtractor {
  public:
   explicit CFieldNameExtractor(const CFX_WideString& full_name)
       : m_FullName(full_name) {
     m_pCur = m_FullName.c_str();
     m_pEnd = m_pCur + m_FullName.GetLength();
   }
 
@@ skipping 335 matching lines @@
 
 CPDF_InterForm::CPDF_InterForm(CPDF_Document* pDocument)
     : m_pDocument(pDocument),
       m_pFormDict(nullptr),
       m_pFieldTree(new CFieldTree),
       m_pFormNotify(nullptr) {
   CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
   if (!pRoot)
     return;
 
-  m_pFormDict = pRoot->GetDictBy("AcroForm");
+  m_pFormDict = pRoot->GetDictFor("AcroForm");
   if (!m_pFormDict)
     return;
 
-  CPDF_Array* pFields = m_pFormDict->GetArrayBy("Fields");
+  CPDF_Array* pFields = m_pFormDict->GetArrayFor("Fields");
   if (!pFields)
     return;
 
   for (size_t i = 0; i < pFields->GetCount(); i++)
     LoadField(pFields->GetDictAt(i));
 }
 
 CPDF_InterForm::~CPDF_InterForm() {
   for (auto it : m_ControlMap)
     delete it.second;
@@ skipping 40 matching lines @@
     while (m < iMinLen) {
       csTmp += '0' + m % 10;
       m++;
     }
   } else {
     m = iCount;
   }
   if (!pResDict)
     return csTmp;
 
-  CPDF_Dictionary* pDict = pResDict->GetDictBy(csType);
+  CPDF_Dictionary* pDict = pResDict->GetDictFor(csType);
   if (!pDict)
     return csTmp;
 
   int num = 0;
   CFX_ByteString bsNum;
   while (TRUE) {
     CFX_ByteString csKey = csTmp + bsNum;
     if (!pDict->KeyExist(csKey))
       return csKey;
     if (m < iCount)
@@ skipping 230 matching lines @@
     return nullptr;
 
   CFX_WideString csWName = FPDF_GetFullName(pFieldDict);
   return m_pFieldTree->GetField(csWName);
 }
 
 CPDF_FormControl* CPDF_InterForm::GetControlAtPoint(CPDF_Page* pPage,
                                                     FX_FLOAT pdf_x,
                                                     FX_FLOAT pdf_y,
                                                     int* z_order) const {
-  CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArrayBy("Annots");
+  CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArrayFor("Annots");
   if (!pAnnotList)
     return nullptr;
 
   for (size_t i = pAnnotList->GetCount(); i > 0; --i) {
     size_t annot_index = i - 1;
     CPDF_Dictionary* pAnnot = pAnnotList->GetDictAt(annot_index);
     if (!pAnnot)
       continue;
 
     const auto it = m_ControlMap.find(pAnnot);
@@ skipping 12 matching lines @@
   return nullptr;
 }
 
 CPDF_FormControl* CPDF_InterForm::GetControlByDict(
     const CPDF_Dictionary* pWidgetDict) const {
   const auto it = m_ControlMap.find(pWidgetDict);
   return it != m_ControlMap.end() ? it->second : nullptr;
 }
 
 FX_BOOL CPDF_InterForm::NeedConstructAP() const {
-  return m_pFormDict && m_pFormDict->GetBooleanBy("NeedAppearances");
+  return m_pFormDict && m_pFormDict->GetBooleanFor("NeedAppearances");
 }
 
 int CPDF_InterForm::CountFieldsInCalculationOrder() {
   if (!m_pFormDict)
     return 0;
 
-  CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
+  CPDF_Array* pArray = m_pFormDict->GetArrayFor("CO");
   return pArray ? pArray->GetCount() : 0;
 }
 
 CPDF_FormField* CPDF_InterForm::GetFieldInCalculationOrder(int index) {
   if (!m_pFormDict || index < 0)
     return nullptr;
 
-  CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
+  CPDF_Array* pArray = m_pFormDict->GetArrayFor("CO");
   if (!pArray)
     return nullptr;
 
   CPDF_Dictionary* pElement = ToDictionary(pArray->GetDirectObjectAt(index));
   return pElement ? GetFieldByDict(pElement) : nullptr;
 }
 
 int CPDF_InterForm::FindFieldInCalculationOrder(const CPDF_FormField* pField) {
   if (!m_pFormDict || !pField)
     return -1;
 
-  CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
+  CPDF_Array* pArray = m_pFormDict->GetArrayFor("CO");
   if (!pArray)
     return -1;
 
   for (size_t i = 0; i < pArray->GetCount(); i++) {
     CPDF_Object* pElement = pArray->GetDirectObjectAt(i);
     if (pElement == pField->m_pDict)
       return i;
   }
   return -1;
 }
@@ skipping 54 matching lines @@
   RemoveFont(m_pFormDict, pFont);
 }
 
 void CPDF_InterForm::RemoveFormFont(CFX_ByteString csNameTag) {
   RemoveFont(m_pFormDict, csNameTag);
 }
 
 CPDF_DefaultAppearance CPDF_InterForm::GetDefaultAppearance() {
   if (!m_pFormDict)
     return CPDF_DefaultAppearance();
-  return CPDF_DefaultAppearance(m_pFormDict->GetStringBy("DA"));
+  return CPDF_DefaultAppearance(m_pFormDict->GetStringFor("DA"));
 }
 
 CPDF_Font* CPDF_InterForm::GetDefaultFormFont() {
   return GetDefaultFont(m_pFormDict, m_pDocument);
 }
 
 int CPDF_InterForm::GetFormAlignment() {
-  return m_pFormDict ? m_pFormDict->GetIntegerBy("Q", 0) : 0;
+  return m_pFormDict ? m_pFormDict->GetIntegerFor("Q", 0) : 0;
 }
 
 bool CPDF_InterForm::ResetForm(const std::vector<CPDF_FormField*>& fields,
                                bool bIncludeOrExclude,
                                bool bNotify) {
   if (bNotify && m_pFormNotify && m_pFormNotify->BeforeFormReset(this) < 0)
     return false;
 
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i) {
@@ skipping 26 matching lines @@
   return true;
 }
 
 void CPDF_InterForm::LoadField(CPDF_Dictionary* pFieldDict, int nLevel) {
   if (nLevel > nMaxRecursion)
     return;
   if (!pFieldDict)
     return;
 
   uint32_t dwParentObjNum = pFieldDict->GetObjNum();
-  CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
+  CPDF_Array* pKids = pFieldDict->GetArrayFor("Kids");
   if (!pKids) {
     AddTerminalField(pFieldDict);
     return;
   }
 
   CPDF_Dictionary* pFirstKid = pKids->GetDictAt(0);
   if (!pFirstKid)
     return;
 
   if (pFirstKid->KeyExist("T") || pFirstKid->KeyExist("Kids")) {
     for (size_t i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pChildDict = pKids->GetDictAt(i);
       if (pChildDict) {
         if (pChildDict->GetObjNum() != dwParentObjNum)
           LoadField(pChildDict, nLevel + 1);
       }
     }
   } else {
     AddTerminalField(pFieldDict);
   }
 }
 
 FX_BOOL CPDF_InterForm::HasXFAForm() const {
-  return m_pFormDict && m_pFormDict->GetArrayBy("XFA");
+  return m_pFormDict && m_pFormDict->GetArrayFor("XFA");
 }
 
 void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage) {
   CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
   if (!pPageDict)
     return;
 
-  CPDF_Array* pAnnots = pPageDict->GetArrayBy("Annots");
+  CPDF_Array* pAnnots = pPageDict->GetArrayFor("Annots");
   if (!pAnnots)
     return;
 
   for (size_t i = 0; i < pAnnots->GetCount(); i++) {
     CPDF_Dictionary* pAnnot = pAnnots->GetDictAt(i);
-    if (pAnnot && pAnnot->GetStringBy("Subtype") == "Widget")
+    if (pAnnot && pAnnot->GetStringFor("Subtype") == "Widget")
       LoadField(pAnnot);
   }
 }
 
 CPDF_FormField* CPDF_InterForm::AddTerminalField(CPDF_Dictionary* pFieldDict) {
   if (!pFieldDict->KeyExist("T"))
     return nullptr;
 
   CPDF_Dictionary* pDict = pFieldDict;
   CFX_WideString csWName = FPDF_GetFullName(pFieldDict);
   if (csWName.IsEmpty())
     return nullptr;
 
   CPDF_FormField* pField = nullptr;
   pField = m_pFieldTree->GetField(csWName);
   if (!pField) {
     CPDF_Dictionary* pParent = pFieldDict;
     if (!pFieldDict->KeyExist("T") &&
-        pFieldDict->GetStringBy("Subtype") == "Widget") {
-      pParent = pFieldDict->GetDictBy("Parent");
+        pFieldDict->GetStringFor("Subtype") == "Widget") {
+      pParent = pFieldDict->GetDictFor("Parent");
       if (!pParent)
         pParent = pFieldDict;
     }
 
     if (pParent && pParent != pFieldDict && !pParent->KeyExist("FT")) {
       if (pFieldDict->KeyExist("FT")) {
-        CPDF_Object* pFTValue = pFieldDict->GetDirectObjectBy("FT");
+        CPDF_Object* pFTValue = pFieldDict->GetDirectObjectFor("FT");
         if (pFTValue)
-          pParent->SetAt("FT", pFTValue->Clone());
+          pParent->SetFor("FT", pFTValue->Clone());
       }
 
       if (pFieldDict->KeyExist("Ff")) {
-        CPDF_Object* pFfValue = pFieldDict->GetDirectObjectBy("Ff");
+        CPDF_Object* pFfValue = pFieldDict->GetDirectObjectFor("Ff");
         if (pFfValue)
-          pParent->SetAt("Ff", pFfValue->Clone());
+          pParent->SetFor("Ff", pFfValue->Clone());
       }
     }
 
     pField = new CPDF_FormField(this, pParent);
-    CPDF_Object* pTObj = pDict->GetObjectBy("T");
+    CPDF_Object* pTObj = pDict->GetObjectFor("T");
     if (ToReference(pTObj)) {
       CPDF_Object* pClone = pTObj->CloneDirectObject();
       if (pClone)
-        pDict->SetAt("T", pClone);
+        pDict->SetFor("T", pClone);
       else
-        pDict->SetAtName("T", "");
+        pDict->SetNameFor("T", "");
     }
     m_pFieldTree->SetField(csWName, pField);
   }
 
-  CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
+  CPDF_Array* pKids = pFieldDict->GetArrayFor("Kids");
   if (!pKids) {
-    if (pFieldDict->GetStringBy("Subtype") == "Widget")
+    if (pFieldDict->GetStringFor("Subtype") == "Widget")
       AddControl(pField, pFieldDict);
   } else {
     for (size_t i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pKid = pKids->GetDictAt(i);
       if (!pKid)
         continue;
-      if (pKid->GetStringBy("Subtype") != "Widget")
+      if (pKid->GetStringFor("Subtype") != "Widget")
         continue;
 
       AddControl(pField, pKid);
     }
   }
   return pField;
 }
 
 CPDF_FormControl* CPDF_InterForm::AddControl(CPDF_FormField* pField,
                                              CPDF_Dictionary* pWidgetDict) {
@@ skipping 24 matching lines @@
     uint32_t dwFlags = pField->GetFieldFlags();
     // TODO(thestig): Look up these magic numbers and add constants for them.
     if (dwFlags & 0x04)
       continue;
 
     bool bFind = true;
     if (fields)
       bFind = pdfium::ContainsValue(*fields, pField);
     if (bIncludeOrExclude == bFind) {
       CPDF_Dictionary* pFieldDict = pField->m_pDict;
-      if ((dwFlags & 0x02) != 0 && pFieldDict->GetStringBy("V").IsEmpty())
+      if ((dwFlags & 0x02) != 0 && pFieldDict->GetStringFor("V").IsEmpty())
         return pField;
     }
   }
   return nullptr;
 }
 
 CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path,
                                            bool bSimpleFileSpec) const {
   std::vector<CPDF_FormField*> fields;
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i)
     fields.push_back(m_pFieldTree->m_Root.GetField(i));
   return ExportToFDF(pdf_path, fields, true, bSimpleFileSpec);
 }
 
 CFDF_Document* CPDF_InterForm::ExportToFDF(
     const CFX_WideStringC& pdf_path,
     const std::vector<CPDF_FormField*>& fields,
     bool bIncludeOrExclude,
     bool bSimpleFileSpec) const {
   CFDF_Document* pDoc = CFDF_Document::CreateNewDoc();
   if (!pDoc)
     return nullptr;
 
-  CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDictBy("FDF");
+  CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDictFor("FDF");
   if (!pdf_path.IsEmpty()) {
     if (bSimpleFileSpec) {
       CFX_WideString wsFilePath = CPDF_FileSpec::EncodeFileName(pdf_path);
-      pMainDict->SetAtString("F", CFX_ByteString::FromUnicode(wsFilePath));
-      pMainDict->SetAtString("UF", PDF_EncodeText(wsFilePath));
+      pMainDict->SetStringFor("F", CFX_ByteString::FromUnicode(wsFilePath));
+      pMainDict->SetStringFor("UF", PDF_EncodeText(wsFilePath));
     } else {
       CPDF_FileSpec filespec;
       filespec.SetFileName(pdf_path);
-      pMainDict->SetAt("F", filespec.GetObj());
+      pMainDict->SetFor("F", filespec.GetObj());
     }
   }
 
   CPDF_Array* pFields = new CPDF_Array;
-  pMainDict->SetAt("Fields", pFields);
+  pMainDict->SetFor("Fields", pFields);
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; i++) {
     CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
     if (!pField || pField->GetType() == CPDF_FormField::PushButton)
       continue;
 
     uint32_t dwFlags = pField->GetFieldFlags();
     if (dwFlags & 0x04)
       continue;
 
     if (bIncludeOrExclude == pdfium::ContainsValue(fields, pField)) {
-      if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetStringBy("V").IsEmpty())
+      if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetStringFor("V").IsEmpty())
         continue;
 
       CFX_WideString fullname = FPDF_GetFullName(pField->GetFieldDict());
       CPDF_Dictionary* pFieldDict = new CPDF_Dictionary;
-      pFieldDict->SetAt("T", new CPDF_String(fullname));
+      pFieldDict->SetFor("T", new CPDF_String(fullname));
       if (pField->GetType() == CPDF_FormField::CheckBox ||
           pField->GetType() == CPDF_FormField::RadioButton) {
         CFX_WideString csExport = pField->GetCheckValue(FALSE);
         CFX_ByteString csBExport = PDF_EncodeText(csExport);
         CPDF_Object* pOpt = FPDF_GetFieldAttr(pField->m_pDict, "Opt");
         if (pOpt)
-          pFieldDict->SetAtString("V", csBExport);
+          pFieldDict->SetStringFor("V", csBExport);
         else
-          pFieldDict->SetAtName("V", csBExport);
+          pFieldDict->SetNameFor("V", csBExport);
       } else {
         CPDF_Object* pV = FPDF_GetFieldAttr(pField->m_pDict, "V");
         if (pV)
-          pFieldDict->SetAt("V", pV->CloneDirectObject());
+          pFieldDict->SetFor("V", pV->CloneDirectObject());
       }
       pFields->Add(pFieldDict);
     }
   }
   return pDoc;
 }
 
 void CPDF_InterForm::FDF_ImportField(CPDF_Dictionary* pFieldDict,
                                      const CFX_WideString& parent_name,
                                      FX_BOOL bNotify,
                                      int nLevel) {
   CFX_WideString name;
   if (!parent_name.IsEmpty())
     name = parent_name + L".";
 
-  name += pFieldDict->GetUnicodeTextBy("T");
-  CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
+  name += pFieldDict->GetUnicodeTextFor("T");
+  CPDF_Array* pKids = pFieldDict->GetArrayFor("Kids");
   if (pKids) {
     for (size_t i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pKid = pKids->GetDictAt(i);
       if (!pKid)
         continue;
       if (nLevel <= nMaxRecursion)
         FDF_ImportField(pKid, name, bNotify, nLevel + 1);
     }
     return;
   }
@@ skipping 14 matching lines @@
       iRet = m_pFormNotify->BeforeValueChange(pField, csWValue);
 
     if (iRet < 0)
       return;
   }
 
   pField->SetValue(csWValue);
   CPDF_FormField::Type eType = pField->GetType();
   if ((eType == CPDF_FormField::ListBox || eType == CPDF_FormField::ComboBox) &&
       pFieldDict->KeyExist("Opt")) {
-    pField->m_pDict->SetAt(
-        "Opt", pFieldDict->GetDirectObjectBy("Opt")->CloneDirectObject());
+    pField->m_pDict->SetFor(
+        "Opt", pFieldDict->GetDirectObjectFor("Opt")->CloneDirectObject());
   }
 
   if (bNotify && m_pFormNotify) {
     if (iType == FIELDTYPE_CHECKBOX || iType == FIELDTYPE_RADIOBUTTON)
       m_pFormNotify->AfterCheckedStatusChange(pField);
     else if (iType == FIELDTYPE_LISTBOX)
       m_pFormNotify->AfterSelectionChange(pField);
     else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD)
       m_pFormNotify->AfterValueChange(pField);
   }
 }
 
 FX_BOOL CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF,
                                       FX_BOOL bNotify) {
   if (!pFDF)
     return FALSE;
 
-  CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDictBy("FDF");
+  CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDictFor("FDF");
   if (!pMainDict)
     return FALSE;
 
-  CPDF_Array* pFields = pMainDict->GetArrayBy("Fields");
+  CPDF_Array* pFields = pMainDict->GetArrayFor("Fields");
   if (!pFields)
     return FALSE;
 
-  m_bsEncoding = pMainDict->GetStringBy("Encoding");
+  m_bsEncoding = pMainDict->GetStringFor("Encoding");
   if (bNotify && m_pFormNotify && m_pFormNotify->BeforeFormImportData(this) < 0)
     return FALSE;
 
   for (size_t i = 0; i < pFields->GetCount(); i++) {
     CPDF_Dictionary* pField = pFields->GetDictAt(i);
     if (!pField)
       continue;
 
     FDF_ImportField(pField, L"", bNotify);
   }
   if (bNotify && m_pFormNotify)
     m_pFormNotify->AfterFormImportData(this);
   return TRUE;
 }
 
 void CPDF_InterForm::SetFormNotify(IPDF_FormNotify* pNotify) {
   m_pFormNotify = pNotify;
 }