Rename dictionary set and get methods

core/fpdfapi/fpdf_parser/cpdf_data_avail.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 "core/fpdfapi/fpdf_parser/include/cpdf_data_avail.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 133 matching lines @@
     switch (type) {
       case CPDF_Object::ARRAY: {
         CPDF_Array* pArray = pObj->AsArray();
         for (size_t k = 0; k < pArray->GetCount(); ++k)
           new_obj_array.Add(pArray->GetObjectAt(k));
       } break;
       case CPDF_Object::STREAM:
         pObj = pObj->GetDict();
       case CPDF_Object::DICTIONARY: {
         CPDF_Dictionary* pDict = pObj->GetDict();
-        if (pDict && pDict->GetStringBy("Type") == "Page" && !bParsePage)
+        if (pDict && pDict->GetStringFor("Type") == "Page" && !bParsePage)
           continue;
 
         for (const auto& it : *pDict) {
           const CFX_ByteString& key = it.first;
           CPDF_Object* value = it.second;
           if (key != "Parent")
             new_obj_array.Add(value);
         }
       } break;
       case CPDF_Object::REFERENCE: {
@@ skipping 269 matching lines @@
     }
     return FALSE;
   }
 
   CPDF_Dictionary* pDict = m_pRoot->GetDict();
   if (!pDict) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  CPDF_Reference* pRef = ToReference(pDict->GetObjectBy("Pages"));
+  CPDF_Reference* pRef = ToReference(pDict->GetObjectFor("Pages"));
   if (!pRef) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   m_PagesObjNum = pRef->GetRefObjNum();
   CPDF_Reference* pAcroFormRef =
-      ToReference(m_pRoot->GetDict()->GetObjectBy("AcroForm"));
+      ToReference(m_pRoot->GetDict()->GetObjectFor("AcroForm"));
   if (pAcroFormRef) {
     m_bHaveAcroForm = TRUE;
     m_dwAcroFormObjNum = pAcroFormRef->GetRefObjNum();
   }
 
   if (m_dwInfoObjNum) {
     m_docStatus = PDF_DATAAVAIL_INFO;
   } else {
     m_docStatus =
         m_bHaveAcroForm ? PDF_DATAAVAIL_ACROFORM : PDF_DATAAVAIL_PAGETREE;
   }
   return TRUE;
 }
 
 FX_BOOL CPDF_DataAvail::PreparePageItem() {
   CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
   CPDF_Reference* pRef =
-      ToReference(pRoot ? pRoot->GetObjectBy("Pages") : nullptr);
+      ToReference(pRoot ? pRoot->GetObjectFor("Pages") : nullptr);
   if (!pRef) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   m_PagesObjNum = pRef->GetRefObjNum();
   m_pCurrentParser = m_pDocument->GetParser();
   m_docStatus = PDF_DATAAVAIL_PAGETREE;
   return TRUE;
 }
@@ skipping 25 matching lines @@
         if (CPDF_Reference* pRef = ToReference(pArrayObj))
           UnavailObjList.Add(pRef->GetRefObjNum());
       }
     }
 
     if (!pObj->IsDictionary()) {
       pObj->Release();
       continue;
     }
 
