Rename dictionary set and get methods

core/fpdfapi/fpdf_parser/cpdf_parser.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_parser.h"
 
 #include <vector>
 
@@ skipping 19 matching lines @@
 const int32_t kMaxXRefSize = 1048576;
 
 uint32_t GetVarInt(const uint8_t* p, int32_t n) {
   uint32_t 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()->GetIntegerBy("N");
+  return pObjStream->GetDict()->GetIntegerFor("N");
 }
 
 int32_t GetStreamFirst(CPDF_StreamAcc* pObjStream) {
-  return pObjStream->GetDict()->GetIntegerBy("First");
+  return pObjStream->GetDict()->GetIntegerFor("First");
 }
 
 }  // namespace
 
 CPDF_Parser::CPDF_Parser()
     : m_pDocument(nullptr),
       m_bHasParsed(false),
       m_bOwnFileRead(true),
       m_FileVersion(0),
       m_pTrailer(nullptr),
@@ skipping 169 matching lines @@
     ReleaseEncryptHandler();
     if (!RebuildCrossRef() || GetRootObjNum() == 0)
       return FORMAT_ERROR;
 
     eRet = SetEncryptHandler();
     if (eRet != SUCCESS)
       return eRet;
   }
   if (m_pSecurityHandler && !m_pSecurityHandler->IsMetadataEncrypted()) {
     CPDF_Reference* pMetadata =
-        ToReference(m_pDocument->GetRoot()->GetObjectBy("Metadata"));
+        ToReference(m_pDocument->GetRoot()->GetObjectFor("Metadata"));
     if (pMetadata)
       m_pSyntax->m_MetadataObjnum = pMetadata->GetRefObjNum();
   }
   return SUCCESS;
 }
 CPDF_Parser::Error CPDF_Parser::SetEncryptHandler() {
   ReleaseEncryptHandler();
   SetEncryptDictionary(nullptr);
 
   if (!m_pTrailer)
     return FORMAT_ERROR;
 
-  CPDF_Object* pEncryptObj = m_pTrailer->GetObjectBy("Encrypt");
+  CPDF_Object* pEncryptObj = m_pTrailer->GetObjectFor("Encrypt");
   if (pEncryptObj) {
     if (CPDF_Dictionary* pEncryptDict = pEncryptObj->AsDictionary()) {
       SetEncryptDictionary(pEncryptDict);
     } else if (CPDF_Reference* pRef = pEncryptObj->AsReference()) {
       pEncryptObj = m_pDocument->GetOrParseIndirectObject(pRef->GetRefObjNum());
       if (pEncryptObj)
         SetEncryptDictionary(pEncryptObj->GetDict());
     }
   }
 
   if (m_pEncryptDict) {
-    CFX_ByteString filter = m_pEncryptDict->GetStringBy("Filter");
+    CFX_ByteString filter = m_pEncryptDict->GetStringFor("Filter");
     std::unique_ptr<CPDF_SecurityHandler> pSecurityHandler;
     Error err = HANDLER_ERROR;
     if (filter == "Standard") {
       pSecurityHandler.reset(new CPDF_SecurityHandler);
       err = PASSWORD_ERROR;
     }
     if (!pSecurityHandler)
       return HANDLER_ERROR;
 
     if (!pSecurityHandler->OnInit(this, m_pEncryptDict))
@@ skipping 90 matching lines @@
 
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         LoadTrailerV4());
     if (!pDict)
       return FALSE;
 
     xrefpos = GetDirectInteger(pDict.get(), "Prev");
 
     // SLOW ...
     XRefStreamList.insert(XRefStreamList.begin(),
-                          pDict->GetIntegerBy("XRefStm"));
+                          pDict->GetIntegerFor("XRefStm"));
     m_Trailers.Add(pDict.release());
   }
 
   for (size_t i = 0; i < CrossRefList.size(); ++i) {
     if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE))
       return FALSE;
     if (i == 0 && !VerifyCrossRefV4())
       return FALSE;
   }
   return TRUE;
