Rename GetElementValue() to GetDirectObject{By,At}().

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/ipdf_data_avail.h"
 
 #include "core/fpdfapi/fpdf_parser/cpdf_data_avail.h"
 #include "core/fpdfapi/fpdf_parser/fpdf_parser_utility.h"
@@ skipping 135 matching lines @@
   for (i = 0; i < obj_array.GetSize(); i++) {
     CPDF_Object* pObj = obj_array[i];
     if (!pObj)
       continue;
 
     int32_t type = pObj->GetType();
     switch (type) {
       case CPDF_Object::ARRAY: {
         CPDF_Array* pArray = pObj->GetArray();
         for (uint32_t k = 0; k < pArray->GetCount(); ++k)
-          new_obj_array.Add(pArray->GetElement(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)
           continue;
 
         for (const auto& it : *pDict) {
           const CFX_ByteString& key = it.first;
@@ skipping 277 matching lines @@
     }
     return FALSE;
   }
 
   CPDF_Dictionary* pDict = m_pRoot->GetDict();
   if (!pDict) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  CPDF_Reference* pRef = ToReference(pDict->GetElement("Pages"));
+  CPDF_Reference* pRef = ToReference(pDict->GetObjectBy("Pages"));
   if (!pRef) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   m_PagesObjNum = pRef->GetRefObjNum();
   CPDF_Reference* pAcroFormRef =
-      ToReference(m_pRoot->GetDict()->GetElement("AcroForm"));
+      ToReference(m_pRoot->GetDict()->GetObjectBy("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->GetElement("Pages") : nullptr);
+      ToReference(pRoot ? pRoot->GetObjectBy("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 17 matching lines @@
       if (bExist)
         UnavailObjList.Add(dwPageObjNum);
       continue;
     }
 
     if (pObj->IsArray()) {
       CPDF_Array* pArray = pObj->GetArray();
       if (pArray) {
         int32_t iSize = pArray->GetCount();
         for (int32_t j = 0; j < iSize; ++j) {
-          if (CPDF_Reference* pRef = ToReference(pArray->GetElement(j)))
+          if (CPDF_Reference* pRef = ToReference(pArray->GetObjectAt(j)))
             UnavailObjList.Add(pRef->GetRefObjNum());
         }
       }
     }
 
     if (!pObj->IsDictionary()) {
       pObj->Release();
       continue;
     }
 
@@ skipping 37 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->GetElement("Kids") : NULL;
+  CPDF_Object* pKids = pDict ? pDict->GetObjectBy("Kids") : NULL;
   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 (uint32_t i = 0; i < pKidsArray->GetCount(); ++i) {
-        if (CPDF_Reference* pRef = ToReference(pKidsArray->GetElement(i)))
+        if (CPDF_Reference* pRef = ToReference(pKidsArray->GetObjectAt(i)))
           m_PageObjList.Add(pRef->GetRefObjNum());
       }
     } break;
     default:
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return FALSE;
   }
   return TRUE;
 }
 
@@ skipping 42 matching lines @@
     }
     return TRUE;
   }
 
   pHints->AddSegment(0, req_size);
   return FALSE;
 }
 
 FX_BOOL CPDF_DataAvail::CheckFirstPage(IPDF_DataAvail::DownloadHints* pHints) {
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-  CPDF_Object* pEndOffSet = pDict ? pDict->GetElement("E") : NULL;
+  CPDF_Object* pEndOffSet = pDict ? pDict->GetObjectBy("E") : NULL;
   if (!pEndOffSet) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  CPDF_Object* pXRefOffset = pDict ? pDict->GetElement("T") : NULL;
+  CPDF_Object* pXRefOffset = pDict ? pDict->GetObjectBy("T") : NULL;
   if (!pXRefOffset) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  CPDF_Object* pFileLen = pDict ? pDict->GetElement("L") : NULL;
+  CPDF_Object* pFileLen = pDict ? pDict->GetObjectBy("L") : NULL;
   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 66 matching lines @@
   if (!pDict) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   if (!pDict->KeyExist("H") || !pDict->KeyExist("O") || !pDict->KeyExist("N")) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  int nPageCount = pDict->GetElementValue("N")->GetInteger();
+  int nPageCount = pDict->GetDirectObjectBy("N")->GetInteger();
   if (nPageCount <= 1) {
     m_docStatus = PDF_DATAAVAIL_DONE;
     return TRUE;
   }
 
   CPDF_Array* pHintStreamRange = pDict->GetArrayBy("H");
   FX_FILESIZE szHSStart =
-      pHintStreamRange->GetElementValue(0)
-          ? pHintStreamRange->GetElementValue(0)->GetInteger()
+      pHintStreamRange->GetDirectObjectAt(0)
+          ? pHintStreamRange->GetDirectObjectAt(0)->GetInteger()
           : 0;
   FX_FILESIZE szHSLength =
-      pHintStreamRange->GetElementValue(1)
-          ? pHintStreamRange->GetElementValue(1)->GetInteger()
+      pHintStreamRange->GetDirectObjectAt(1)
+          ? pHintStreamRange->GetDirectObjectAt(1)->GetInteger()
           : 0;
   if (szHSStart < 0 || szHSLength <= 0) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   if (!IsDataAvail(szHSStart, szHSLength, pHints))
     return FALSE;
 
   m_syntaxParser.InitParser(m_pFileRead, m_dwHeaderOffset);
@@ skipping 84 matching lines @@
     m_pLinearized->Release();
     m_pLinearized = nullptr;
   }
 
   m_pLinearized =
       ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum);
   if (!m_pLinearized)
     return FALSE;
 
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-  if (pDict && pDict->GetElement("Linearized")) {
-    CPDF_Object* pLen = pDict->GetElement("L");
+  if (pDict && pDict->GetObjectBy("Linearized")) {
+    CPDF_Object* pLen = pDict->GetObjectBy("L");
     if (!pLen)
       return FALSE;
 
     if ((FX_FILESIZE)pLen->GetInteger() != m_pFileRead->GetSize())
       return FALSE;
 
     m_bLinearized = TRUE;
 
-    if (CPDF_Number* pNo = ToNumber(pDict->GetElement("P")))
+    if (CPDF_Number* pNo = ToNumber(pDict->GetObjectBy("P")))
       m_dwFirstPageNo = pNo->GetInteger();
 
     return TRUE;
   }
   return FALSE;
 }
 
 FX_BOOL CPDF_DataAvail::CheckEnd(IPDF_DataAvail::DownloadHints* pHints) {
   uint32_t req_pos = (uint32_t)(m_dwFileLen > 1024 ? m_dwFileLen - 1024 : 0);
   uint32_t dwSize = (uint32_t)(m_dwFileLen - req_pos);
@@ skipping 59 matching lines @@
       return -1;
 
     uint32_t objNum = FXSYS_atoui(objnum);
     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->GetElement("Type") : nullptr);
