Member function name refactoring

core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.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/fpdfapi/fpdf_parser.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 52 matching lines @@
 }
 
 FX_DWORD GetVarInt(const uint8_t* p, int32_t n) {
   FX_DWORD result = 0;
   for (int32_t i = 0; i < n; ++i)
     result = result * 256 + p[i];
   return result;
 }
 
 int32_t GetStreamNCount(CPDF_StreamAcc* pObjStream) {
-  return pObjStream->GetDict()->GetInteger("N");
+  return pObjStream->GetDict()->GetIntegerBy("N");
 }
 
 int32_t GetStreamFirst(CPDF_StreamAcc* pObjStream) {
-  return pObjStream->GetDict()->GetInteger("First");
+  return pObjStream->GetDict()->GetIntegerBy("First");
 }
 
 bool CanReadFromBitStream(const CFX_BitStream* hStream,
                           const FX_SAFE_DWORD& num_bits) {
   return (num_bits.IsValid() &&
           hStream->BitsRemaining() >= num_bits.ValueOrDie());
 }
 
 }  // namespace
 
@@ skipping 219 matching lines @@
     if (!m_pSecurityHandler->OnInit(this, m_pEncryptDict)) {
       return HANDLER_ERROR;
     }
     std::unique_ptr<CPDF_CryptoHandler> pCryptoHandler(
         m_pSecurityHandler->CreateCryptoHandler());
     if (!pCryptoHandler->Init(m_pEncryptDict, m_pSecurityHandler.get())) {
       return HANDLER_ERROR;
     }
     m_Syntax.SetEncrypt(pCryptoHandler.release());
   } else if (m_pEncryptDict) {
-    CFX_ByteString filter = m_pEncryptDict->GetString("Filter");
+    CFX_ByteString filter = m_pEncryptDict->GetStringBy("Filter");
     std::unique_ptr<CPDF_SecurityHandler> pSecurityHandler;
     Error err = HANDLER_ERROR;
     if (filter == "Standard") {
       pSecurityHandler.reset(FPDF_CreateStandardSecurityHandler());
       err = PASSWORD_ERROR;
     }
     if (!pSecurityHandler) {
       return HANDLER_ERROR;
     }
     if (!pSecurityHandler->OnInit(this, m_pEncryptDict)) {
@@ skipping 61 matching lines @@
       return FALSE;
     seen_xrefpos.insert(xrefpos);
     CrossRefList.InsertAt(0, xrefpos);
     LoadCrossRefV4(xrefpos, 0, TRUE);
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         LoadTrailerV4());
     if (!pDict)
       return FALSE;
     xrefpos = GetDirectInteger(pDict.get(), "Prev");
 
-    XRefStreamList.InsertAt(0, pDict->GetInteger("XRefStm"));
+    XRefStreamList.InsertAt(0, pDict->GetIntegerBy("XRefStm"));
     m_Trailers.Add(pDict.release());
   }
   for (int32_t i = 0; i < CrossRefList.GetSize(); i++) {
     if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE))
       return FALSE;
   }
   return TRUE;
 }
 FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos,
                                                  FX_DWORD dwObjCount) {
@@ skipping 22 matching lines @@
     seen_xrefpos.insert(xrefpos);
     CrossRefList.InsertAt(0, xrefpos);
     LoadCrossRefV4(xrefpos, 0, TRUE);
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         LoadTrailerV4());
     if (!pDict) {
       return FALSE;
     }
     xrefpos = GetDirectInteger(pDict.get(), "Prev");
 
-    XRefStreamList.InsertAt(0, pDict->GetInteger("XRefStm"));
+    XRefStreamList.InsertAt(0, pDict->GetIntegerBy("XRefStm"));
     m_Trailers.Add(pDict.release());
   }
   for (int32_t i = 1; i < CrossRefList.GetSize(); i++)
     if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE)) {
       return FALSE;
     }
   return TRUE;
 }
 FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos,
                                               FX_DWORD dwObjCount) {
@@ skipping 330 matching lines @@
                                   CompareFileSize);
                 if (!pResult) {
                   m_SortedOffset.Add(obj_pos);
                 }
                 FX_FILESIZE obj_end = 0;
                 CPDF_Object* pObject = ParseIndirectObjectAtByStrict(
                     m_pDocument, obj_pos, objnum, &obj_end);
                 if (CPDF_Stream* pStream = ToStream(pObject)) {
                   if (CPDF_Dictionary* pDict = pStream->GetDict()) {
                     if ((pDict->KeyExist("Type")) &&
-                        (pDict->GetString("Type") == "XRef" &&
+                        (pDict->GetStringBy("Type") == "XRef" &&
                          pDict->KeyExist("Size"))) {
                       CPDF_Object* pRoot = pDict->GetElement("Root");
                       if (pRoot && pRoot->GetDict() &&
                           pRoot->GetDict()->GetElement("Pages")) {
                         if (m_pTrailer)
                           m_pTrailer->Release();
                         m_pTrailer = ToDictionary(pDict->Clone());
                         }
                       }
                   }
@@ skipping 203 matching lines @@
         pObject->Release();
     }
     if (!bInserted)
       return FALSE;
   }
 
   CPDF_Stream* pStream = pObject->AsStream();
   if (!pStream)
     return FALSE;
 
