Member function name refactoring

core/src/fpdfdoc/doc_form.cpp

 // Copyright 2014 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 "core/include/fpdfdoc/fpdf_doc.h"
 #include "doc_utils.h"
 #include "third_party/base/stl_util.h"
 
@@ skipping 216 matching lines @@
       m_pDocument(pDocument),
       m_bGenerateAP(bGenerateAP),
       m_pFormDict(nullptr),
       m_pFieldTree(new CFieldTree),
       m_pFormNotify(nullptr),
       m_bUpdated(FALSE) {
   CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
   if (!pRoot)
     return;
 
-  m_pFormDict = pRoot->GetDict("AcroForm");
+  m_pFormDict = pRoot->GetDictBy("AcroForm");
   if (!m_pFormDict)
     return;
 
-  CPDF_Array* pFields = m_pFormDict->GetArray("Fields");
+  CPDF_Array* pFields = m_pFormDict->GetArrayBy("Fields");
   if (!pFields)
     return;
 
   int count = pFields->GetCount();
   for (int i = 0; i < count; i++) {
-    LoadField(pFields->GetDict(i));
+    LoadField(pFields->GetDictAt(i));
   }
 }
 
 CPDF_InterForm::~CPDF_InterForm() {
   for (auto it : m_ControlMap)
     delete it.second;
 
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i) {
     delete m_pFieldTree->m_Root.GetField(i);
@@ skipping 36 matching lines @@
     while (m < iMinLen) {
       csTmp += '0' + m % 10;
       m++;
     }
   } else {
     m = iCount;
   }
   if (!pResDict) {
     return csTmp;
   }
