Rename dictionary set and get methods

core/fpdfapi/fpdf_page/fpdf_page_parser_old.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/fpdfapi/fpdf_page/pageint.h"
 
 #include <limits.h>
 
@@ skipping 103 matching lines @@
                                     dest_buf, dest_size);
   }
   if (decoder == "LZWDecode" || decoder == "LZW") {
     return FPDFAPI_FlateOrLZWDecode(TRUE, src_buf, limit, pParam, 0, dest_buf,
                                     dest_size);
   }
   if (decoder == "DCTDecode" || decoder == "DCT") {
     CCodec_ScanlineDecoder* pDecoder =
         CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
             src_buf, limit, width, height, 0,
-            pParam ? pParam->GetIntegerBy("ColorTransform", 1) : 1);
+            pParam ? pParam->GetIntegerFor("ColorTransform", 1) : 1);
     return DecodeAllScanlines(pDecoder, dest_buf, dest_size);
   }
   if (decoder == "RunLengthDecode" || decoder == "RL") {
     return RunLengthDecode(src_buf, limit, dest_buf, dest_size);
   }
   dest_size = 0;
   dest_buf = 0;
   return (uint32_t)-1;
 }
 
 CPDF_Stream* CPDF_StreamParser::ReadInlineStream(CPDF_Document* pDoc,
                                                  CPDF_Dictionary* pDict,
                                                  CPDF_Object* pCSObj) {
   if (m_Pos == m_Size)
     return nullptr;
 
   if (PDFCharIsWhitespace(m_pBuf[m_Pos]))
     m_Pos++;
 
   CFX_ByteString Decoder;
   CPDF_Dictionary* pParam = nullptr;
-  CPDF_Object* pFilter = pDict->GetDirectObjectBy("Filter");
+  CPDF_Object* pFilter = pDict->GetDirectObjectFor("Filter");
   if (pFilter) {
     if (CPDF_Array* pArray = pFilter->AsArray()) {
       Decoder = pArray->GetStringAt(0);
-      CPDF_Array* pParams = pDict->GetArrayBy("DecodeParms");
+      CPDF_Array* pParams = pDict->GetArrayFor("DecodeParms");
       if (pParams)
         pParam = pParams->GetDictAt(0);
     } else {
       Decoder = pFilter->GetString();
-      pParam = pDict->GetDictBy("DecodeParms");
+      pParam = pDict->GetDictFor("DecodeParms");
     }
   }
-  uint32_t width = pDict->GetIntegerBy("Width");
-  uint32_t height = pDict->GetIntegerBy("Height");
+  uint32_t width = pDict->GetIntegerFor("Width");
+  uint32_t height = pDict->GetIntegerFor("Height");
   uint32_t OrigSize = 0;
   if (pCSObj) {
-    uint32_t bpc = pDict->GetIntegerBy("BitsPerComponent");
+    uint32_t bpc = pDict->GetIntegerFor("BitsPerComponent");
     uint32_t nComponents = 1;
     CPDF_ColorSpace* pCS = pDoc->LoadColorSpace(pCSObj);
     if (pCS) {
       nComponents = pCS->CountComponents();
       pDoc->GetPageData()->ReleaseColorSpace(pCSObj);
     } else {
       nComponents = 3;
     }
     uint32_t pitch = width;
     if (bpc && pitch > INT_MAX / bpc)
@@ skipping 56 matching lines @@
         m_Pos = dwPrevPos;
         break;
       }
       dwStreamSize += m_Pos - dwPrevPos;
     }
     m_Pos = dwSavePos;
     pData = FX_Alloc(uint8_t, dwStreamSize);
     FXSYS_memcpy(pData, m_pBuf + m_Pos, dwStreamSize);
     m_Pos += dwStreamSize;
   }
-  pDict->SetAtInteger("Length", (int)dwStreamSize);
+  pDict->SetIntegerFor("Length", (int)dwStreamSize);
   return new CPDF_Stream(pData, dwStreamSize, pDict);
 }
 
 CPDF_StreamParser::SyntaxType CPDF_StreamParser::ParseNextElement() {
   if (m_pLastObj) {
     m_pLastObj->Release();
     m_pLastObj = nullptr;
   }
 
   m_WordSize = 0;
@@ skipping 112 matching lines @@
           PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1));
       CPDF_Object* pObj = ReadNextObject(true, 0);
       if (!pObj) {
         pDict->Release();
         return nullptr;
       }
 
       if (key.IsEmpty())
         pObj->Release();
       else