-  *pos = pStream->GetDict()->GetInteger("Prev");
-  int32_t size = pStream->GetDict()->GetInteger("Size");
+  *pos = pStream->GetDict()->GetIntegerBy("Prev");
+  int32_t size = pStream->GetDict()->GetIntegerBy("Size");
   if (size < 0) {
     pStream->Release();
     return FALSE;
   }
   if (bMainXRef) {
     m_pTrailer = ToDictionary(pStream->GetDict()->Clone());
     ShrinkObjectMap(size);
     if (m_V5Type.SetSize(size)) {
       FXSYS_memset(m_V5Type.GetData(), 0, size);
     }
   } else {
     m_Trailers.Add(ToDictionary(pStream->GetDict()->Clone()));
   }
   std::vector<std::pair<int32_t, int32_t> > arrIndex;
-  CPDF_Array* pArray = pStream->GetDict()->GetArray("Index");
+  CPDF_Array* pArray = pStream->GetDict()->GetArrayBy("Index");
   if (pArray) {
     FX_DWORD nPairSize = pArray->GetCount() / 2;
     for (FX_DWORD i = 0; i < nPairSize; i++) {
       CPDF_Object* pStartNumObj = pArray->GetElement(i * 2);
       CPDF_Object* pCountObj = pArray->GetElement(i * 2 + 1);
       if (ToNumber(pStartNumObj) && ToNumber(pCountObj)) {
         int nStartNum = pStartNumObj->GetInteger();
         int nCount = pCountObj->GetInteger();
         if (nStartNum >= 0 && nCount > 0) {
           arrIndex.push_back(std::make_pair(nStartNum, nCount));
         }
       }
     }
   }
   if (arrIndex.size() == 0) {
     arrIndex.push_back(std::make_pair(0, size));
   }
-  pArray = pStream->GetDict()->GetArray("W");
+  pArray = pStream->GetDict()->GetArrayBy("W");
   if (!pArray) {
     pStream->Release();
     return FALSE;
   }
   CFX_DWordArray WidthArray;
   FX_SAFE_DWORD dwAccWidth = 0;
   for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
-    WidthArray.Add(pArray->GetInteger(i));
+    WidthArray.Add(pArray->GetIntegerAt(i));
     dwAccWidth += WidthArray[i];
   }
   if (!dwAccWidth.IsValid() || WidthArray.GetSize() < 3) {
     pStream->Release();
     return FALSE;
   }
   FX_DWORD totalWidth = dwAccWidth.ValueOrDie();
   CPDF_StreamAcc acc;
   acc.LoadAllData(pStream);
   const uint8_t* pData = acc.GetData();