-  CPDF_Dictionary* pDict = pResDict->GetDict(csType);
+  CPDF_Dictionary* pDict = pResDict->GetDictBy(csType);
   if (!pDict) {
     return csTmp;
   }
   int num = 0;
   CFX_ByteString bsNum;
   while (TRUE) {
     if (!pDict->KeyExist(csTmp + bsNum)) {
       return csTmp + bsNum;
     }
     if (m < iCount) {
@@ skipping 351 matching lines @@
     return NULL;
   }
   CFX_WideString csWName = 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->GetArray("Annots");
+  CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArrayBy("Annots");
   if (!pAnnotList)
     return nullptr;
 
   for (FX_DWORD i = pAnnotList->GetCount(); i > 0; --i) {
     FX_DWORD annot_index = i - 1;
-    CPDF_Dictionary* pAnnot = pAnnotList->GetDict(annot_index);
+    CPDF_Dictionary* pAnnot = pAnnotList->GetDictAt(annot_index);
     if (!pAnnot)
       continue;
 
     const auto it = m_ControlMap.find(pAnnot);
     if (it == m_ControlMap.end())
       continue;
 
     CPDF_FormControl* pControl = it->second;
     CFX_FloatRect rect = pControl->GetRect();
     if (!rect.Contains(pdf_x, pdf_y))
       continue;
 
     if (z_order)
       *z_order = annot_index;
     return pControl;
   }
   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() {
-  return m_pFormDict && m_pFormDict->GetBoolean("NeedAppearances");
+  return m_pFormDict && m_pFormDict->GetBooleanBy("NeedAppearances");
 }
 void CPDF_InterForm::NeedConstructAP(FX_BOOL bNeedAP) {
   if (!m_pFormDict) {
     InitInterFormDict(m_pFormDict, m_pDocument);
   }
   m_pFormDict->SetAtBoolean("NeedAppearances", bNeedAP);
   m_bGenerateAP = bNeedAP;
 }
 int CPDF_InterForm::CountFieldsInCalculationOrder() {
   if (!m_pFormDict) {
     return 0;
   }
-  CPDF_Array* pArray = m_pFormDict->GetArray("CO");
+  CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
   return pArray ? pArray->GetCount() : 0;
 }
 CPDF_FormField* CPDF_InterForm::GetFieldInCalculationOrder(int index) {
   if (!m_pFormDict || index < 0) {
     return NULL;
   }
-  CPDF_Array* pArray = m_pFormDict->GetArray("CO");
+  CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
   if (!pArray) {
     return NULL;
   }
   if (CPDF_Dictionary* pElement =
           ToDictionary(pArray->GetElementValue(index))) {
     return GetFieldByDict(pElement);
   }
   return NULL;
 }
 int CPDF_InterForm::FindFieldInCalculationOrder(const CPDF_FormField* pField) {
   if (!m_pFormDict || !pField) {
     return -1;
   }
-  CPDF_Array* pArray = m_pFormDict->GetArray("CO");
+  CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
   if (!pArray) {
     return -1;
   }
   for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
     CPDF_Object* pElement = pArray->GetElementValue(i);
     if (pElement == pField->m_pDict) {
       return i;
     }
   }
   return -1;
@@ skipping 49 matching lines @@
 }
 void CPDF_InterForm::RemoveFormFont(CFX_ByteString csNameTag) {
   m_bUpdated = TRUE;
   RemoveInterFormFont(m_pFormDict, csNameTag);
 }
 CPDF_DefaultAppearance CPDF_InterForm::GetDefaultAppearance() {
   CFX_ByteString csDA;
   if (!m_pFormDict) {
     return csDA;
   }
-  csDA = m_pFormDict->GetString("DA");
+  csDA = m_pFormDict->GetStringBy("DA");
   return csDA;
 }
 CPDF_Font* CPDF_InterForm::GetDefaultFormFont() {
   return GetDefaultInterFormFont(m_pFormDict, m_pDocument);
 }
 int CPDF_InterForm::GetFormAlignment() {
-  return m_pFormDict ? m_pFormDict->GetInteger("Q", 0) : 0;
+  return m_pFormDict ? m_pFormDict->GetIntegerBy("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 27 matching lines @@
 }
 
 void CPDF_InterForm::LoadField(CPDF_Dictionary* pFieldDict, int nLevel) {
   if (nLevel > nMaxRecursion) {
     return;
   }
   if (!pFieldDict) {
     return;
   }
   FX_DWORD dwParentObjNum = pFieldDict->GetObjNum();
-  CPDF_Array* pKids = pFieldDict->GetArray("Kids");
+  CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
   if (!pKids) {
     AddTerminalField(pFieldDict);
     return;
   }
-  CPDF_Dictionary* pFirstKid = pKids->GetDict(0);
+  CPDF_Dictionary* pFirstKid = pKids->GetDictAt(0);
   if (!pFirstKid) {
     return;
   }
   if (pFirstKid->KeyExist("T") || pFirstKid->KeyExist("Kids")) {
     for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
-      CPDF_Dictionary* pChildDict = pKids->GetDict(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->GetArray("XFA");
+  return m_pFormDict && m_pFormDict->GetArrayBy("XFA");
 }
 void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage) {
   CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
   if (!pPageDict) {
     return;
   }
-  CPDF_Array* pAnnots = pPageDict->GetArray("Annots");
+  CPDF_Array* pAnnots = pPageDict->GetArrayBy("Annots");
   if (!pAnnots) {
     return;
   }
   int iAnnotCount = pAnnots->GetCount();
   for (int i = 0; i < iAnnotCount; i++) {
-    CPDF_Dictionary* pAnnot = pAnnots->GetDict(i);
-    if (pAnnot && pAnnot->GetString("Subtype") == "Widget") {
+    CPDF_Dictionary* pAnnot = pAnnots->GetDictAt(i);
+    if (pAnnot && pAnnot->GetStringBy("Subtype") == "Widget") {
       LoadField(pAnnot);
     }
   }
 }
 CPDF_FormField* CPDF_InterForm::AddTerminalField(CPDF_Dictionary* pFieldDict) {
   if (!pFieldDict->KeyExist("T")) {
     return NULL;
   }
   CPDF_Dictionary* pDict = pFieldDict;
   CFX_WideString csWName = GetFullName(pFieldDict);
   if (csWName.IsEmpty()) {
     return NULL;
   }
   CPDF_FormField* pField = NULL;
   pField = m_pFieldTree->GetField(csWName);
   if (!pField) {
     CPDF_Dictionary* pParent = pFieldDict;
     if (!pFieldDict->KeyExist("T") &&
-        pFieldDict->GetString("Subtype") == "Widget") {
-      pParent = pFieldDict->GetDict("Parent");
+        pFieldDict->GetStringBy("Subtype") == "Widget") {
+      pParent = pFieldDict->GetDictBy("Parent");
       if (!pParent) {
         pParent = pFieldDict;
       }
     }
     if (pParent && pParent != pFieldDict && !pParent->KeyExist("FT")) {
       if (pFieldDict->KeyExist("FT")) {
         CPDF_Object* pFTValue = pFieldDict->GetElementValue("FT");
         if (pFTValue) {
           pParent->SetAt("FT", pFTValue->Clone());
         }
       }
       if (pFieldDict->KeyExist("Ff")) {
         CPDF_Object* pFfValue = pFieldDict->GetElementValue("Ff");
         if (pFfValue) {
           pParent->SetAt("Ff", pFfValue->Clone());
         }
       }
     }
     pField = new CPDF_FormField(this, pParent);
     CPDF_Object* pTObj = pDict->GetElement("T");
     if (ToReference(pTObj)) {
       CPDF_Object* pClone = pTObj->Clone(TRUE);
       if (pClone)
         pDict->SetAt("T", pClone);
       else
         pDict->SetAtName("T", "");
     }
     m_pFieldTree->SetField(csWName, pField);
   }
-  CPDF_Array* pKids = pFieldDict->GetArray("Kids");
+  CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
   if (!pKids) {
-    if (pFieldDict->GetString("Subtype") == "Widget") {
+    if (pFieldDict->GetStringBy("Subtype") == "Widget") {
       AddControl(pField, pFieldDict);
     }
   } else {
     for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
-      CPDF_Dictionary* pKid = pKids->GetDict(i);
+      CPDF_Dictionary* pKid = pKids->GetDictAt(i);
       if (!pKid) {
         continue;
       }
-      if (pKid->GetString("Subtype") != "Widget") {
+      if (pKid->GetStringBy("Subtype") != "Widget") {
         continue;
       }
       AddControl(pField, pKid);
     }
   }
   return pField;
 }
 CPDF_FormControl* CPDF_InterForm::AddControl(const CPDF_FormField* pField,
                                              CPDF_Dictionary* pWidgetDict) {
   const auto it = m_ControlMap.find(pWidgetDict);
@@ skipping 24 matching lines @@
     FX_DWORD 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->GetString("V").IsEmpty()) {
+      if ((dwFlags & 0x02) != 0 && pFieldDict->GetStringBy("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 NULL;
   }
-  CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDict("FDF");
+  CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDictBy("FDF");
   if (!pdf_path.IsEmpty()) {
     if (bSimpleFileSpec) {
       CFX_WideString wsFilePath = FILESPEC_EncodeFileName(pdf_path);
       pMainDict->SetAtString("F", CFX_ByteString::FromUnicode(wsFilePath));
       pMainDict->SetAtString("UF", PDF_EncodeText(wsFilePath));
     } else {
       CPDF_FileSpec filespec;
       filespec.SetFileName(pdf_path);
       pMainDict->SetAt("F", static_cast<CPDF_Object*>(filespec));
     }
   }
   CPDF_Array* pFields = new CPDF_Array;
   pMainDict->SetAt("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;
     }
     FX_DWORD dwFlags = pField->GetFieldFlags();
     if (dwFlags & 0x04)
       continue;
 
     if (bIncludeOrExclude == pdfium::ContainsValue(fields, pField)) {
-      if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetString("V").IsEmpty())
+      if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetStringBy("V").IsEmpty())
         continue;
 
       CFX_WideString fullname = GetFullName(pField->GetFieldDict());
       CPDF_Dictionary* pFieldDict = new CPDF_Dictionary;
       pFieldDict->SetAt("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");
@@ skipping 16 matching lines @@
   int32_t m_codePage;
 } g_fieldEncoding[] = {
     {"BigFive", 950},
     {"GBK", 936},
     {"Shift-JIS", 932},
     {"UHC", 949},
 };
 static void FPDFDOC_FDF_GetFieldValue(CPDF_Dictionary* pFieldDict,
                                       CFX_WideString& csValue,
                                       CFX_ByteString& bsEncoding) {
-  CFX_ByteString csBValue = pFieldDict->GetString("V");
+  CFX_ByteString csBValue = pFieldDict->GetStringBy("V");
   int32_t iCount = sizeof(g_fieldEncoding) / sizeof(g_fieldEncoding[0]);
   int32_t i = 0;
   for (; i < iCount; ++i)
     if (bsEncoding == g_fieldEncoding[i].m_name) {
       break;
     }
   if (i < iCount) {
     CFX_CharMap* pCharMap =
         CFX_CharMap::GetDefaultMapper(g_fieldEncoding[i].m_codePage);
     FXSYS_assert(pCharMap);
     csValue.ConvertFrom(csBValue, pCharMap);
     return;
   }
   CFX_ByteString csTemp = csBValue.Left(2);
   if (csTemp == "\xFF\xFE" || csTemp == "\xFE\xFF") {
     csValue = PDF_DecodeText(csBValue);
   } else {
     csValue = CFX_WideString::FromLocal(csBValue);
   }
 }
 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->GetUnicodeText("T");
-  CPDF_Array* pKids = pFieldDict->GetArray("Kids");
+  name += pFieldDict->GetUnicodeTextBy("T");
+  CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
   if (pKids) {
     for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
-      CPDF_Dictionary* pKid = pKids->GetDict(i);
+      CPDF_Dictionary* pKid = pKids->GetDictAt(i);
       if (!pKid) {
         continue;
       }
       if (nLevel <= nMaxRecursion) {
         FDF_ImportField(pKid, name, bNotify, nLevel + 1);
       }
     }
     return;
   }
   if (!pFieldDict->KeyExist("V")) {
@@ skipping 39 matching lines @@
   }
   if (CPDF_InterForm::m_bUpdateAP) {
     pField->UpdateAP(NULL);
   }
 }
 FX_BOOL CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF,
                                       FX_BOOL bNotify) {
   if (!pFDF) {
     return FALSE;
   }
-  CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDict("FDF");
+  CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDictBy("FDF");
   if (!pMainDict) {
     return FALSE;
   }
-  CPDF_Array* pFields = pMainDict->GetArray("Fields");
+  CPDF_Array* pFields = pMainDict->GetArrayBy("Fields");
   if (!pFields) {
     return FALSE;
   }
-  m_bsEncoding = pMainDict->GetString("Encoding");
+  m_bsEncoding = pMainDict->GetStringBy("Encoding");
   if (bNotify && m_pFormNotify) {
     int iRet = m_pFormNotify->BeforeFormImportData(this);
     if (iRet < 0) {
       return FALSE;
     }
   }
   for (FX_DWORD i = 0; i < pFields->GetCount(); i++) {
-    CPDF_Dictionary* pField = pFields->GetDict(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(const CPDF_FormNotify* pNotify) {
   m_pFormNotify = (CPDF_FormNotify*)pNotify;
 }