+    CPDF_Name* pName = ToName(pDict ? pDict->GetObjectBy("Type") : nullptr);
     if (pName) {
       if (pName->GetString() == "XRef") {
         m_Pos += m_parser.m_pSyntax->SavePos();
         xref_offset = pObj->GetDict()->GetIntegerBy("Prev");
         pObj->Release();
         return 1;
       }
     }
     pObj->Release();
     return -1;
@@ skipping 229 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->GetElement("Encrypt");
+    CPDF_Object* pEncrypt = pTrailerDict->GetObjectBy("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 61 matching lines @@
 
   CPDF_Array* pArray = pPages->AsArray();
   if (!pArray) {
     pPages->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   pPageNode->m_type = PDF_PAGENODE_PAGES;
   for (uint32_t i = 0; i < pArray->GetCount(); ++i) {
-    CPDF_Reference* pKid = ToReference(pArray->GetElement(i));
+    CPDF_Reference* pKid = ToReference(pArray->GetObjectAt(i));
     if (!pKid)
       continue;
 
     PageNode* pNode = new PageNode();
     pPageNode->m_childNode.Add(pNode);
     pNode->m_dwPageNo = pKid->GetRefObjNum();
   }
   pPages->Release();
   return TRUE;
 }
@@ skipping 26 matching lines @@
     pPage->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   pPageNode->m_dwPageNo = dwPageNo;
   CPDF_Dictionary* pDict = pPage->GetDict();
   CFX_ByteString type = pDict->GetStringBy("Type");
   if (type == "Pages") {
     pPageNode->m_type = PDF_PAGENODE_PAGES;
-    CPDF_Object* pKids = pDict->GetElement("Kids");
+    CPDF_Object* pKids = pDict->GetObjectBy("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);
         pNode->m_dwPageNo = pKid->GetRefObjNum();
       } break;
       case CPDF_Object::ARRAY: {
         CPDF_Array* pKidsArray = pKids->AsArray();
         for (uint32_t i = 0; i < pKidsArray->GetCount(); ++i) {
-          CPDF_Reference* pKid = ToReference(pKidsArray->GetElement(i));
+          CPDF_Reference* pKid = ToReference(pKidsArray->GetObjectAt(i));
           if (!pKid)
             continue;
 
           PageNode* pNode = new PageNode();
           pPageNode->m_childNode.Add(pNode);
           pNode->m_dwPageNo = pKid->GetRefObjNum();
         }
       } break;
       default:
         break;
@@ skipping 174 matching lines @@
 FX_BOOL CPDF_DataAvail::CheckPageAnnots(int32_t iPage,
                                         IPDF_DataAvail::DownloadHints* pHints) {
   if (!m_objs_array.GetSize()) {
     m_objs_array.RemoveAll();
     m_ObjectSet.clear();
 
     CPDF_Dictionary* pPageDict = m_pDocument->GetPage(iPage);
     if (!pPageDict)
       return TRUE;
 
-    CPDF_Object* pAnnots = pPageDict->GetElement("Annots");
+    CPDF_Object* pAnnots = pPageDict->GetObjectBy("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->GetElement("Parent");
+  CPDF_Object* pParent = pDict->GetObjectBy("Parent");
   if (!pParent)
     return FALSE;
 
   CPDF_Dictionary* pParentDict = pParent->GetDict();
   if (!pParentDict)
     return FALSE;
 
-  CPDF_Object* pRet = pParentDict->GetElement("Resources");
+  CPDF_Object* pRet = pParentDict->GetObjectBy("Resources");
   if (pRet) {
     m_pPageResource = pRet;
     return TRUE;
   }
 
   return HaveResourceAncestor(pParentDict);
 }
 
 IPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsPageAvail(
     int32_t iPage,
@@ skipping 93 matching lines @@
     m_bPageLoadedOK = TRUE;
   }
 
   if (!m_bAnnotsLoad) {
     if (!CheckPageAnnots(iPage, pHints))
       return DataNotAvailable;
     m_bAnnotsLoad = TRUE;
   }
 
   if (m_pPageDict && !m_bNeedDownLoadResource) {
-    m_pPageResource = m_pPageDict->GetElement("Resources");
+    m_pPageResource = m_pPageDict->GetObjectBy("Resources");
     if (!m_pPageResource)
       m_bNeedDownLoadResource = HaveResourceAncestor(m_pPageDict);
     else
       m_bNeedDownLoadResource = TRUE;
   }
 
   if (m_bNeedDownLoadResource) {
     FX_BOOL bRet = CheckResources(pHints);
     if (!bRet)
       return DataNotAvailable;
@@ skipping 33 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->GetElementValue("N") : nullptr;
+    CPDF_Object* pObj = pDict ? pDict->GetDirectObjectBy("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->GetElementValue("P") : nullptr;
+    CPDF_Object* pObj = pDict ? pDict->GetDirectObjectBy("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;
       FX_BOOL bPagePosGot = m_pHintTables->GetPagePos(index, szPageStartPos,
                                                       szPageLength, dwObjNum);
       if (!bPagePosGot)
         return nullptr;
@@ skipping 14 matching lines @@
 IPDF_DataAvail::DocFormStatus CPDF_DataAvail::IsFormAvail(
     IPDF_DataAvail::DownloadHints* pHints) {
   if (!m_pDocument)
     return FormAvailable;
 
   if (!m_bLinearizedFormParamLoad) {
     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
     if (!pRoot)
       return FormAvailable;
 
-    CPDF_Object* pAcroForm = pRoot->GetElement("AcroForm");
+    CPDF_Object* pAcroForm = pRoot->GetObjectBy("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();
 }