Rename dictionary set and get methods

core/fpdfapi/fpdf_font/cpdf_cidfont.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_font/cpdf_cidfont.h"
 
 #include <algorithm>
 #include <vector>
@@ skipping 305 matching lines @@
 #else
   if (m_pCMap->m_pEmbedMap) {
     return EmbeddedCharcodeFromUnicode(m_pCMap->m_pEmbedMap, m_pCMap->m_Charset,
                                        unicode);
   }
 #endif
   return 0;
 }
 
 FX_BOOL CPDF_CIDFont::Load() {
-  if (m_pFontDict->GetStringBy("Subtype") == "TrueType") {
+  if (m_pFontDict->GetStringFor("Subtype") == "TrueType") {
     LoadGB2312();
     return TRUE;
   }
 
-  CPDF_Array* pFonts = m_pFontDict->GetArrayBy("DescendantFonts");
+  CPDF_Array* pFonts = m_pFontDict->GetArrayFor("DescendantFonts");
   if (!pFonts || pFonts->GetCount() != 1)
     return FALSE;
 
   CPDF_Dictionary* pCIDFontDict = pFonts->GetDictAt(0);
   if (!pCIDFontDict)
     return FALSE;
 
-  m_BaseFont = pCIDFontDict->GetStringBy("BaseFont");
+  m_BaseFont = pCIDFontDict->GetStringFor("BaseFont");
   if ((m_BaseFont.Compare("CourierStd") == 0 ||
        m_BaseFont.Compare("CourierStd-Bold") == 0 ||
        m_BaseFont.Compare("CourierStd-BoldOblique") == 0 ||
        m_BaseFont.Compare("CourierStd-Oblique") == 0) &&
       !IsEmbedded()) {
     m_bAdobeCourierStd = true;
   }
-  CPDF_Dictionary* pFontDesc = pCIDFontDict->GetDictBy("FontDescriptor");
+  CPDF_Dictionary* pFontDesc = pCIDFontDict->GetDictFor("FontDescriptor");
   if (pFontDesc)
     LoadFontDescriptor(pFontDesc);
 
-  CPDF_Object* pEncoding = m_pFontDict->GetDirectObjectBy("Encoding");
+  CPDF_Object* pEncoding = m_pFontDict->GetDirectObjectFor("Encoding");
   if (!pEncoding)
     return FALSE;
 
-  CFX_ByteString subtype = pCIDFontDict->GetStringBy("Subtype");
+  CFX_ByteString subtype = pCIDFontDict->GetStringFor("Subtype");
   m_bType1 = (subtype == "CIDFontType0");
 
   CPDF_CMapManager& manager = GetFontGlobals()->m_CMapManager;
   if (pEncoding->IsName()) {
     CFX_ByteString cmap = pEncoding->GetString();
     bool bPromptCJK = m_pFontFile && m_bType1;
     m_pCMap = manager.GetPredefinedCMap(cmap, bPromptCJK);
     if (!m_pCMap)
       return FALSE;
   } else if (CPDF_Stream* pStream = pEncoding->AsStream()) {
     m_pCMap = new CPDF_CMap;
     m_pAllocatedCMap.reset(m_pCMap);
     CPDF_StreamAcc acc;
     acc.LoadAllData(pStream, FALSE);
     m_pCMap->LoadEmbedded(acc.GetData(), acc.GetSize());
   } else {
     return FALSE;
   }
 
   m_Charset = m_pCMap->m_Charset;
   if (m_Charset == CIDSET_UNKNOWN) {
-    CPDF_Dictionary* pCIDInfo = pCIDFontDict->GetDictBy("CIDSystemInfo");
+    CPDF_Dictionary* pCIDInfo = pCIDFontDict->GetDictFor("CIDSystemInfo");
     if (pCIDInfo) {
       m_Charset =
-          CharsetFromOrdering(pCIDInfo->GetStringBy("Ordering").AsStringC());
+          CharsetFromOrdering(pCIDInfo->GetStringFor("Ordering").AsStringC());
     }
   }
   if (m_Charset != CIDSET_UNKNOWN) {
     bool bPromptCJK = !m_pFontFile && (m_pCMap->m_Coding == CIDCODING_CID ||
                                        pCIDFontDict->KeyExist("W"));
     m_pCID2UnicodeMap = manager.GetCID2UnicodeMap(m_Charset, bPromptCJK);
   }
   if (m_Font.GetFace()) {
     if (m_bType1)
       FXFT_Select_Charmap(m_Font.GetFace(), FXFT_ENCODING_UNICODE);
     else
       FT_UseCIDCharmap(m_Font.GetFace(), m_pCMap->m_Coding);
   }
-  m_DefaultWidth = pCIDFontDict->GetIntegerBy("DW", 1000);
-  CPDF_Array* pWidthArray = pCIDFontDict->GetArrayBy("W");
+  m_DefaultWidth = pCIDFontDict->GetIntegerFor("DW", 1000);
+  CPDF_Array* pWidthArray = pCIDFontDict->GetArrayFor("W");
   if (pWidthArray)
     LoadMetricsArray(pWidthArray, m_WidthList, 1);
   if (!IsEmbedded())
     LoadSubstFont();
 
   if (m_pFontFile || (GetSubstFont()->m_SubstFlags & FXFONT_SUBST_EXACT)) {
-    CPDF_Object* pmap = pCIDFontDict->GetDirectObjectBy("CIDToGIDMap");
+    CPDF_Object* pmap = pCIDFontDict->GetDirectObjectFor("CIDToGIDMap");
     if (pmap) {
       if (CPDF_Stream* pStream = pmap->AsStream()) {
         m_pStreamAcc.reset(new CPDF_StreamAcc);
         m_pStreamAcc->LoadAllData(pStream, FALSE);
       } else if (pmap->GetString() == "Identity") {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
         if (m_pFontFile) {
           m_bCIDIsGID = true;
         }
 #else
         m_bCIDIsGID = true;
 #endif
       }
     }
   }
 
   CheckFontMetrics();
   if (IsVertWriting()) {
-    pWidthArray = pCIDFontDict->GetArrayBy("W2");
+    pWidthArray = pCIDFontDict->GetArrayFor("W2");
     if (pWidthArray) {
       LoadMetricsArray(pWidthArray, m_VertMetrics, 3);
     }
-    CPDF_Array* pDefaultArray = pCIDFontDict->GetArrayBy("DW2");
+    CPDF_Array* pDefaultArray = pCIDFontDict->GetArrayFor("DW2");
     if (pDefaultArray) {
       m_DefaultVY = pDefaultArray->GetIntegerAt(0);
       m_DefaultW1 = pDefaultArray->GetIntegerAt(1);
     } else {
       m_DefaultVY = 880;
       m_DefaultW1 = -1000;
     }
   }
   return TRUE;
 }
@@ skipping 389 matching lines @@
     }
   }
 }
 
 // static
 FX_FLOAT CPDF_CIDFont::CIDTransformToFloat(uint8_t ch) {
   return (ch < 128 ? ch : ch - 255) * (1.0f / 127);
 }
 
 void CPDF_CIDFont::LoadGB2312() {
-  m_BaseFont = m_pFontDict->GetStringBy("BaseFont");
-  CPDF_Dictionary* pFontDesc = m_pFontDict->GetDictBy("FontDescriptor");
+  m_BaseFont = m_pFontDict->GetStringFor("BaseFont");
+  CPDF_Dictionary* pFontDesc = m_pFontDict->GetDictFor("FontDescriptor");
   if (pFontDesc)
     LoadFontDescriptor(pFontDesc);
 
   m_Charset = CIDSET_GB1;
   m_bType1 = false;
   CPDF_CMapManager& manager = GetFontGlobals()->m_CMapManager;
   m_pCMap = manager.GetPredefinedCMap("GBK-EUC-H", FALSE);
   m_pCID2UnicodeMap = manager.GetCID2UnicodeMap(m_Charset, FALSE);
   if (!IsEmbedded())
     LoadSubstFont();
 
   CheckFontMetrics();
   m_DefaultWidth = 1000;
   m_bAnsiWidthsFixed = true;
 }
 
 const uint8_t* CPDF_CIDFont::GetCIDTransform(uint16_t CID) const {
   if (m_Charset != CIDSET_JAPAN1 || m_pFontFile)
     return nullptr;
 
   const auto* pEnd = g_Japan1_VertCIDs + FX_ArraySize(g_Japan1_VertCIDs);
   const auto* pTransform = std::lower_bound(
       g_Japan1_VertCIDs, pEnd, CID,
       [](const CIDTransform& entry, uint16_t cid) { return entry.cid < cid; });
   return pTransform < pEnd && CID == pTransform->cid ? &pTransform->a : nullptr;
 }