-    CFX_ByteString type = pObj->GetDict()->GetStringBy("Type");
+    CFX_ByteString type = pObj->GetDict()->GetStringFor("Type");
     if (type == "Pages") {
       m_PagesArray.Add(pObj);
       continue;
     }
     pObj->Release();
   }
 
   m_PageObjList.RemoveAll();
   if (UnavailObjList.GetSize()) {
     m_PageObjList.Append(UnavailObjList);
@@ skipping 26 matching lines @@
   return TRUE;
 }
 
 FX_BOOL CPDF_DataAvail::GetPageKids(CPDF_Parser* pParser, CPDF_Object* pPages) {
   if (!pParser) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   CPDF_Dictionary* pDict = pPages->GetDict();
-  CPDF_Object* pKids = pDict ? pDict->GetObjectBy("Kids") : nullptr;
+  CPDF_Object* pKids = pDict ? pDict->GetObjectFor("Kids") : nullptr;
   if (!pKids)
     return TRUE;
 
   switch (pKids->GetType()) {
     case CPDF_Object::REFERENCE:
       m_PageObjList.Add(pKids->AsReference()->GetRefObjNum());
       break;
     case CPDF_Object::ARRAY: {
       CPDF_Array* pKidsArray = pKids->AsArray();
       for (size_t i = 0; i < pKidsArray->GetCount(); ++i) {
@@ skipping 52 matching lines @@
     }
     return TRUE;
   }
 
   pHints->AddSegment(0, kReqSize);
   return FALSE;
 }
 
 FX_BOOL CPDF_DataAvail::CheckFirstPage(DownloadHints* pHints) {
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-  CPDF_Object* pEndOffSet = pDict ? pDict->GetObjectBy("E") : nullptr;
+  CPDF_Object* pEndOffSet = pDict ? pDict->GetObjectFor("E") : nullptr;
   if (!pEndOffSet) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  CPDF_Object* pXRefOffset = pDict ? pDict->GetObjectBy("T") : nullptr;
+  CPDF_Object* pXRefOffset = pDict ? pDict->GetObjectFor("T") : nullptr;
   if (!pXRefOffset) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  CPDF_Object* pFileLen = pDict ? pDict->GetObjectBy("L") : nullptr;
+  CPDF_Object* pFileLen = pDict ? pDict->GetObjectFor("L") : nullptr;
   if (!pFileLen) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   FX_BOOL bNeedDownLoad = FALSE;
   if (pEndOffSet->IsNumber()) {
     uint32_t dwEnd = pEndOffSet->GetInteger();
     dwEnd += 512;
     if ((FX_FILESIZE)dwEnd > m_dwFileLen)
@@ skipping 62 matching lines @@
 }
 
 FX_BOOL CPDF_DataAvail::CheckHintTables(DownloadHints* pHints) {
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
   if (!pDict) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   // The actual value is not required here, but validate its existence and type.
-  CPDF_Number* pFirstPage = ToNumber(pDict->GetDirectObjectBy("O"));
+  CPDF_Number* pFirstPage = ToNumber(pDict->GetDirectObjectFor("O"));
   if (!pFirstPage || !pFirstPage->IsInteger()) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  CPDF_Number* pPageCount = ToNumber(pDict->GetDirectObjectBy("N"));
+  CPDF_Number* pPageCount = ToNumber(pDict->GetDirectObjectFor("N"));
   if (!pPageCount || !pPageCount->IsInteger()) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   int nPageCount = pPageCount->GetInteger();
   if (nPageCount <= 1) {
     m_docStatus = PDF_DATAAVAIL_DONE;
     return TRUE;
   }
 
-  CPDF_Array* pHintStreamRange = pDict->GetArrayBy("H");
+  CPDF_Array* pHintStreamRange = pDict->GetArrayFor("H");
   size_t nHintStreamSize = pHintStreamRange ? pHintStreamRange->GetCount() : 0;
   if (nHintStreamSize != 2 && nHintStreamSize != 4) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   for (const CPDF_Object* pArrayObject : *pHintStreamRange) {
     const CPDF_Number* pNumber = ToNumber(pArrayObject->GetDirect());
     if (!pNumber || !pNumber->IsInteger()) {
       m_docStatus = PDF_DATAAVAIL_ERROR;
@@ skipping 102 matching lines @@
   if (!bNumber)
     return FALSE;
 
   uint32_t objnum = FXSYS_atoui(wordObjNum.c_str());
   m_pLinearized =
       ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum);
   if (!m_pLinearized)
     return FALSE;
 
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-  if (!pDict || !pDict->GetObjectBy("Linearized"))
+  if (!pDict || !pDict->GetObjectFor("Linearized"))
     return FALSE;
 
-  CPDF_Object* pLen = pDict->GetObjectBy("L");
+  CPDF_Object* pLen = pDict->GetObjectFor("L");
   if (!pLen)
     return FALSE;
 
   if ((FX_FILESIZE)pLen->GetInteger() != m_pFileRead->GetSize())
     return FALSE;
 
   m_bLinearized = TRUE;
 
-  if (CPDF_Number* pNo = ToNumber(pDict->GetObjectBy("P")))
+  if (CPDF_Number* pNo = ToNumber(pDict->GetObjectFor("P")))
     m_dwFirstPageNo = pNo->GetInteger();
 
   return TRUE;
 }
 
 FX_BOOL CPDF_DataAvail::CheckEnd(DownloadHints* pHints) {
   uint32_t req_pos = (uint32_t)(m_dwFileLen > 1024 ? m_dwFileLen - 1024 : 0);
   uint32_t dwSize = (uint32_t)(m_dwFileLen - req_pos);
 
   if (m_pFileAvail->IsDataAvail(req_pos, dwSize)) {
@@ skipping 56 matching lines @@
       return -1;
 
     uint32_t objNum = FXSYS_atoui(objnum.c_str());
     CPDF_Object* pObj = m_parser.ParseIndirectObjectAt(nullptr, 0, objNum);
     if (!pObj) {
       m_Pos += m_parser.m_pSyntax->SavePos();
       return 0;
     }
 
     CPDF_Dictionary* pDict = pObj->GetDict();
-    CPDF_Name* pName = ToName(pDict ? pDict->GetObjectBy("Type") : nullptr);
+    CPDF_Name* pName = ToName(pDict ? pDict->GetObjectFor("Type") : nullptr);
     if (pName) {
       if (pName->GetString() == "XRef") {
         m_Pos += m_parser.m_pSyntax->SavePos();
-        xref_offset = pObj->GetDict()->GetIntegerBy("Prev");
+        xref_offset = pObj->GetDict()->GetIntegerFor("Prev");
         pObj->Release();
         return 1;
       }
     }
     pObj->Release();
     return -1;
   }
   pHints->AddSegment(m_Pos, req_size);
   return 0;
 }
@@ skipping 222 matching lines @@
     if (!pTrailer) {
       m_Pos += m_syntaxParser.SavePos();
       pHints->AddSegment(m_Pos, iTrailerSize);
       return FALSE;
     }
 
     if (!pTrailer->IsDictionary())
       return FALSE;
 
     CPDF_Dictionary* pTrailerDict = pTrailer->GetDict();
-    CPDF_Object* pEncrypt = pTrailerDict->GetObjectBy("Encrypt");
+    CPDF_Object* pEncrypt = pTrailerDict->GetObjectFor("Encrypt");
     if (ToReference(pEncrypt)) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return TRUE;
     }
 
     uint32_t xrefpos = GetDirectInteger(pTrailerDict, "Prev");
     if (xrefpos) {
       m_dwPrevXRefOffset = GetDirectInteger(pTrailerDict, "XRefStm");
       if (m_dwPrevXRefOffset) {
         m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
@@ skipping 102 matching lines @@
   }
 
   if (!pPage->IsDictionary()) {
     pPage->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   pPageNode->m_dwPageNo = dwPageNo;
   CPDF_Dictionary* pDict = pPage->GetDict();
-  CFX_ByteString type = pDict->GetStringBy("Type");
+  CFX_ByteString type = pDict->GetStringFor("Type");
   if (type == "Pages") {
     pPageNode->m_type = PDF_PAGENODE_PAGES;
-    CPDF_Object* pKids = pDict->GetObjectBy("Kids");
+    CPDF_Object* pKids = pDict->GetObjectFor("Kids");
     if (!pKids) {
       m_docStatus = PDF_DATAAVAIL_PAGE;
       return TRUE;
     }
 
     switch (pKids->GetType()) {
       case CPDF_Object::REFERENCE: {
         CPDF_Reference* pKid = pKids->AsReference();
         PageNode* pNode = new PageNode();
         pPageNode->m_childNode.Add(pNode);
@@ skipping 112 matching lines @@
     pPages->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   if (!pPagesDict->KeyExist("Kids")) {
     pPages->Release();
     return TRUE;
   }
 
-  int count = pPagesDict->GetIntegerBy("Count");
+  int count = pPagesDict->GetIntegerFor("Count");
   if (count > 0) {
     pPages->Release();
     return TRUE;
   }
 
   pPages->Release();
   return FALSE;
 }
 
 FX_BOOL CPDF_DataAvail::LoadDocPages(DownloadHints* pHints) {
@@ skipping 59 matching lines @@
                                         DownloadHints* pHints) {
   if (!m_objs_array.GetSize()) {
     m_objs_array.RemoveAll();
     m_ObjectSet.clear();
 
     FX_SAFE_INT32 safePage = pdfium::base::checked_cast<int32_t>(dwPage);
     CPDF_Dictionary* pPageDict = m_pDocument->GetPage(safePage.ValueOrDie());
     if (!pPageDict)
       return TRUE;
 
-    CPDF_Object* pAnnots = pPageDict->GetObjectBy("Annots");
+    CPDF_Object* pAnnots = pPageDict->GetObjectFor("Annots");
     if (!pAnnots)
       return TRUE;
 
     CFX_ArrayTemplate<CPDF_Object*> obj_array;
     obj_array.Add(pAnnots);
 
     FX_BOOL bRet = IsObjectsAvail(obj_array, FALSE, pHints, m_objs_array);
     if (bRet)
       m_objs_array.RemoveAll();
 
@@ skipping 22 matching lines @@
   if (nRet == DataAvailable)
     m_bPageLoadedOK = FALSE;
   return nRet;
 }
 
 FX_BOOL CPDF_DataAvail::HaveResourceAncestor(CPDF_Dictionary* pDict) {
   CFX_AutoRestorer<int> restorer(&s_CurrentDataAvailRecursionDepth);
   if (++s_CurrentDataAvailRecursionDepth > kMaxDataAvailRecursionDepth)
     return FALSE;
 
-  CPDF_Object* pParent = pDict->GetObjectBy("Parent");
+  CPDF_Object* pParent = pDict->GetObjectFor("Parent");
   if (!pParent)
     return FALSE;
 
   CPDF_Dictionary* pParentDict = pParent->GetDict();
   if (!pParentDict)
     return FALSE;
 
-  CPDF_Object* pRet = pParentDict->GetObjectBy("Resources");
+  CPDF_Object* pRet = pParentDict->GetObjectFor("Resources");
   if (pRet) {
     m_pPageResource = pRet;
     return TRUE;
   }
 
   return HaveResourceAncestor(pParentDict);
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsPageAvail(
     uint32_t dwPage,
@@ skipping 94 matching lines @@
     m_bPageLoadedOK = TRUE;
   }
 
   if (!m_bAnnotsLoad) {
     if (!CheckPageAnnots(dwPage, pHints))
       return DataNotAvailable;
     m_bAnnotsLoad = TRUE;
   }
 
   if (m_pPageDict && !m_bNeedDownLoadResource) {
-    m_pPageResource = m_pPageDict->GetObjectBy("Resources");
+    m_pPageResource = m_pPageDict->GetObjectFor("Resources");
     m_bNeedDownLoadResource =
         m_pPageResource || HaveResourceAncestor(m_pPageDict);
   }
 
   if (m_bNeedDownLoadResource) {
     if (!CheckResources(pHints))
       return DataNotAvailable;
     m_bNeedDownLoadResource = FALSE;
   }
 
@@ skipping 30 matching lines @@
                                                uint32_t* pSize) {
   if (pPos)
     *pPos = m_dwLastXRefOffset;
   if (pSize)
     *pSize = (uint32_t)(m_dwFileLen - m_dwLastXRefOffset);
 }
 
 int CPDF_DataAvail::GetPageCount() const {
   if (m_pLinearized) {
     CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-    CPDF_Object* pObj = pDict ? pDict->GetDirectObjectBy("N") : nullptr;
+    CPDF_Object* pObj = pDict ? pDict->GetDirectObjectFor("N") : nullptr;
     return pObj ? pObj->GetInteger() : 0;
   }
   return m_pDocument ? m_pDocument->GetPageCount() : 0;
 }
 
 CPDF_Dictionary* CPDF_DataAvail::GetPage(int index) {
   if (!m_pDocument || index < 0 || index >= GetPageCount())
     return nullptr;
 
   if (m_pLinearized) {
     CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-    CPDF_Object* pObj = pDict ? pDict->GetDirectObjectBy("P") : nullptr;
+    CPDF_Object* pObj = pDict ? pDict->GetDirectObjectFor("P") : nullptr;
 
     int pageNum = pObj ? pObj->GetInteger() : 0;
     if (m_pHintTables && index != pageNum) {
       FX_FILESIZE szPageStartPos = 0;
       FX_FILESIZE szPageLength = 0;
       uint32_t dwObjNum = 0;
       bool bPagePosGot = m_pHintTables->GetPagePos(index, &szPageStartPos,
                                                    &szPageLength, &dwObjNum);
       if (!bPagePosGot)
         return nullptr;
@@ skipping 16 matching lines @@
 CPDF_DataAvail::DocFormStatus CPDF_DataAvail::IsFormAvail(
     DownloadHints* pHints) {
   if (!m_pDocument)
     return FormAvailable;
 
   if (!m_bLinearizedFormParamLoad) {
     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
     if (!pRoot)
       return FormAvailable;
 
-    CPDF_Object* pAcroForm = pRoot->GetObjectBy("AcroForm");
+    CPDF_Object* pAcroForm = pRoot->GetObjectFor("AcroForm");
     if (!pAcroForm)
       return FormNotExist;
 
     DocAvailStatus nDocStatus = CheckLinearizedData(pHints);
     if (nDocStatus == DataError)
       return FormError;
     if (nDocStatus == DataNotAvailable)
       return FormNotAvailable;
 
     if (!m_objs_array.GetSize())
@@ skipping 11 matching lines @@
   return FormAvailable;
 }
 
 CPDF_DataAvail::PageNode::PageNode() : m_type(PDF_PAGENODE_UNKNOWN) {}
 
 CPDF_DataAvail::PageNode::~PageNode() {
   for (int32_t i = 0; i < m_childNode.GetSize(); ++i)
     delete m_childNode[i];
   m_childNode.RemoveAll();
 }