@@ skipping 410 matching lines @@
   if (!ToDictionary(pObj.get()))
     return nullptr;
   return pObj.release()->AsDictionary();
 }
 
 FX_DWORD CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision) {
   if (!m_pSecurityHandler) {
     return (FX_DWORD)-1;
   }
   FX_DWORD dwPermission = m_pSecurityHandler->GetPermissions();
-  if (m_pEncryptDict && m_pEncryptDict->GetString("Filter") == "Standard") {
+  if (m_pEncryptDict && m_pEncryptDict->GetStringBy("Filter") == "Standard") {
     dwPermission &= 0xFFFFFFFC;
     dwPermission |= 0xFFFFF0C0;
-    if (bCheckRevision && m_pEncryptDict->GetInteger("R") == 2) {
+    if (bCheckRevision && m_pEncryptDict->GetIntegerBy("R") == 2) {
       dwPermission &= 0xFFFFF0FF;
     }
   }
   return dwPermission;
 }
 FX_BOOL CPDF_Parser::IsOwner() {
   return !m_pSecurityHandler || m_pSecurityHandler->IsOwner();
 }
 void CPDF_Parser::SetSecurityHandler(CPDF_SecurityHandler* pSecurityHandler,
                                      FX_BOOL bForced) {
@@ skipping 1438 matching lines @@
       case CPDF_Object::ARRAY: {
         CPDF_Array* pArray = pObj->GetArray();
         for (FX_DWORD k = 0; k < pArray->GetCount(); k++) {
           new_obj_array.Add(pArray->GetElement(k));
         }
       } break;
       case CPDF_Object::STREAM:
         pObj = pObj->GetDict();
       case CPDF_Object::DICTIONARY: {
         CPDF_Dictionary* pDict = pObj->GetDict();
-        if (pDict && pDict->GetString("Type") == "Page" && !bParsePage) {
+        if (pDict && pDict->GetStringBy("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;
@@ skipping 330 matching lines @@
         for (int32_t j = 0; j < iSize; ++j) {
           if (CPDF_Reference* pRef = ToReference(pArray->GetElement(j)))
             UnavailObjList.Add(pRef->GetRefObjNum());
         }
       }
     }
     if (!pObj->IsDictionary()) {
       pObj->Release();
       continue;
     }
-    CFX_ByteString type = pObj->GetDict()->GetString("Type");
+    CFX_ByteString type = pObj->GetDict()->GetStringBy("Type");
     if (type == "Pages") {
       m_PagesArray.Add(pObj);
       continue;
     }
     pObj->Release();
   }
   m_PageObjList.RemoveAll();
   if (UnavailObjList.GetSize()) {
     m_PageObjList.Append(UnavailObjList);
     return FALSE;
@@ skipping 180 matching lines @@
   }
   if (!pDict->KeyExist("H") || !pDict->KeyExist("O") || !pDict->KeyExist("N")) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
   int nPageCount = pDict->GetElementValue("N")->GetInteger();
   if (nPageCount <= 1) {
     m_docStatus = PDF_DATAAVAIL_DONE;
     return TRUE;
   }
-  CPDF_Array* pHintStreamRange = pDict->GetArray("H");
+  CPDF_Array* pHintStreamRange = pDict->GetArrayBy("H");
   FX_FILESIZE szHSStart =
       pHintStreamRange->GetElementValue(0)
           ? pHintStreamRange->GetElementValue(0)->GetInteger()
           : 0;
   FX_FILESIZE szHSLength =
       pHintStreamRange->GetElementValue(1)
           ? pHintStreamRange->GetElementValue(1)->GetInteger()
           : 0;
   if (szHSStart < 0 || szHSLength <= 0) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
@@ skipping 160 matching lines @@
     CPDF_Object* pObj = m_parser.ParseIndirectObjectAt(nullptr, 0, objNum);
     if (!pObj) {
       m_Pos += m_parser.m_Syntax.SavePos();
       return 0;
     }
     CPDF_Dictionary* pDict = pObj->GetDict();
     CPDF_Name* pName = ToName(pDict ? pDict->GetElement("Type") : nullptr);
     if (pName) {
       if (pName->GetString() == "XRef") {
         m_Pos += m_parser.m_Syntax.SavePos();
-        xref_offset = pObj->GetDict()->GetInteger("Prev");
+        xref_offset = pObj->GetDict()->GetIntegerBy("Prev");
         pObj->Release();
         return 1;
       }
     }
     pObj->Release();
     return -1;
   }
   pHints->AddSegment(m_Pos, req_size);
   return 0;
 }
@@ skipping 329 matching lines @@
     pPage->Release();
     return TRUE;
   }
   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->GetString("Type");
+  CFX_ByteString type = pDict->GetStringBy("Type");
   if (type == "Pages") {
     pPageNode->m_type = PDF_PAGENODE_PAGES;
     CPDF_Object* pKids = pDict->GetElement("Kids");
     if (!pKids) {
       m_docStatus = PDF_DATAAVAIL_PAGE;
       return TRUE;
     }
     switch (pKids->GetType()) {
       case CPDF_Object::REFERENCE: {
         CPDF_Reference* pKid = pKids->AsReference();
@@ skipping 106 matching lines @@
   CPDF_Dictionary* pPagesDict = pPages->GetDict();
   if (!pPagesDict) {
     pPages->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
   if (!pPagesDict->KeyExist("Kids")) {
     pPages->Release();
     return TRUE;
   }
-  int count = pPagesDict->GetInteger("Count");
+  int count = pPagesDict->GetIntegerBy("Count");
   if (count > 0) {
     pPages->Release();
     return TRUE;
   }
   pPages->Release();
   return FALSE;
 }
 FX_BOOL CPDF_DataAvail::LoadDocPages(IFX_DownloadHints* pHints) {
   if (!CheckUnkownPageNode(m_PagesObjNum, &m_pageNodes, pHints)) {
     return FALSE;
@@ skipping 695 matching lines @@
   CFX_BitStream bs;
   bs.Init(acc.GetData(), size);
   return ReadPageHintTable(&bs) &&
          ReadSharedObjHintTable(&bs, pdfium::base::checked_cast<FX_DWORD>(
                                          shared_hint_table_offset));
 }
 
 int CPDF_HintTables::ReadPrimaryHintStreamOffset() const {
   if (!m_pLinearizedDict)
     return -1;
-  CPDF_Array* pRange = m_pLinearizedDict->GetArray("H");
+  CPDF_Array* pRange = m_pLinearizedDict->GetArrayBy("H");
   if (!pRange)
     return -1;
   CPDF_Object* pStreamOffset = pRange->GetElementValue(0);
   if (!pStreamOffset)
     return -1;
   return pStreamOffset->GetInteger();
 }
 int CPDF_HintTables::ReadPrimaryHintStreamLength() const {
   if (!m_pLinearizedDict)
     return -1;
-  CPDF_Array* pRange = m_pLinearizedDict->GetArray("H");
+  CPDF_Array* pRange = m_pLinearizedDict->GetArrayBy("H");
   if (!pRange)
     return -1;
   CPDF_Object* pStreamLen = pRange->GetElementValue(1);
   if (!pStreamLen)
     return -1;
   return pStreamLen->GetInteger();
 }