Rename dictionary set and get methods

core/fpdfapi/fpdf_edit/fpdf_edit_create.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_edit/editint.h"
 
 #include <vector>
 
@@ skipping 408 matching lines @@
   m_Acc.LoadAllData(pStream, TRUE);
   if ((pStream && pStream->GetDict() &&
        pStream->GetDict()->KeyExist("Filter")) ||
       !bFlateEncode) {
     if (pStream->GetDict()->KeyExist("Filter") && !bFlateEncode) {
       CPDF_StreamAcc destAcc;
       destAcc.LoadAllData(pStream);
       m_dwSize = destAcc.GetSize();
       m_pData = (uint8_t*)destAcc.DetachData();
       m_pDict = ToDictionary(pStream->GetDict()->Clone());
-      m_pDict->RemoveAt("Filter");
+      m_pDict->RemoveFor("Filter");
       m_bNewData = TRUE;
       m_bCloned = TRUE;
     } else {
       m_pData = (uint8_t*)m_Acc.GetData();
       m_dwSize = m_Acc.GetSize();
       m_pDict = pStream->GetDict();
     }
     return;
   }
 
   m_bNewData = TRUE;
   m_bCloned = TRUE;
   // TODO(thestig): Move to Init() and check return value.
   ::FlateEncode(m_Acc.GetData(), m_Acc.GetSize(), &m_pData, &m_dwSize);
   m_pDict = ToDictionary(pStream->GetDict()->Clone());
-  m_pDict->SetAtInteger("Length", m_dwSize);
-  m_pDict->SetAtName("Filter", "FlateDecode");
-  m_pDict->RemoveAt("DecodeParms");
+  m_pDict->SetIntegerFor("Length", m_dwSize);
+  m_pDict->SetNameFor("Filter", "FlateDecode");
+  m_pDict->RemoveFor("DecodeParms");
 }
 
 CPDF_FlateEncoder::CPDF_FlateEncoder(const uint8_t* pBuffer,
                                      uint32_t size,
                                      bool bFlateEncode,
                                      bool bXRefStream)
     : m_pData(nullptr),
       m_dwSize(0),
       m_pDict(nullptr),
       m_bCloned(FALSE),
@@ skipping 458 matching lines @@
 
   uint32_t objnum = pObj->GetObjNum();
   if (m_pParser && m_pParser->GetObjectGenNum(objnum) > 0)
     return 1;
 
   if (pObj->IsNumber())
     return 1;
 
   CPDF_Dictionary* pDict = pObj->GetDict();
   if (pObj->IsStream()) {
-    if (pDict && pDict->GetStringBy("Type") == "XRef")
+    if (pDict && pDict->GetStringFor("Type") == "XRef")
       return 0;
     return 1;
   }
 
   if (pDict) {
     if (pDict == m_pDocument->m_pRootDict || pDict == m_pEncryptDict)
       return 1;
     if (pDict->IsSignatureDict())
       return 1;
-    if (pDict->GetStringBy("Type") == "Page")
+    if (pDict->GetStringFor("Type") == "Page")
       return 1;
   }
 
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
   if (m_pXRefStream->CompressIndirectObject(objnum, pObj, this) < 0)
     return -1;
   if (!IsXRefNeedEnd(m_pXRefStream.get(), m_dwFlags))
     return 0;
   if (!m_pXRefStream->End(this))
     return -1;
