Merge to XFA: Member function name refactoring

core/src/fpdfdoc/doc_utils.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 <algorithm>
 
 #include "core/include/fpdfdoc/fpdf_doc.h"
 #include "doc_utils.h"
 
 static const int FPDFDOC_UTILS_MAXRECURSION = 32;
 
 CFX_WideString GetFullName(CPDF_Dictionary* pFieldDict) {
   CFX_WideString full_name;
   CPDF_Dictionary* pLevel = pFieldDict;
   while (pLevel) {
-    CFX_WideString short_name = pLevel->GetUnicodeText("T");
+    CFX_WideString short_name = pLevel->GetUnicodeTextBy("T");
     if (short_name != L"") {
       if (full_name == L"") {
         full_name = short_name;
       } else {
         full_name = short_name + L"." + full_name;
       }
     }
-    pLevel = pLevel->GetDict("Parent");
+    pLevel = pLevel->GetDictBy("Parent");
   }
   return full_name;
 }
 FX_BOOL CPDF_DefaultAppearance::HasFont() {
   if (m_csDA.IsEmpty()) {
     return FALSE;
   }
   CPDF_SimpleParser syntax(m_csDA);
   return syntax.FindTagParam("Tf", 2);
 }
@@ skipping 228 matching lines @@
   }
   csDA += "0 g";
   if (!pFormDict->KeyExist("DA")) {
     pFormDict->SetAtString("DA", csDA);
   }
 }
 FX_DWORD CountInterFormFonts(CPDF_Dictionary* pFormDict) {
   if (!pFormDict) {
     return 0;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     return 0;
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
     return 0;
   }
   FX_DWORD dwCount = 0;
   for (const auto& it : *pFonts) {
     CPDF_Object* pObj = it.second;
     if (!pObj) {
       continue;
     }
     if (CPDF_Dictionary* pDirect = ToDictionary(pObj->GetDirect())) {
-      if (pDirect->GetString("Type") == "Font") {
+      if (pDirect->GetStringBy("Type") == "Font") {
         dwCount++;
       }
     }
   }
   return dwCount;
 }
 CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
                             CPDF_Document* pDocument,
                             FX_DWORD index,
                             CFX_ByteString& csNameTag) {
   if (!pFormDict) {
     return NULL;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     return NULL;
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
     return NULL;
   }
   FX_DWORD 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->GetString("Type") != "Font")
+    if (pElement->GetStringBy("Type") != "Font")
       continue;
     if (dwCount == index) {
       csNameTag = csKey;
       return pDocument->LoadFont(pElement);
     }
     dwCount++;
   }
   return NULL;
 }
 CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
                             CPDF_Document* pDocument,
                             CFX_ByteString csNameTag) {
   CFX_ByteString csAlias = PDF_NameDecode(csNameTag);
   if (!pFormDict || csAlias.IsEmpty()) {
     return NULL;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     return NULL;
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
     return NULL;
   }
-  CPDF_Dictionary* pElement = pFonts->GetDict(csAlias);
+  CPDF_Dictionary* pElement = pFonts->GetDictBy(csAlias);
   if (!pElement) {
     return NULL;
   }
-  if (pElement->GetString("Type") == "Font") {
+  if (pElement->GetStringBy("Type") == "Font") {
     return pDocument->LoadFont(pElement);
   }
   return NULL;
 }
 CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
                             CPDF_Document* pDocument,
                             CFX_ByteString csFontName,
                             CFX_ByteString& csNameTag) {
   if (!pFormDict || csFontName.IsEmpty()) {
     return NULL;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     return NULL;
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
     return NULL;
   }
   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->GetString("Type") != "Font")
