Rename dictionary set and get methods

core/fpdfapi/fpdf_font/cpdf_font.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/include/cpdf_font.h"
 
 #include <memory>
 #include <vector>
@@ skipping 145 matching lines @@
 }
 
 uint32_t CPDF_Font::CharCodeFromUnicode(FX_WCHAR unicode) const {
   if (!m_bToUnicodeLoaded)
     LoadUnicodeMap();
 
   return m_pToUnicodeMap ? m_pToUnicodeMap->ReverseLookup(unicode) : 0;
 }
 
 void CPDF_Font::LoadFontDescriptor(CPDF_Dictionary* pFontDesc) {
-  m_Flags = pFontDesc->GetIntegerBy("Flags", PDFFONT_NONSYMBOLIC);
+  m_Flags = pFontDesc->GetIntegerFor("Flags", PDFFONT_NONSYMBOLIC);
   int ItalicAngle = 0;
   FX_BOOL bExistItalicAngle = FALSE;
   if (pFontDesc->KeyExist("ItalicAngle")) {
-    ItalicAngle = pFontDesc->GetIntegerBy("ItalicAngle");
+    ItalicAngle = pFontDesc->GetIntegerFor("ItalicAngle");
     bExistItalicAngle = TRUE;
   }
   if (ItalicAngle < 0) {
     m_Flags |= PDFFONT_ITALIC;
     m_ItalicAngle = ItalicAngle;
   }
   FX_BOOL bExistStemV = FALSE;
   if (pFontDesc->KeyExist("StemV")) {
-    m_StemV = pFontDesc->GetIntegerBy("StemV");
+    m_StemV = pFontDesc->GetIntegerFor("StemV");
     bExistStemV = TRUE;
   }
   FX_BOOL bExistAscent = FALSE;
   if (pFontDesc->KeyExist("Ascent")) {
-    m_Ascent = pFontDesc->GetIntegerBy("Ascent");
+    m_Ascent = pFontDesc->GetIntegerFor("Ascent");
     bExistAscent = TRUE;
   }
   FX_BOOL bExistDescent = FALSE;
   if (pFontDesc->KeyExist("Descent")) {
-    m_Descent = pFontDesc->GetIntegerBy("Descent");
+    m_Descent = pFontDesc->GetIntegerFor("Descent");
     bExistDescent = TRUE;
   }
   FX_BOOL bExistCapHeight = FALSE;
   if (pFontDesc->KeyExist("CapHeight")) {
     bExistCapHeight = TRUE;
   }
   if (bExistItalicAngle && bExistAscent && bExistCapHeight && bExistDescent &&
       bExistStemV) {
     m_Flags |= PDFFONT_USEEXTERNATTR;
   }
   if (m_Descent > 10) {
     m_Descent = -m_Descent;
   }
-  CPDF_Array* pBBox = pFontDesc->GetArrayBy("FontBBox");
+  CPDF_Array* pBBox = pFontDesc->GetArrayFor("FontBBox");
   if (pBBox) {
     m_FontBBox.left = pBBox->GetIntegerAt(0);
     m_FontBBox.bottom = pBBox->GetIntegerAt(1);
     m_FontBBox.right = pBBox->GetIntegerAt(2);
     m_FontBBox.top = pBBox->GetIntegerAt(3);
   }
 
-  CPDF_Stream* pFontFile = pFontDesc->GetStreamBy("FontFile");
+  CPDF_Stream* pFontFile = pFontDesc->GetStreamFor("FontFile");
   if (!pFontFile)
-    pFontFile = pFontDesc->GetStreamBy("FontFile2");
+    pFontFile = pFontDesc->GetStreamFor("FontFile2");
   if (!pFontFile)
-    pFontFile = pFontDesc->GetStreamBy("FontFile3");
+    pFontFile = pFontDesc->GetStreamFor("FontFile3");
   if (!pFontFile)
     return;
 
   m_pFontFile = m_pDocument->LoadFontFile(pFontFile);
   if (!m_pFontFile)
     return;
 
   const uint8_t* pFontData = m_pFontFile->GetData();
   uint32_t dwFontSize = m_pFontFile->GetSize();
   if (!m_Font.LoadEmbedded(pFontData, dwFontSize)) {
@@ skipping 44 matching lines @@
   if (m_Ascent == 0 && m_Descent == 0) {
     FX_RECT rect = GetCharBBox('A');
     m_Ascent = rect.bottom == rect.top ? m_FontBBox.top : rect.top;
     rect = GetCharBBox('g');
     m_Descent = rect.bottom == rect.top ? m_FontBBox.bottom : rect.bottom;
   }
 }
 
 void CPDF_Font::LoadUnicodeMap() const {
   m_bToUnicodeLoaded = TRUE;
-  CPDF_Stream* pStream = m_pFontDict->GetStreamBy("ToUnicode");
+  CPDF_Stream* pStream = m_pFontDict->GetStreamFor("ToUnicode");
   if (!pStream) {
     return;
   }
   m_pToUnicodeMap.reset(new CPDF_ToUnicodeMap);
   m_pToUnicodeMap->Load(pStream);
 }
 
 int CPDF_Font::GetStringWidth(const FX_CHAR* pString, int size) {
   int offset = 0;
   int width = 0;
@@ skipping 11 matching lines @@
   if (font_id < 0) {
     return nullptr;
   }
   CPDF_FontGlobals* pFontGlobals =
       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
   CPDF_Font* pFont = pFontGlobals->Find(pDoc, font_id);
   if (pFont) {
     return pFont;
   }
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
-  pDict->SetAtName("Type", "Font");
-  pDict->SetAtName("Subtype", "Type1");
-  pDict->SetAtName("BaseFont", fontname);
-  pDict->SetAtName("Encoding", "WinAnsiEncoding");
+  pDict->SetNameFor("Type", "Font");
+  pDict->SetNameFor("Subtype", "Type1");
+  pDict->SetNameFor("BaseFont", fontname);
+  pDict->SetNameFor("Encoding", "WinAnsiEncoding");
   pFont = CPDF_Font::CreateFontF(nullptr, pDict);
   pFontGlobals->Set(pDoc, font_id, pFont);
   return pFont;
 }
 
 CPDF_Font* CPDF_Font::CreateFontF(CPDF_Document* pDoc,
                                   CPDF_Dictionary* pFontDict) {
-  CFX_ByteString type = pFontDict->GetStringBy("Subtype");
+  CFX_ByteString type = pFontDict->GetStringFor("Subtype");
   std::unique_ptr<CPDF_Font> pFont;
   if (type == "TrueType") {
-    CFX_ByteString tag = pFontDict->GetStringBy("BaseFont").Left(4);
+    CFX_ByteString tag = pFontDict->GetStringFor("BaseFont").Left(4);
     for (size_t i = 0; i < FX_ArraySize(kChineseFontNames); ++i) {
       if (tag == CFX_ByteString(kChineseFontNames[i], 4)) {
-        CPDF_Dictionary* pFontDesc = pFontDict->GetDictBy("FontDescriptor");
+        CPDF_Dictionary* pFontDesc = pFontDict->GetDictFor("FontDescriptor");
         if (!pFontDesc || !pFontDesc->KeyExist("FontFile2"))
           pFont.reset(new CPDF_CIDFont);
         break;
       }
     }
     if (!pFont)
       pFont.reset(new CPDF_TrueTypeFont);
   } else if (type == "Type3") {
     pFont.reset(new CPDF_Type3Font);
   } else if (type == "Type0") {
     pFont.reset(new CPDF_CIDFont);
   } else {
     pFont.reset(new CPDF_Type1Font);
   }
   pFont->m_pFontDict = pFontDict;
   pFont->m_pDocument = pDoc;
-  pFont->m_BaseFont = pFontDict->GetStringBy("BaseFont");
+  pFont->m_BaseFont = pFontDict->GetStringFor("BaseFont");
   return pFont->Load() ? pFont.release() : nullptr;
 }
 
 uint32_t CPDF_Font::GetNextChar(const FX_CHAR* pString,
                                 int nStrLen,
                                 int& offset) const {
   if (offset < 0 || nStrLen < 1) {
     return 0;
   }
   uint8_t ch = offset < nStrLen ? pString[offset++] : pString[nStrLen - 1];
@@ skipping 32 matching lines @@
     GetPredefinedEncoding(bsEncoding, &iBaseEncoding);
     return;
   }
 
   CPDF_Dictionary* pDict = pEncoding->AsDictionary();
   if (!pDict)
     return;
 
   if (iBaseEncoding != PDFFONT_ENCODING_ADOBE_SYMBOL &&
       iBaseEncoding != PDFFONT_ENCODING_ZAPFDINGBATS) {
-    CFX_ByteString bsEncoding = pDict->GetStringBy("BaseEncoding");
+    CFX_ByteString bsEncoding = pDict->GetStringFor("BaseEncoding");
     if (bsEncoding.Compare("MacExpertEncoding") == 0 && bTrueType) {
       bsEncoding = "WinAnsiEncoding";
     }
     GetPredefinedEncoding(bsEncoding, &iBaseEncoding);
   }
   if ((!bEmbedded || bTrueType) && iBaseEncoding == PDFFONT_ENCODING_BUILTIN)
     iBaseEncoding = PDFFONT_ENCODING_STANDARD;
 
-  CPDF_Array* pDiffs = pDict->GetArrayBy("Differences");
+  CPDF_Array* pDiffs = pDict->GetArrayFor("Differences");
   if (!pDiffs)
     return;
 
   pCharNames->resize(256);
   uint32_t cur_code = 0;
   for (uint32_t i = 0; i < pDiffs->GetCount(); i++) {
     CPDF_Object* pElement = pDiffs->GetDirectObjectAt(i);
     if (!pElement)
       continue;
 
@@ skipping 49 matching lines @@
   if (fallbackFont < 0 ||
       fallbackFont >= pdfium::CollectionSize<int>(m_FontFallbacks)) {
     return -1;
   }
   int glyph =
       FXFT_Get_Char_Index(m_FontFallbacks[fallbackFont]->GetFace(), charcode);
   if (glyph == 0 || glyph == 0xffff)
     return -1;
   return glyph;
 }