@@ skipping 39 matching lines @@
     return -1;
   }
   return 0;
 }
 int32_t CPDF_Creator::WriteStream(const CPDF_Object* pStream,
                                   uint32_t objnum,
                                   CPDF_CryptoHandler* pCrypto) {
   CPDF_FlateEncoder encoder(const_cast<CPDF_Stream*>(pStream->AsStream()),
                             pStream != m_pMetadata);
   CPDF_Encryptor encryptor(pCrypto, objnum, encoder.m_pData, encoder.m_dwSize);
-  if ((uint32_t)encoder.m_pDict->GetIntegerBy("Length") != encryptor.m_dwSize) {
+  if ((uint32_t)encoder.m_pDict->GetIntegerFor("Length") !=
+      encryptor.m_dwSize) {
     encoder.CloneDict();
-    encoder.m_pDict->SetAtInteger("Length", encryptor.m_dwSize);
+    encoder.m_pDict->SetIntegerFor("Length", encryptor.m_dwSize);
   }
   if (WriteDirectObj(objnum, encoder.m_pDict) < 0) {
     return -1;
   }
   int len = m_File.AppendString("stream\r\n");
   if (len < 0) {
     return -1;
   }
   m_Offset += len;
   if (m_File.AppendBlock(encryptor.m_pData, encryptor.m_dwSize) < 0) {
@@ skipping 89 matching lines @@
         return -1;
       }
       m_Offset += len;
       break;
     }
     case CPDF_Object::STREAM: {
       CPDF_FlateEncoder encoder(const_cast<CPDF_Stream*>(pObj->AsStream()),
                                 TRUE);
       CPDF_Encryptor encryptor(m_pCryptoHandler, objnum, encoder.m_pData,
                                encoder.m_dwSize);
-      if ((uint32_t)encoder.m_pDict->GetIntegerBy("Length") !=
+      if ((uint32_t)encoder.m_pDict->GetIntegerFor("Length") !=
           encryptor.m_dwSize) {
         encoder.CloneDict();
-        encoder.m_pDict->SetAtInteger("Length", encryptor.m_dwSize);
+        encoder.m_pDict->SetIntegerFor("Length", encryptor.m_dwSize);
       }
       if (WriteDirectObj(objnum, encoder.m_pDict) < 0) {
         return -1;
       }
       if ((len = m_File.AppendString("stream\r\n")) < 0) {
         return -1;
       }
       m_Offset += len;
       if (m_File.AppendBlock(encryptor.m_pData, encryptor.m_dwSize) < 0) {
         return -1;
@@ skipping 317 matching lines @@
 int32_t CPDF_Creator::WriteDoc_Stage1(IFX_Pause* pPause) {
   ASSERT(m_iStage > -1 || m_iStage < 20);
   if (m_iStage == 0) {
     if (!m_pParser) {
       m_dwFlags &= ~FPDFCREATE_INCREMENTAL;
     }
     if (m_bSecurityChanged && (m_dwFlags & FPDFCREATE_NO_ORIGINAL) == 0) {
       m_dwFlags &= ~FPDFCREATE_INCREMENTAL;
     }
     CPDF_Dictionary* pDict = m_pDocument->GetRoot();
-    m_pMetadata = pDict ? pDict->GetDirectObjectBy("Metadata") : nullptr;
+    m_pMetadata = pDict ? pDict->GetDirectObjectFor("Metadata") : nullptr;
     if (m_dwFlags & FPDFCREATE_OBJECTSTREAM) {
       m_pXRefStream.reset(new CPDF_XRefStream);
       m_pXRefStream->Start();
       if ((m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pParser) {
         FX_FILESIZE prev = m_pParser->GetLastXRefOffset();
         m_pXRefStream->m_PrevOffset = prev;
       }
     }
     m_iStage = 10;
   }
@@ skipping 492 matching lines @@
       return;
     }
     std::vector<uint8_t> buffer =
         PDF_GenerateFileID((uint32_t)(uintptr_t) this, m_dwLastObjNum);
     CFX_ByteString bsBuffer(buffer.data(), buffer.size());
     m_pIDArray->Add(new CPDF_String(bsBuffer, TRUE), m_pDocument);
     return;
   }
   m_pIDArray->Add(m_pIDArray->GetObjectAt(0)->Clone());
   if (m_pEncryptDict && !pOldIDArray && m_pParser && bNewId) {
-    if (m_pEncryptDict->GetStringBy("Filter") == "Standard") {
+    if (m_pEncryptDict->GetStringFor("Filter") == "Standard") {
       CFX_ByteString user_pass = m_pParser->GetPassword();
       uint32_t flag = PDF_ENCRYPT_CONTENT;
 
       CPDF_SecurityHandler handler;
       handler.OnCreate(m_pEncryptDict, m_pIDArray, user_pass.raw_str(),
                        user_pass.GetLength(), flag);
       if (m_bLocalCryptoHandler)
         delete m_pCryptoHandler;
       m_pCryptoHandler = new CPDF_CryptoHandler;
       m_pCryptoHandler->Init(m_pEncryptDict, &handler);
@@ skipping 42 matching lines @@
   m_pCryptoHandler = nullptr;
 }
 void CPDF_Creator::ResetStandardSecurity() {
   if (!m_bLocalCryptoHandler)
     return;
 
   delete m_pCryptoHandler;
   m_pCryptoHandler = nullptr;
   m_bLocalCryptoHandler = FALSE;
 }