@@ skipping 34 matching lines @@
 
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         LoadTrailerV4());
     if (!pDict)
       return FALSE;
 
     xrefpos = GetDirectInteger(pDict.get(), "Prev");
 
     // SLOW ...
     XRefStreamList.insert(XRefStreamList.begin(),
-                          pDict->GetIntegerBy("XRefStm"));
+                          pDict->GetIntegerFor("XRefStm"));
     m_Trailers.Add(pDict.release());
   }
 
   for (size_t i = 1; i < CrossRefList.size(); ++i) {
     if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE))
       return FALSE;
   }
   return TRUE;
 }
 
@@ skipping 308 matching lines @@
               if (PDFCharIsWhitespace(byte) || PDFCharIsDelimiter(byte)) {
                 FX_FILESIZE obj_pos = start_pos - m_pSyntax->m_HeaderOffset;
                 m_SortedOffset.insert(obj_pos);
                 last_obj = start_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->GetStringBy("Type") == "XRef" &&
+                        (pDict->GetStringFor("Type") == "XRef" &&
                          pDict->KeyExist("Size"))) {
-                      CPDF_Object* pRoot = pDict->GetObjectBy("Root");
+                      CPDF_Object* pRoot = pDict->GetObjectFor("Root");
                       if (pRoot && pRoot->GetDict() &&
-                          pRoot->GetDict()->GetObjectBy("Pages")) {
+                          pRoot->GetDict()->GetObjectFor("Pages")) {
                         if (m_pTrailer)
                           m_pTrailer->Release();
                         m_pTrailer = ToDictionary(pDict->Clone());
                       }
                     }
                   }
                 }
 
                 FX_FILESIZE offset = 0;
                 m_pSyntax->RestorePos(obj_pos);