-        pDict->SetAt(key, pObj);
+        pDict->SetFor(key, pObj);
     }
     return pDict;
   }
 
   if (first_char == '[') {
     if ((!bAllowNestedArray && dwInArrayLevel) ||
         dwInArrayLevel > kMaxNestedArrayLevel) {
       return nullptr;
     }
 
@@ skipping 261 matching lines @@
       !pPage->m_pFormDict) {
     m_Status = Done;
     return;
   }
   m_pObjectHolder = pPage;
   m_bForm = FALSE;
   m_Status = ToBeContinued;
   m_InternalStage = STAGE_GETCONTENT;
   m_CurrentOffset = 0;
 
-  CPDF_Object* pContent = pPage->m_pFormDict->GetDirectObjectBy("Contents");
+  CPDF_Object* pContent = pPage->m_pFormDict->GetDirectObjectFor("Contents");
   if (!pContent) {
     m_Status = Done;
     return;
   }
   if (CPDF_Stream* pStream = pContent->AsStream()) {
     m_nStreams = 0;
     m_pSingleStream.reset(new CPDF_StreamAcc);
     m_pSingleStream->LoadAllData(pStream, FALSE);
   } else if (CPDF_Array* pArray = pContent->AsArray()) {
     m_nStreams = pArray->GetCount();
     if (m_nStreams)
       m_StreamArray.resize(m_nStreams);
     else
       m_Status = Done;
   } else {
     m_Status = Done;
   }
 }
 
 void CPDF_ContentParser::Start(CPDF_Form* pForm,
                                CPDF_AllStates* pGraphicStates,
                                const CFX_Matrix* pParentMatrix,
                                CPDF_Type3Char* pType3Char,
                                int level) {
   m_pType3Char = pType3Char;
   m_pObjectHolder = pForm;
   m_bForm = TRUE;
-  CFX_Matrix form_matrix = pForm->m_pFormDict->GetMatrixBy("Matrix");
+  CFX_Matrix form_matrix = pForm->m_pFormDict->GetMatrixFor("Matrix");
   if (pGraphicStates) {
     form_matrix.Concat(pGraphicStates->m_CTM);
   }
-  CPDF_Array* pBBox = pForm->m_pFormDict->GetArrayBy("BBox");
+  CPDF_Array* pBBox = pForm->m_pFormDict->GetArrayFor("BBox");
   CFX_FloatRect form_bbox;
   CPDF_Path ClipPath;
   if (pBBox) {
     form_bbox = pBBox->GetRect();
     ClipPath.Emplace();
     ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right,
                         form_bbox.top);
     ClipPath.Transform(&form_matrix);
     if (pParentMatrix) {
       ClipPath.Transform(pParentMatrix);
     }
     form_bbox.Transform(&form_matrix);
     if (pParentMatrix) {
       form_bbox.Transform(pParentMatrix);
     }
   }
-  CPDF_Dictionary* pResources = pForm->m_pFormDict->GetDictBy("Resources");
+  CPDF_Dictionary* pResources = pForm->m_pFormDict->GetDictFor("Resources");
   m_pParser.reset(new CPDF_StreamContentParser(
       pForm->m_pDocument, pForm->m_pPageResources, pForm->m_pResources,
       pParentMatrix, pForm, pResources, &form_bbox, pGraphicStates, level));
   m_pParser->GetCurStates()->m_CTM = form_matrix;
   m_pParser->GetCurStates()->m_ParentMatrix = form_matrix;
   if (ClipPath) {
     m_pParser->GetCurStates()->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING,
                                                      TRUE);
   }
   if (pForm->m_Transparency & PDFTRANS_GROUP) {
@@ skipping 38 matching lines @@
           }
           m_StreamArray.clear();
         } else {
           m_pData = (uint8_t*)m_pSingleStream->GetData();
           m_Size = m_pSingleStream->GetSize();
         }
         m_InternalStage = STAGE_PARSE;
         m_CurrentOffset = 0;
       } else {
         CPDF_Array* pContent =
-            m_pObjectHolder->m_pFormDict->GetArrayBy("Contents");
+            m_pObjectHolder->m_pFormDict->GetArrayFor("Contents");
         m_StreamArray[m_CurrentOffset].reset(new CPDF_StreamAcc);
         CPDF_Stream* pStreamObj = ToStream(
             pContent ? pContent->GetDirectObjectAt(m_CurrentOffset) : nullptr);
         m_StreamArray[m_CurrentOffset]->LoadAllData(pStreamObj, FALSE);
         m_CurrentOffset++;
       }
     }
     if (m_InternalStage == STAGE_PARSE) {
       if (!m_pParser) {
         m_pParser.reset(new CPDF_StreamContentParser(
@@ skipping 44 matching lines @@
       }
       m_Status = Done;
       return;
     }
     steps++;
     if (pPause && pPause->NeedToPauseNow()) {
       break;
     }
   }
 }