+    if (pElement->GetStringBy("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 NULL;
 }
 CPDF_Font* GetNativeInterFormFont(CPDF_Dictionary* pFormDict,
                                   CPDF_Document* pDocument,
                                   uint8_t charSet,
                                   CFX_ByteString& csNameTag) {
   if (!pFormDict) {
     return NULL;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     return NULL;
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
     return NULL;
   }
   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->GetString("Type") != "Font")
+    if (pElement->GetStringBy("Type") != "Font")
       continue;
     CPDF_Font* pFind = pDocument->LoadFont(pElement);
     if (!pFind) {
       continue;
     }
     CFX_SubstFont* pSubst = (CFX_SubstFont*)pFind->GetSubstFont();
     if (!pSubst) {
       continue;
     }
     if (pSubst->m_Charset == (int)charSet) {
@@ skipping 18 matching lines @@
     }
   }
   return GetNativeInterFormFont(pFormDict, pDocument, charSet, csNameTag);
 }
 FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict,
                           const CPDF_Font* pFont,
                           CFX_ByteString& csNameTag) {
   if (!pFormDict || !pFont) {
     return FALSE;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     return FALSE;
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("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->GetString("Type") != "Font") {
+    if (pElement->GetStringBy("Type") != "Font") {
       continue;
     }
     if (pFont->GetFontDict() == pElement) {
       csNameTag = csKey;
       return TRUE;
     }
   }
   return FALSE;
 }
 FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict,
                           CPDF_Document* pDocument,
                           CFX_ByteString csFontName,
                           CPDF_Font*& pFont,
                           CFX_ByteString& csNameTag) {
   if (!pFormDict) {
     return FALSE;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     return FALSE;
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("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->GetString("Type") != "Font") {
+    if (pElement->GetStringBy("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 @@
     InitInterFormDict(pFormDict, pDocument);
   }
   CFX_ByteString csTag;
   if (FindInterFormFont(pFormDict, pFont, csTag)) {
     csNameTag = csTag;
     return;
   }
   if (!pFormDict) {
     InitInterFormDict(pFormDict, pDocument);
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     pDR = new CPDF_Dictionary;
     pFormDict->SetAt("DR", pDR);
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
     pFonts = new CPDF_Dictionary;
     pDR->SetAt("Font", pFonts);
   }
   if (csNameTag.IsEmpty()) {
     csNameTag = pFont->GetBaseFont();
   }
   csNameTag.Remove(' ');
   csNameTag =
       CPDF_InterForm::GenerateNewResourceName(pDR, "Font", 4, csNameTag);
@@ skipping 32 matching lines @@
   return AddNativeInterFormFont(pFormDict, pDocument, charSet, csNameTag);
 }
 void RemoveInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont) {
   if (!pFormDict || !pFont) {
     return;
   }
   CFX_ByteString csTag;
   if (!FindInterFormFont(pFormDict, pFont, csTag)) {
     return;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   pFonts->RemoveAt(csTag);
 }
 void RemoveInterFormFont(CPDF_Dictionary* pFormDict, CFX_ByteString csNameTag) {
   if (!pFormDict || csNameTag.IsEmpty()) {
     return;
   }
-  CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
     return;
   }
-  CPDF_Dictionary* pFonts = pDR->GetDict("Font");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
     return;
   }
   pFonts->RemoveAt(csNameTag);
 }
 CPDF_Font* GetDefaultInterFormFont(CPDF_Dictionary* pFormDict,
                                    CPDF_Document* pDocument) {
   if (!pFormDict) {
     return NULL;
   }
-  CPDF_DefaultAppearance cDA = pFormDict->GetString("DA");
+  CPDF_DefaultAppearance cDA = pFormDict->GetStringBy("DA");
   CFX_ByteString csFontNameTag;
   FX_FLOAT fFontSize;
   cDA.GetFont(csFontNameTag, fFontSize);
   return GetInterFormFont(pFormDict, pDocument, csFontNameTag);
 }
 CPDF_IconFit::ScaleMethod CPDF_IconFit::GetScaleMethod() {
   if (!m_pDict) {
     return Always;
   }
-  CFX_ByteString csSW = m_pDict->GetString("SW", "A");
+  CFX_ByteString csSW = m_pDict->GetStringBy("SW", "A");
   if (csSW == "B") {
     return Bigger;
   }
   if (csSW == "S") {
     return Smaller;
   }
   if (csSW == "N") {
     return Never;
   }
   return Always;
 }
 FX_BOOL CPDF_IconFit::IsProportionalScale() {
   if (!m_pDict) {
     return TRUE;
   }
-  return m_pDict->GetString("S", "P") != "A";
+  return m_pDict->GetStringBy("S", "P") != "A";
 }
 void CPDF_IconFit::GetIconPosition(FX_FLOAT& fLeft, FX_FLOAT& fBottom) {
   fLeft = fBottom = 0.5;
   if (!m_pDict) {
     return;
   }
-  CPDF_Array* pA = m_pDict->GetArray("A");
+  CPDF_Array* pA = m_pDict->GetArrayBy("A");
   if (pA) {
     FX_DWORD dwCount = pA->GetCount();
     if (dwCount > 0) {
-      fLeft = pA->GetNumber(0);
+      fLeft = pA->GetNumberAt(0);
     }
     if (dwCount > 1) {
-      fBottom = pA->GetNumber(1);
+      fBottom = pA->GetNumberAt(1);
     }
   }
 }
 FX_BOOL CPDF_IconFit::GetFittingBounds() {
   if (!m_pDict) {
     return FALSE;
   }
-  return m_pDict->GetBoolean("FB");
+  return m_pDict->GetBooleanBy("FB");
 }
 void SaveCheckedFieldStatus(CPDF_FormField* pField,
                             CFX_ByteArray& statusArray) {
   int iCount = pField->CountControls();
   for (int i = 0; i < iCount; i++) {
     CPDF_FormControl* pControl = pField->GetControl(i);
     if (!pControl) {
       continue;
     }
     statusArray.Add(pControl->IsChecked() ? 1 : 0);
   }
 }
 CPDF_Object* FPDF_GetFieldAttr(CPDF_Dictionary* pFieldDict,
                                const FX_CHAR* name,
                                int nLevel) {
   if (nLevel > FPDFDOC_UTILS_MAXRECURSION) {
     return NULL;
   }
   if (!pFieldDict) {
     return NULL;
   }
   CPDF_Object* pAttr = pFieldDict->GetElementValue(name);
   if (pAttr) {
     return pAttr;
   }
-  CPDF_Dictionary* pParent = pFieldDict->GetDict("Parent");
+  CPDF_Dictionary* pParent = pFieldDict->GetDictBy("Parent");
   if (!pParent) {
     return NULL;
   }
   return FPDF_GetFieldAttr(pParent, name, nLevel + 1);
 }