@@ skipping 43 matching lines @@
 
               CPDF_Object* pObj = m_pSyntax->GetObject(m_pDocument, 0, 0, true);
               if (pObj) {
                 if (!pObj->IsDictionary() && !pObj->AsStream()) {
                   pObj->Release();
                 } else {
                   CPDF_Stream* pStream = pObj->AsStream();
                   if (CPDF_Dictionary* pTrailer =
                           pStream ? pStream->GetDict() : pObj->AsDictionary()) {
                     if (m_pTrailer) {
-                      CPDF_Object* pRoot = pTrailer->GetObjectBy("Root");
+                      CPDF_Object* pRoot = pTrailer->GetObjectFor("Root");
                       CPDF_Reference* pRef = ToReference(pRoot);
                       if (!pRoot ||
                           (pRef && IsValidObjectNumber(pRef->GetRefObjNum()) &&
                            m_ObjectInfo[pRef->GetRefObjNum()].pos != 0)) {
                         auto it = pTrailer->begin();
                         while (it != pTrailer->end()) {
                           const CFX_ByteString& key = it->first;
                           CPDF_Object* pElement = it->second;
                           ++it;
                           uint32_t dwObjNum =
                               pElement ? pElement->GetObjNum() : 0;
                           if (dwObjNum) {
-                            m_pTrailer->SetAtReference(key, m_pDocument,
-                                                       dwObjNum);
+                            m_pTrailer->SetReferenceFor(key, m_pDocument,
+                                                        dwObjNum);
                           } else {
-                            m_pTrailer->SetAt(key, pElement->Clone());
+                            m_pTrailer->SetFor(key, pElement->Clone());
                           }
                         }
                       }
                       pObj->Release();
                     } else {
                       if (pObj->IsStream()) {
                         m_pTrailer = ToDictionary(pTrailer->Clone());
                         pObj->Release();
                       } else {
                         m_pTrailer = pTrailer;
@@ skipping 124 matching lines @@
                                                               pObject)) {
       return FALSE;
     }
   }
 
   CPDF_Stream* pStream = pObject->AsStream();
   if (!pStream)
     return FALSE;
 
   CPDF_Dictionary* pDict = pStream->GetDict();
-  *pos = pDict->GetIntegerBy("Prev");
-  int32_t size = pDict->GetIntegerBy("Size");
+  *pos = pDict->GetIntegerFor("Prev");
+  int32_t size = pDict->GetIntegerFor("Size");
   if (size < 0) {
     pStream->Release();
     return FALSE;
   }
 
   CPDF_Dictionary* pNewTrailer = ToDictionary(pDict->Clone());
   if (bMainXRef) {
     m_pTrailer = pNewTrailer;
     ShrinkObjectMap(size);
     for (auto& it : m_ObjectInfo)
       it.second.type = 0;
   } else {
     m_Trailers.Add(pNewTrailer);
   }
 
   std::vector<std::pair<int32_t, int32_t>> arrIndex;
-  CPDF_Array* pArray = pDict->GetArrayBy("Index");
+  CPDF_Array* pArray = pDict->GetArrayFor("Index");
   if (pArray) {
     for (size_t i = 0; i < pArray->GetCount() / 2; i++) {
       CPDF_Object* pStartNumObj = pArray->GetObjectAt(i * 2);
       CPDF_Object* pCountObj = pArray->GetObjectAt(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 = pDict->GetArrayBy("W");
+  pArray = pDict->GetArrayFor("W");
   if (!pArray) {
     pStream->Release();
     return FALSE;
   }
 
   CFX_ArrayTemplate<uint32_t> WidthArray;
   FX_SAFE_UINT32 dwAccWidth = 0;
   for (size_t i = 0; i < pArray->GetCount(); ++i) {
     WidthArray.Add(pArray->GetIntegerAt(i));
     dwAccWidth += WidthArray[i];
@@ skipping 70 matching lines @@
         }
       }
     }
     segindex += count;
   }
   pStream->Release();
   return TRUE;
 }
 
 CPDF_Array* CPDF_Parser::GetIDArray() {
-  CPDF_Object* pID = m_pTrailer ? m_pTrailer->GetObjectBy("ID") : nullptr;
+  CPDF_Object* pID = m_pTrailer ? m_pTrailer->GetObjectFor("ID") : nullptr;
   if (!pID)
     return nullptr;
 
   if (CPDF_Reference* pRef = pID->AsReference()) {
     pID = ParseIndirectObject(nullptr, pRef->GetRefObjNum());
-    m_pTrailer->SetAt("ID", pID);
+    m_pTrailer->SetFor("ID", pID);
   }
   return ToArray(pID);
 }
 
 uint32_t CPDF_Parser::GetRootObjNum() {
   CPDF_Reference* pRef =
-      ToReference(m_pTrailer ? m_pTrailer->GetObjectBy("Root") : nullptr);
+      ToReference(m_pTrailer ? m_pTrailer->GetObjectFor("Root") : nullptr);
   return pRef ? pRef->GetRefObjNum() : 0;
 }
 
 uint32_t CPDF_Parser::GetInfoObjNum() {
   CPDF_Reference* pRef =
-      ToReference(m_pTrailer ? m_pTrailer->GetObjectBy("Info") : nullptr);
+      ToReference(m_pTrailer ? m_pTrailer->GetObjectFor("Info") : nullptr);
   return pRef ? pRef->GetRefObjNum() : 0;
 }
 
 FX_BOOL CPDF_Parser::IsFormStream(uint32_t objnum, FX_BOOL& bForm) {
   bForm = FALSE;
   if (!IsValidObjectNumber(objnum))
     return TRUE;
 
   if (GetObjectType(objnum) == 0)
     return TRUE;
@@ skipping 299 matching lines @@
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
   uint32_t gennum = FXSYS_atoui(word.c_str());
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
-  CPDF_Object* pObj = m_pSyntax->GetObjectByStrict(pObjList, objnum, gennum);
+  CPDF_Object* pObj = m_pSyntax->GetObjectForStrict(pObjList, objnum, gennum);
   if (pResultPos)
     *pResultPos = m_pSyntax->m_Pos;
 
   m_pSyntax->RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() {
   if (m_pSyntax->GetKeyword() != "trailer")
     return nullptr;
 
   std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
       m_pSyntax->GetObject(m_pDocument, 0, 0, true));
   if (!ToDictionary(pObj.get()))
     return nullptr;
   return pObj.release()->AsDictionary();
 }
 
 uint32_t CPDF_Parser::GetPermissions() const {
   if (!m_pSecurityHandler)
     return 0xFFFFFFFF;
 
   uint32_t dwPermission = m_pSecurityHandler->GetPermissions();
-  if (m_pEncryptDict && m_pEncryptDict->GetStringBy("Filter") == "Standard") {
+  if (m_pEncryptDict && m_pEncryptDict->GetStringFor("Filter") == "Standard") {
     // See PDF Reference 1.7, page 123, table 3.20.
     dwPermission &= 0xFFFFFFFC;
     dwPermission |= 0xFFFFF0C0;
   }
   return dwPermission;
 }
 
 FX_BOOL CPDF_Parser::IsLinearizedFile(IFX_FileRead* pFileAccess,
                                       uint32_t offset) {
   m_pSyntax->InitParser(pFileAccess, offset);
@@ skipping 14 matching lines @@
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
     return FALSE;
   }
 
   m_pLinearized = m_pSyntax->GetObject(nullptr, objnum, gennum, true);
   if (!m_pLinearized)
     return FALSE;
 
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-  if (pDict && pDict->GetObjectBy("Linearized")) {
+  if (pDict && pDict->GetObjectFor("Linearized")) {
     m_pSyntax->GetNextWord(nullptr);
 
-    CPDF_Object* pLen = pDict->GetObjectBy("L");
+    CPDF_Object* pLen = pDict->GetObjectFor("L");
     if (!pLen) {
       m_pLinearized->Release();
       m_pLinearized = nullptr;
       return FALSE;
     }
 
     if (pLen->GetInteger() != (int)pFileAccess->GetSize())
       return FALSE;
 
-    if (CPDF_Number* pNo = ToNumber(pDict->GetObjectBy("P")))
+    if (CPDF_Number* pNo = ToNumber(pDict->GetObjectFor("P")))
       m_dwFirstPageNo = pNo->GetInteger();
 
-    if (CPDF_Number* pTable = ToNumber(pDict->GetObjectBy("T")))
+    if (CPDF_Number* pTable = ToNumber(pDict->GetObjectFor("T")))
       m_LastXRefOffset = pTable->GetInteger();
 
     return TRUE;
   }
   m_pLinearized->Release();
   m_pLinearized = nullptr;
   return FALSE;
 }
 
 CPDF_Parser::Error CPDF_Parser::StartLinearizedParse(IFX_FileRead* pFileAccess,
@@ skipping 64 matching lines @@
     if (!RebuildCrossRef() || GetRootObjNum() == 0)
       return FORMAT_ERROR;
 
     eRet = SetEncryptHandler();
     if (eRet != SUCCESS)
       return eRet;
   }
 
   if (m_pSecurityHandler && m_pSecurityHandler->IsMetadataEncrypted()) {
     if (CPDF_Reference* pMetadata =
-            ToReference(m_pDocument->GetRoot()->GetObjectBy("Metadata")))
+            ToReference(m_pDocument->GetRoot()->GetObjectFor("Metadata")))
       m_pSyntax->m_MetadataObjnum = pMetadata->GetRefObjNum();
   }
   return SUCCESS;
 }
 
 FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV5(FX_FILESIZE xrefpos) {
   if (!LoadCrossRefV5(&xrefpos, FALSE))
     return FALSE;
 
   std::set<FX_FILESIZE> seen_xrefpos;
@@ skipping 38 matching lines @@
   if (!LoadLinearizedAllCrossRefV4(m_LastXRefOffset, m_dwXrefStartObjNum) &&
       !LoadLinearizedAllCrossRefV5(m_LastXRefOffset)) {
     m_LastXRefOffset = 0;
     m_pSyntax->m_MetadataObjnum = dwSaveMetadataObjnum;
     return FORMAT_ERROR;
   }
 
   m_pSyntax->m_MetadataObjnum = dwSaveMetadataObjnum;
   return SUCCESS;
 }