Member function name refactoring

core/src/fpdfapi/fpdf_font/fpdf_font.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 "font_int.h"
 
 #include "core/src/fpdfapi/fpdf_page/pageint.h"
 #include "core/include/fpdfapi/fpdf_module.h"
@@ skipping 176 matching lines @@
   int dest_pos = 0;
   for (int src_pos = 0; src_pos < src_len; src_pos++) {
     FX_DWORD charcode = CharCodeFromUnicode(src_buf[src_pos]);
     dest_pos += AppendChar(dest_buf + dest_pos, charcode);
   }
   result.ReleaseBuffer(dest_pos);
   return result;
 }
 
 void CPDF_Font::LoadFontDescriptor(CPDF_Dictionary* pFontDesc) {
-  m_Flags = pFontDesc->GetInteger("Flags", PDFFONT_NONSYMBOLIC);
+  m_Flags = pFontDesc->GetIntegerBy("Flags", PDFFONT_NONSYMBOLIC);
   int ItalicAngle = 0;
   FX_BOOL bExistItalicAngle = FALSE;
   if (pFontDesc->KeyExist("ItalicAngle")) {
-    ItalicAngle = pFontDesc->GetInteger("ItalicAngle");
+    ItalicAngle = pFontDesc->GetIntegerBy("ItalicAngle");
     bExistItalicAngle = TRUE;
   }
   if (ItalicAngle < 0) {
     m_Flags |= PDFFONT_ITALIC;
     m_ItalicAngle = ItalicAngle;
   }
   FX_BOOL bExistStemV = FALSE;
   if (pFontDesc->KeyExist("StemV")) {
-    m_StemV = pFontDesc->GetInteger("StemV");
+    m_StemV = pFontDesc->GetIntegerBy("StemV");
     bExistStemV = TRUE;
   }
   FX_BOOL bExistAscent = FALSE;
   if (pFontDesc->KeyExist("Ascent")) {
-    m_Ascent = pFontDesc->GetInteger("Ascent");
+    m_Ascent = pFontDesc->GetIntegerBy("Ascent");
     bExistAscent = TRUE;
   }
   FX_BOOL bExistDescent = FALSE;
   if (pFontDesc->KeyExist("Descent")) {
-    m_Descent = pFontDesc->GetInteger("Descent");
+    m_Descent = pFontDesc->GetIntegerBy("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->GetArray("FontBBox");
+  CPDF_Array* pBBox = pFontDesc->GetArrayBy("FontBBox");
   if (pBBox) {
-    m_FontBBox.left = pBBox->GetInteger(0);
-    m_FontBBox.bottom = pBBox->GetInteger(1);
-    m_FontBBox.right = pBBox->GetInteger(2);
-    m_FontBBox.top = pBBox->GetInteger(3);
+    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->GetStream("FontFile");
+  CPDF_Stream* pFontFile = pFontDesc->GetStreamBy("FontFile");
   if (!pFontFile)
-    pFontFile = pFontDesc->GetStream("FontFile2");
+    pFontFile = pFontDesc->GetStreamBy("FontFile2");
   if (!pFontFile)
-    pFontFile = pFontDesc->GetStream("FontFile3");
+    pFontFile = pFontDesc->GetStreamBy("FontFile3");
   if (!pFontFile)
     return;
 
   m_pFontFile = m_pDocument->LoadFontFile(pFontFile);
   if (!m_pFontFile)
     return;
 
   const uint8_t* pFontData = m_pFontFile->GetData();
   FX_DWORD dwFontSize = m_pFontFile->GetSize();
   if (!m_Font.LoadEmbedded(pFontData, dwFontSize)) {
@@ skipping 60 matching lines @@
     GetCharBBox('g', rect);
     if (rect.bottom == rect.top) {
       m_Descent = m_FontBBox.bottom;
     } else {
       m_Descent = rect.bottom;
     }
   }
 }
 void CPDF_Font::LoadUnicodeMap() {
   m_bToUnicodeLoaded = TRUE;
-  CPDF_Stream* pStream = m_pFontDict->GetStream("ToUnicode");
+  CPDF_Stream* pStream = m_pFontDict->GetStreamBy("ToUnicode");
   if (!pStream) {
     return;
   }
   m_pToUnicodeMap = new CPDF_ToUnicodeMap;
   m_pToUnicodeMap->Load(pStream);
 }
 int CPDF_Font::GetStringWidth(const FX_CHAR* pString, int size) {
   int offset = 0;
   int width = 0;
   while (offset < size) {
@@ skipping 35 matching lines @@
   pFontGlobals->Set(pDoc, font_id, pFont);
   return pFont;
 }
 const uint8_t ChineseFontNames[][5] = {{0xCB, 0xCE, 0xCC, 0xE5, 0x00},
                                        {0xBF, 0xAC, 0xCC, 0xE5, 0x00},
                                        {0xBA, 0xDA, 0xCC, 0xE5, 0x00},
                                        {0xB7, 0xC2, 0xCB, 0xCE, 0x00},
                                        {0xD0, 0xC2, 0xCB, 0xCE, 0x00}};
 CPDF_Font* CPDF_Font::CreateFontF(CPDF_Document* pDoc,
                                   CPDF_Dictionary* pFontDict) {
-  CFX_ByteString type = pFontDict->GetString("Subtype");
+  CFX_ByteString type = pFontDict->GetStringBy("Subtype");
   CPDF_Font* pFont;
   if (type == "TrueType") {
     {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_ ||   \
     _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
-      CFX_ByteString basefont = pFontDict->GetString("BaseFont");
+      CFX_ByteString basefont = pFontDict->GetStringBy("BaseFont");
       CFX_ByteString tag = basefont.Left(4);
       int i;
       int count = sizeof(ChineseFontNames) / sizeof(ChineseFontNames[0]);
       for (i = 0; i < count; ++i) {
         if (tag == CFX_ByteString((const FX_CHAR*)ChineseFontNames[i])) {
           break;
         }
       }
       if (i < count) {
-        CPDF_Dictionary* pFontDesc = pFontDict->GetDict("FontDescriptor");
+        CPDF_Dictionary* pFontDesc = pFontDict->GetDictBy("FontDescriptor");
         if (!pFontDesc || !pFontDesc->KeyExist("FontFile2")) {
           pFont = new CPDF_CIDFont;
           pFont->m_pFontDict = pFontDict;
           pFont->m_pDocument = pDoc;
           if (!pFont->Load()) {
             delete pFont;
             return NULL;
           }
           return pFont;
         }
@@ skipping 13 matching lines @@
   if (!pFont->Load()) {
     delete pFont;
     return NULL;
   }
   return pFont;
 }
 FX_BOOL CPDF_Font::Load() {
   if (!m_pFontDict) {
     return FALSE;
   }
-  CFX_ByteString type = m_pFontDict->GetString("Subtype");
-  m_BaseFont = m_pFontDict->GetString("BaseFont");
+  CFX_ByteString type = m_pFontDict->GetStringBy("Subtype");
+  m_BaseFont = m_pFontDict->GetStringBy("BaseFont");
   if (type == "MMType1") {
     type = "Type1";
   }
   return _Load();
 }
 static CFX_WideString _FontMap_GetWideString(CFX_CharMap* pMap,
                                              const CFX_ByteString& bytestr) {
   return ((CPDF_FontCharMap*)pMap)->m_pFont->DecodeString(bytestr);
 }
 static CFX_ByteString _FontMap_GetByteString(CFX_CharMap* pMap,
@@ skipping 258 matching lines @@
     GetPredefinedEncoding(iBaseEncoding, bsEncoding);
     return;
   }
 
   CPDF_Dictionary* pDict = pEncoding->AsDictionary();
   if (!pDict)
     return;
 
   if (iBaseEncoding != PDFFONT_ENCODING_ADOBE_SYMBOL &&
       iBaseEncoding != PDFFONT_ENCODING_ZAPFDINGBATS) {
-    CFX_ByteString bsEncoding = pDict->GetString("BaseEncoding");
+    CFX_ByteString bsEncoding = pDict->GetStringBy("BaseEncoding");
     if (bsEncoding.Compare("MacExpertEncoding") == 0 && bTrueType) {
       bsEncoding = "WinAnsiEncoding";
     }
     GetPredefinedEncoding(iBaseEncoding, bsEncoding);
   }
   if ((!bEmbedded || bTrueType) && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
     iBaseEncoding = PDFFONT_ENCODING_STANDARD;
   }
-  CPDF_Array* pDiffs = pDict->GetArray("Differences");
+  CPDF_Array* pDiffs = pDict->GetArrayBy("Differences");
   if (!pDiffs) {
     return;
   }
   pCharNames = new CFX_ByteString[256];
   FX_DWORD cur_code = 0;
   for (FX_DWORD i = 0; i < pDiffs->GetCount(); i++) {
     CPDF_Object* pElement = pDiffs->GetElementValue(i);
     if (!pElement)
       continue;
 
@@ skipping 117 matching lines @@
   const FX_CHAR* name = NULL;
   if (pCharNames) {
     name = pCharNames[charcode];
   }
   if ((!name || name[0] == 0) && iBaseEncoding) {
     name = PDF_CharNameFromPredefinedCharSet(iBaseEncoding, charcode);
   }
   return name && name[0] ? name : nullptr;
 }
 FX_BOOL CPDF_SimpleFont::LoadCommon() {
-  CPDF_Dictionary* pFontDesc = m_pFontDict->GetDict("FontDescriptor");
+  CPDF_Dictionary* pFontDesc = m_pFontDict->GetDictBy("FontDescriptor");
   if (pFontDesc) {
     LoadFontDescriptor(pFontDesc);
   }
-  CPDF_Array* pWidthArray = m_pFontDict->GetArray("Widths");
+  CPDF_Array* pWidthArray = m_pFontDict->GetArrayBy("Widths");
   int width_start = 0, width_end = -1;
   m_bUseFontWidth = TRUE;
   if (pWidthArray) {
     m_bUseFontWidth = FALSE;
     if (pFontDesc && pFontDesc->KeyExist("MissingWidth")) {
-      int MissingWidth = pFontDesc->GetInteger("MissingWidth");
+      int MissingWidth = pFontDesc->GetIntegerBy("MissingWidth");
       for (int i = 0; i < 256; i++) {
         m_CharWidth[i] = MissingWidth;
       }
     }
-    width_start = m_pFontDict->GetInteger("FirstChar", 0);
-    width_end = m_pFontDict->GetInteger("LastChar", 0);
+    width_start = m_pFontDict->GetIntegerBy("FirstChar", 0);
+    width_end = m_pFontDict->GetIntegerBy("LastChar", 0);
     if (width_start >= 0 && width_start <= 255) {
       if (width_end <= 0 ||
           width_end >= width_start + (int)pWidthArray->GetCount()) {
         width_end = width_start + pWidthArray->GetCount() - 1;
       }
       if (width_end > 255) {
         width_end = 255;
       }
       for (int i = width_start; i <= width_end; i++) {
-        m_CharWidth[i] = pWidthArray->GetInteger(i - width_start);
+        m_CharWidth[i] = pWidthArray->GetIntegerAt(i - width_start);
       }
     }
   }
   if (m_pFontFile) {
     if (m_BaseFont.GetLength() > 8 && m_BaseFont[7] == '+') {
       m_BaseFont = m_BaseFont.Mid(8);
     }
   } else {
     LoadSubstFont();
   }
@@ skipping 54 matching lines @@
   return m_BaseEncoding != PDFFONT_ENCODING_BUILTIN &&
          m_BaseEncoding != PDFFONT_ENCODING_ADOBE_SYMBOL &&
          m_BaseEncoding != PDFFONT_ENCODING_ZAPFDINGBATS;
 }
 CPDF_Type1Font::CPDF_Type1Font() : CPDF_SimpleFont(PDFFONT_TYPE1) {
   m_Base14Font = -1;
 }
 FX_BOOL CPDF_Type1Font::_Load() {
   m_Base14Font = PDF_GetStandardFontName(&m_BaseFont);
   if (m_Base14Font >= 0) {
-    CPDF_Dictionary* pFontDesc = m_pFontDict->GetDict("FontDescriptor");
+    CPDF_Dictionary* pFontDesc = m_pFontDict->GetDictBy("FontDescriptor");
     if (pFontDesc && pFontDesc->KeyExist("Flags")) {
-      m_Flags = pFontDesc->GetInteger("Flags");
+      m_Flags = pFontDesc->GetIntegerBy("Flags");
     } else {
       m_Flags = m_Base14Font >= 12 ? PDFFONT_SYMBOLIC : PDFFONT_NONSYMBOLIC;
     }
     if (m_Base14Font < 4)
       for (int i = 0; i < 256; i++) {
         m_CharWidth[i] = 600;
       }
     if (m_Base14Font == 12) {
       m_BaseEncoding = PDFFONT_ENCODING_ADOBE_SYMBOL;
     } else if (m_Base14Font == 13) {
@@ skipping 446 matching lines @@
       baseEncoding =
           bSupportWin ? PDFFONT_ENCODING_WINANSI : PDFFONT_ENCODING_BUILTIN;
     }
   }
   if (((baseEncoding == PDFFONT_ENCODING_MACROMAN ||
         baseEncoding == PDFFONT_ENCODING_WINANSI) &&
        !m_pCharNames) ||
       (m_Flags & PDFFONT_NONSYMBOLIC)) {
     if (!FXFT_Has_Glyph_Names(m_Font.GetFace()) &&
         (!m_Font.GetFace()->num_charmaps || !m_Font.GetFace()->charmaps)) {
-      int nStartChar = m_pFontDict->GetInteger("FirstChar");
+      int nStartChar = m_pFontDict->GetIntegerBy("FirstChar");
       if (nStartChar < 0 || nStartChar > 255)
         return;
 
       int charcode = 0;
       for (; charcode < nStartChar; charcode++) {
         m_GlyphIndex[charcode] = 0;
       }
       FX_WORD nGlyph = charcode - nStartChar + 3;
       for (; charcode < 256; charcode++, nGlyph++) {
         m_GlyphIndex[charcode] = nGlyph;
@@ skipping 155 matching lines @@
       m_pFontResources(nullptr) {
   FXSYS_memset(m_CharWidthL, 0, sizeof(m_CharWidthL));
 }
 
 CPDF_Type3Font::~CPDF_Type3Font() {
   for (auto it : m_CacheMap)
     delete it.second;
 }
 
 FX_BOOL CPDF_Type3Font::_Load() {
-  m_pFontResources = m_pFontDict->GetDict("Resources");
-  CPDF_Array* pMatrix = m_pFontDict->GetArray("FontMatrix");
+  m_pFontResources = m_pFontDict->GetDictBy("Resources");
+  CPDF_Array* pMatrix = m_pFontDict->GetArrayBy("FontMatrix");
   FX_FLOAT xscale = 1.0f, yscale = 1.0f;
   if (pMatrix) {
     m_FontMatrix = pMatrix->GetMatrix();
     xscale = m_FontMatrix.a;
     yscale = m_FontMatrix.d;
   }
-  CPDF_Array* pBBox = m_pFontDict->GetArray("FontBBox");
+  CPDF_Array* pBBox = m_pFontDict->GetArrayBy("FontBBox");
   if (pBBox) {
-    m_FontBBox.left = (int32_t)(FXSYS_Mul(pBBox->GetNumber(0), xscale) * 1000);
+    m_FontBBox.left =
+        (int32_t)(FXSYS_Mul(pBBox->GetNumberAt(0), xscale) * 1000);
     m_FontBBox.bottom =
-        (int32_t)(FXSYS_Mul(pBBox->GetNumber(1), yscale) * 1000);
-    m_FontBBox.right = (int32_t)(FXSYS_Mul(pBBox->GetNumber(2), xscale) * 1000);
-    m_FontBBox.top = (int32_t)(FXSYS_Mul(pBBox->GetNumber(3), yscale) * 1000);
+        (int32_t)(FXSYS_Mul(pBBox->GetNumberAt(1), yscale) * 1000);
+    m_FontBBox.right =
+        (int32_t)(FXSYS_Mul(pBBox->GetNumberAt(2), xscale) * 1000);
+    m_FontBBox.top = (int32_t)(FXSYS_Mul(pBBox->GetNumberAt(3), yscale) * 1000);
   }
-  int StartChar = m_pFontDict->GetInteger("FirstChar");
-  CPDF_Array* pWidthArray = m_pFontDict->GetArray("Widths");
+  int StartChar = m_pFontDict->GetIntegerBy("FirstChar");
+  CPDF_Array* pWidthArray = m_pFontDict->GetArrayBy("Widths");
   if (pWidthArray && (StartChar >= 0 && StartChar < 256)) {
     FX_DWORD count = pWidthArray->GetCount();
     if (count > 256) {
       count = 256;
     }
     if (StartChar + count > 256) {
       count = 256 - StartChar;
     }
     for (FX_DWORD i = 0; i < count; i++) {
       m_CharWidthL[StartChar + i] =
-          FXSYS_round(FXSYS_Mul(pWidthArray->GetNumber(i), xscale) * 1000);
+          FXSYS_round(FXSYS_Mul(pWidthArray->GetNumberAt(i), xscale) * 1000);
     }
   }
-  m_pCharProcs = m_pFontDict->GetDict("CharProcs");
+  m_pCharProcs = m_pFontDict->GetDictBy("CharProcs");
   CPDF_Object* pEncoding = m_pFontDict->GetElementValue("Encoding");
   if (pEncoding) {
     LoadPDFEncoding(pEncoding, m_BaseEncoding, m_pCharNames, FALSE, FALSE);
     if (m_pCharNames) {
       for (int i = 0; i < 256; i++) {
         m_Encoding.m_Unicodes[i] = PDF_UnicodeFromAdobeName(m_pCharNames[i]);
         if (m_Encoding.m_Unicodes[i] == 0) {
           m_Encoding.m_Unicodes[i] = i;
         }
       }
@@ skipping 84 matching lines @@
   rect = pChar->m_BBox;
 }
 
 CPDF_Type3Char::CPDF_Type3Char(CPDF_Form* pForm)
     : m_pForm(pForm), m_pBitmap(nullptr), m_bColored(FALSE) {}
 
 CPDF_Type3Char::~CPDF_Type3Char() {
   delete m_pForm;
   delete m_pBitmap;
 }