Rename dictionary set and get methods

core/fpdfdoc/cpvt_generateap.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/fpdfdoc/cpvt_generateap.h"
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_simple_parser.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream.h"
 #include "core/fpdfapi/fpdf_parser/include/fpdf_parser_decode.h"
 #include "core/fpdfdoc/cpvt_color.h"
 #include "core/fpdfdoc/cpvt_fontmap.h"
 #include "core/fpdfdoc/include/cpdf_annot.h"
 #include "core/fpdfdoc/include/cpdf_formfield.h"
 #include "core/fpdfdoc/include/cpvt_word.h"
 
 namespace {
 
 bool GenerateWidgetAP(CPDF_Document* pDoc,
                       CPDF_Dictionary* pAnnotDict,
                       const int32_t& nWidgetType) {
   CPDF_Dictionary* pFormDict = nullptr;
   if (CPDF_Dictionary* pRootDict = pDoc->GetRoot())
-    pFormDict = pRootDict->GetDictBy("AcroForm");
+    pFormDict = pRootDict->GetDictFor("AcroForm");
   if (!pFormDict)
     return false;
 
   CFX_ByteString DA;
   if (CPDF_Object* pDAObj = FPDF_GetFieldAttr(pAnnotDict, "DA"))
     DA = pDAObj->GetString();
   if (DA.IsEmpty())
-    DA = pFormDict->GetStringBy("DA");
+    DA = pFormDict->GetStringFor("DA");
   if (DA.IsEmpty())
     return false;
 
   CPDF_SimpleParser syntax(DA.AsStringC());
   syntax.FindTagParamFromStart("Tf", 2);
   CFX_ByteString sFontName(syntax.GetWord());
   sFontName = PDF_NameDecode(sFontName);
   if (sFontName.IsEmpty())
     return false;
 
   FX_FLOAT fFontSize = FX_atof(syntax.GetWord());
   CPVT_Color crText = CPVT_Color::ParseColor(DA);
-  CPDF_Dictionary* pDRDict = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pDRDict = pFormDict->GetDictFor("DR");
   if (!pDRDict)
     return false;
 
-  CPDF_Dictionary* pDRFontDict = pDRDict->GetDictBy("Font");
+  CPDF_Dictionary* pDRFontDict = pDRDict->GetDictFor("Font");
   if (!pDRFontDict)
     return false;
 
-  CPDF_Dictionary* pFontDict = pDRFontDict->GetDictBy(sFontName.Mid(1));
+  CPDF_Dictionary* pFontDict = pDRFontDict->GetDictFor(sFontName.Mid(1));
   if (!pFontDict) {
     pFontDict = new CPDF_Dictionary;
-    pFontDict->SetAtName("Type", "Font");
-    pFontDict->SetAtName("Subtype", "Type1");
-    pFontDict->SetAtName("BaseFont", "Helvetica");
-    pFontDict->SetAtName("Encoding", "WinAnsiEncoding");
+    pFontDict->SetNameFor("Type", "Font");
+    pFontDict->SetNameFor("Subtype", "Type1");
+    pFontDict->SetNameFor("BaseFont", "Helvetica");
+    pFontDict->SetNameFor("Encoding", "WinAnsiEncoding");
     pDoc->AddIndirectObject(pFontDict);
-    pDRFontDict->SetAtReference(sFontName.Mid(1), pDoc, pFontDict);
+    pDRFontDict->SetReferenceFor(sFontName.Mid(1), pDoc, pFontDict);
   }
   CPDF_Font* pDefFont = pDoc->LoadFont(pFontDict);
   if (!pDefFont)
     return false;
 
-  CFX_FloatRect rcAnnot = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rcAnnot = pAnnotDict->GetRectFor("Rect");
   int32_t nRotate = 0;
-  if (CPDF_Dictionary* pMKDict = pAnnotDict->GetDictBy("MK"))
-    nRotate = pMKDict->GetIntegerBy("R");
+  if (CPDF_Dictionary* pMKDict = pAnnotDict->GetDictFor("MK"))
+    nRotate = pMKDict->GetIntegerFor("R");
 
   CFX_FloatRect rcBBox;
   CFX_Matrix matrix;
   switch (nRotate % 360) {
     case 0:
       rcBBox = CFX_FloatRect(0, 0, rcAnnot.right - rcAnnot.left,
                              rcAnnot.top - rcAnnot.bottom);
       break;
     case 90:
       matrix = CFX_Matrix(0, 1, -1, 0, rcAnnot.right - rcAnnot.left, 0);
@@ skipping 10 matching lines @@
       matrix = CFX_Matrix(0, -1, 1, 0, 0, rcAnnot.top - rcAnnot.bottom);
       rcBBox = CFX_FloatRect(0, 0, rcAnnot.top - rcAnnot.bottom,
                              rcAnnot.right - rcAnnot.left);
       break;
   }
 
   BorderStyle nBorderStyle = BorderStyle::SOLID;
   FX_FLOAT fBorderWidth = 1;
   CPVT_Dash dsBorder(3, 0, 0);
   CPVT_Color crLeftTop, crRightBottom;
-  if (CPDF_Dictionary* pBSDict = pAnnotDict->GetDictBy("BS")) {
+  if (CPDF_Dictionary* pBSDict = pAnnotDict->GetDictFor("BS")) {
     if (pBSDict->KeyExist("W"))
-      fBorderWidth = pBSDict->GetNumberBy("W");
+      fBorderWidth = pBSDict->GetNumberFor("W");
 
-    if (CPDF_Array* pArray = pBSDict->GetArrayBy("D")) {
+    if (CPDF_Array* pArray = pBSDict->GetArrayFor("D")) {
       dsBorder = CPVT_Dash(pArray->GetIntegerAt(0), pArray->GetIntegerAt(1),
                            pArray->GetIntegerAt(2));
     }
-    switch (pBSDict->GetStringBy("S").GetAt(0)) {
+    switch (pBSDict->GetStringFor("S").GetAt(0)) {
       case 'S':
         nBorderStyle = BorderStyle::SOLID;
         break;
       case 'D':
         nBorderStyle = BorderStyle::DASH;
         break;
       case 'B':
         nBorderStyle = BorderStyle::BEVELED;
         fBorderWidth *= 2;
         crLeftTop = CPVT_Color(CPVT_Color::kGray, 1);
         crRightBottom = CPVT_Color(CPVT_Color::kGray, 0.5);
         break;
       case 'I':
         nBorderStyle = BorderStyle::INSET;
         fBorderWidth *= 2;
         crLeftTop = CPVT_Color(CPVT_Color::kGray, 0.5);
         crRightBottom = CPVT_Color(CPVT_Color::kGray, 0.75);
         break;
       case 'U':
         nBorderStyle = BorderStyle::UNDERLINE;
         break;
     }
   }
   CPVT_Color crBorder, crBG;
-  if (CPDF_Dictionary* pMKDict = pAnnotDict->GetDictBy("MK")) {
-    if (CPDF_Array* pArray = pMKDict->GetArrayBy("BC"))
+  if (CPDF_Dictionary* pMKDict = pAnnotDict->GetDictFor("MK")) {
+    if (CPDF_Array* pArray = pMKDict->GetArrayFor("BC"))
       crBorder = CPVT_Color::ParseColor(*pArray);
-    if (CPDF_Array* pArray = pMKDict->GetArrayBy("BG"))
+    if (CPDF_Array* pArray = pMKDict->GetArrayFor("BG"))
       crBG = CPVT_Color::ParseColor(*pArray);
   }
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sBG =
       CPVT_GenerateAP::GenerateColorAP(crBG, PaintOperation::FILL);
   if (sBG.GetLength() > 0) {
     sAppStream << "q\n" << sBG << rcBBox.left << " " << rcBBox.bottom << " "
                << rcBBox.Width() << " " << rcBBox.Height() << " re f\n"
                << "Q\n";
   }
   CFX_ByteString sBorderStream = CPVT_GenerateAP::GenerateBorderAP(
       rcBBox, fBorderWidth, crBorder, crLeftTop, crRightBottom, nBorderStyle,
       dsBorder);
   if (sBorderStream.GetLength() > 0)
     sAppStream << "q\n" << sBorderStream << "Q\n";
 
   CFX_FloatRect rcBody =
       CFX_FloatRect(rcBBox.left + fBorderWidth, rcBBox.bottom + fBorderWidth,
                     rcBBox.right - fBorderWidth, rcBBox.top - fBorderWidth);
   rcBody.Normalize();
-  CPDF_Dictionary* pAPDict = pAnnotDict->GetDictBy("AP");
+  CPDF_Dictionary* pAPDict = pAnnotDict->GetDictFor("AP");
   if (!pAPDict) {
     pAPDict = new CPDF_Dictionary;
-    pAnnotDict->SetAt("AP", pAPDict);
+    pAnnotDict->SetFor("AP", pAPDict);
   }
-  CPDF_Stream* pNormalStream = pAPDict->GetStreamBy("N");
+  CPDF_Stream* pNormalStream = pAPDict->GetStreamFor("N");
   if (!pNormalStream) {
     pNormalStream = new CPDF_Stream(nullptr, 0, nullptr);
     int32_t objnum = pDoc->AddIndirectObject(pNormalStream);
-    pAnnotDict->GetDictBy("AP")->SetAtReference("N", pDoc, objnum);
+    pAnnotDict->GetDictFor("AP")->SetReferenceFor("N", pDoc, objnum);
   }
   CPDF_Dictionary* pStreamDict = pNormalStream->GetDict();
   if (pStreamDict) {
-    pStreamDict->SetAtMatrix("Matrix", matrix);
-    pStreamDict->SetAtRect("BBox", rcBBox);
-    CPDF_Dictionary* pStreamResList = pStreamDict->GetDictBy("Resources");
+    pStreamDict->SetMatrixFor("Matrix", matrix);
+    pStreamDict->SetRectFor("BBox", rcBBox);
+    CPDF_Dictionary* pStreamResList = pStreamDict->GetDictFor("Resources");
     if (pStreamResList) {
-      CPDF_Dictionary* pStreamResFontList = pStreamResList->GetDictBy("Font");
+      CPDF_Dictionary* pStreamResFontList = pStreamResList->GetDictFor("Font");
       if (!pStreamResFontList) {
         pStreamResFontList = new CPDF_Dictionary;
-        pStreamResList->SetAt("Font", pStreamResFontList);
+        pStreamResList->SetFor("Font", pStreamResFontList);
       }
       if (!pStreamResFontList->KeyExist(sFontName))
-        pStreamResFontList->SetAtReference(sFontName, pDoc, pFontDict);
+        pStreamResFontList->SetReferenceFor(sFontName, pDoc, pFontDict);
     } else {
-      pStreamDict->SetAt("Resources", pFormDict->GetDictBy("DR")->Clone());
-      pStreamResList = pStreamDict->GetDictBy("Resources");
+      pStreamDict->SetFor("Resources", pFormDict->GetDictFor("DR")->Clone());
+      pStreamResList = pStreamDict->GetDictFor("Resources");
     }
   }
   switch (nWidgetType) {
     case 0: {
       CFX_WideString swValue =
           FPDF_GetFieldAttr(pAnnotDict, "V")
               ? FPDF_GetFieldAttr(pAnnotDict, "V")->GetUnicodeText()
               : CFX_WideString();
       int32_t nAlign = FPDF_GetFieldAttr(pAnnotDict, "Q")
                            ? FPDF_GetFieldAttr(pAnnotDict, "Q")->GetInteger()
                            : 0;
       uint32_t dwFlags = FPDF_GetFieldAttr(pAnnotDict, "Ff")
                              ? FPDF_GetFieldAttr(pAnnotDict, "Ff")->GetInteger()
                              : 0;
       uint32_t dwMaxLen =
           FPDF_GetFieldAttr(pAnnotDict, "MaxLen")
               ? FPDF_GetFieldAttr(pAnnotDict, "MaxLen")->GetInteger()
               : 0;
       CPVT_FontMap map(
-          pDoc, pStreamDict ? pStreamDict->GetDictBy("Resources") : nullptr,
+          pDoc, pStreamDict ? pStreamDict->GetDictFor("Resources") : nullptr,
           pDefFont, sFontName.Right(sFontName.GetLength() - 1));
       CPDF_VariableText::Provider prd(&map);
       CPDF_VariableText vt;
       vt.SetProvider(&prd);
       vt.SetPlateRect(rcBody);
       vt.SetAlignment(nAlign);
       if (IsFloatZero(fFontSize))
         vt.SetAutoFontSize(TRUE);
       else
         vt.SetFontSize(fFontSize);
@@ skipping 40 matching lines @@
                    << sBody << "ET\n"
                    << "Q\nEMC\n";
       }
     } break;
     case 1: {
       CFX_WideString swValue =
           FPDF_GetFieldAttr(pAnnotDict, "V")
               ? FPDF_GetFieldAttr(pAnnotDict, "V")->GetUnicodeText()
               : CFX_WideString();
       CPVT_FontMap map(
-          pDoc, pStreamDict ? pStreamDict->GetDictBy("Resources") : nullptr,
+          pDoc, pStreamDict ? pStreamDict->GetDictFor("Resources") : nullptr,
           pDefFont, sFontName.Right(sFontName.GetLength() - 1));
       CPDF_VariableText::Provider prd(&map);
       CPDF_VariableText vt;
       vt.SetProvider(&prd);
       CFX_FloatRect rcButton = rcBody;
       rcButton.left = rcButton.right - 13;
       rcButton.Normalize();
       CFX_FloatRect rcEdit = rcBody;
       rcEdit.right = rcButton.left;
       rcEdit.Normalize();
@@ skipping 49 matching lines @@
           sAppStream << ptCenter.x - 3 << " " << ptCenter.y + 1.5f << " m\n";
           sAppStream << ptCenter.x + 3 << " " << ptCenter.y + 1.5f << " l\n";
           sAppStream << ptCenter.x << " " << ptCenter.y - 1.5f << " l\n";
           sAppStream << ptCenter.x - 3 << " " << ptCenter.y + 1.5f << " l f\n";
           sAppStream << sButton << "Q\n";
         }
       }
     } break;
     case 2: {
       CPVT_FontMap map(
-          pDoc, pStreamDict ? pStreamDict->GetDictBy("Resources") : nullptr,
+          pDoc, pStreamDict ? pStreamDict->GetDictFor("Resources") : nullptr,
           pDefFont, sFontName.Right(sFontName.GetLength() - 1));
       CPDF_VariableText::Provider prd(&map);
       CPDF_Array* pOpts = ToArray(FPDF_GetFieldAttr(pAnnotDict, "Opt"));
       CPDF_Array* pSels = ToArray(FPDF_GetFieldAttr(pAnnotDict, "I"));
       CPDF_Object* pTi = FPDF_GetFieldAttr(pAnnotDict, "TI");
       int32_t nTop = pTi ? pTi->GetInteger() : 0;
       CFX_ByteTextBuf sBody;
       if (pOpts) {
         FX_FLOAT fy = rcBody.top;
         for (size_t i = nTop, sz = pOpts->GetCount(); i < sz; i++) {
@@ skipping 65 matching lines @@
                    << rcBody.Width() << " " << rcBody.Height() << " re\nW\nn\n"
                    << sBody.AsStringC() << "Q\nEMC\n";
       }
     } break;
   }
   if (pNormalStream) {
     pNormalStream->SetData(sAppStream.GetBuffer(), sAppStream.GetSize(), FALSE,
                            FALSE);
     pStreamDict = pNormalStream->GetDict();
     if (pStreamDict) {
-      pStreamDict->SetAtMatrix("Matrix", matrix);
-      pStreamDict->SetAtRect("BBox", rcBBox);
-      CPDF_Dictionary* pStreamResList = pStreamDict->GetDictBy("Resources");
+      pStreamDict->SetMatrixFor("Matrix", matrix);
+      pStreamDict->SetRectFor("BBox", rcBBox);
+      CPDF_Dictionary* pStreamResList = pStreamDict->GetDictFor("Resources");
       if (pStreamResList) {
-        CPDF_Dictionary* pStreamResFontList = pStreamResList->GetDictBy("Font");
+        CPDF_Dictionary* pStreamResFontList =
+            pStreamResList->GetDictFor("Font");
         if (!pStreamResFontList) {
           pStreamResFontList = new CPDF_Dictionary;
-          pStreamResList->SetAt("Font", pStreamResFontList);
+          pStreamResList->SetFor("Font", pStreamResFontList);
         }
         if (!pStreamResFontList->KeyExist(sFontName))
-          pStreamResFontList->SetAtReference(sFontName, pDoc, pFontDict);
+          pStreamResFontList->SetReferenceFor(sFontName, pDoc, pFontDict);
       } else {
-        pStreamDict->SetAt("Resources", pFormDict->GetDictBy("DR")->Clone());
-        pStreamResList = pStreamDict->GetDictBy("Resources");
+        pStreamDict->SetFor("Resources", pFormDict->GetDictFor("DR")->Clone());
+        pStreamResList = pStreamDict->GetDictFor("Resources");
       }
     }
   }
   return true;
 }
 
 CFX_ByteString GetColorStringWithDefault(CPDF_Array* pColor,
                                          const CPVT_Color& crDefaultColor,
                                          PaintOperation nOperation) {
   if (pColor) {
     CPVT_Color color = CPVT_Color::ParseColor(*pColor);
     return CPVT_GenerateAP::GenerateColorAP(color, nOperation);
   }
 
   return CPVT_GenerateAP::GenerateColorAP(crDefaultColor, nOperation);
 }
 
 FX_FLOAT GetBorderWidth(const CPDF_Dictionary& pAnnotDict) {
-  if (CPDF_Dictionary* pBorderStyleDict = pAnnotDict.GetDictBy("BS")) {
+  if (CPDF_Dictionary* pBorderStyleDict = pAnnotDict.GetDictFor("BS")) {
     if (pBorderStyleDict->KeyExist("W"))
-      return pBorderStyleDict->GetNumberBy("W");
+      return pBorderStyleDict->GetNumberFor("W");
   }
 
-  if (CPDF_Array* pBorderArray = pAnnotDict.GetArrayBy("Border")) {
+  if (CPDF_Array* pBorderArray = pAnnotDict.GetArrayFor("Border")) {
     if (pBorderArray->GetCount() > 2)
       return pBorderArray->GetNumberAt(2);
   }
 
   return 1;
 }
 
 CPDF_Array* GetDashArray(const CPDF_Dictionary& pAnnotDict) {
-  if (CPDF_Dictionary* pBorderStyleDict = pAnnotDict.GetDictBy("BS")) {
-    if (pBorderStyleDict->GetStringBy("S") == "D")
-      return pBorderStyleDict->GetArrayBy("D");
+  if (CPDF_Dictionary* pBorderStyleDict = pAnnotDict.GetDictFor("BS")) {
+    if (pBorderStyleDict->GetStringFor("S") == "D")
+      return pBorderStyleDict->GetArrayFor("D");
   }
 
-  if (CPDF_Array* pBorderArray = pAnnotDict.GetArrayBy("Border")) {
+  if (CPDF_Array* pBorderArray = pAnnotDict.GetArrayFor("Border")) {
     if (pBorderArray->GetCount() == 4)
       return pBorderArray->GetArrayAt(3);
   }
 
   return nullptr;
 }
 
 CFX_ByteString GetDashPatternString(const CPDF_Dictionary& pAnnotDict) {
   CPDF_Array* pDashArray = GetDashArray(pAnnotDict);
   if (!pDashArray || pDashArray->IsEmpty())
     return CFX_ByteString();
 
   // Support maximum of ten elements in the dash array.
   size_t pDashArrayCount = std::min<size_t>(pDashArray->GetCount(), 10);
   CFX_ByteTextBuf sDashStream;
 
   sDashStream << "[";
   for (size_t i = 0; i < pDashArrayCount; ++i)
     sDashStream << pDashArray->GetNumberAt(i) << " ";
   sDashStream << "] 0 d\n";
 
   return sDashStream.MakeString();
 }
 
 CFX_ByteString GetPopupContentsString(CPDF_Document* pDoc,
                                       const CPDF_Dictionary& pAnnotDict,
                                       CPDF_Font* pDefFont,
                                       const CFX_ByteString& sFontName) {
-  CFX_WideString swValue(pAnnotDict.GetUnicodeTextBy("T"));
+  CFX_WideString swValue(pAnnotDict.GetUnicodeTextFor("T"));
   swValue += L'\n';
-  swValue += pAnnotDict.GetUnicodeTextBy("Contents");
+  swValue += pAnnotDict.GetUnicodeTextFor("Contents");
   CPVT_FontMap map(pDoc, nullptr, pDefFont, sFontName);
 
   CPDF_VariableText::Provider prd(&map);
   CPDF_VariableText vt;
   vt.SetProvider(&prd);
-  vt.SetPlateRect(pAnnotDict.GetRectBy("Rect"));
+  vt.SetPlateRect(pAnnotDict.GetRectFor("Rect"));
   vt.SetFontSize(12);
   vt.SetAutoReturn(TRUE);
   vt.SetMultiLine(TRUE);
 
   vt.Initialize();
   vt.SetText(swValue);
   vt.RearrangeAll();
   CFX_FloatPoint ptOffset(3.0f, -3.0f);
   CFX_ByteString sContent = CPVT_GenerateAP::GenerateEditAP(
       &map, vt.GetIterator(), ptOffset, FALSE, 0);
 
   if (sContent.IsEmpty())
     return CFX_ByteString();
 
   CFX_ByteTextBuf sAppStream;
   sAppStream << "BT\n"
              << CPVT_GenerateAP::GenerateColorAP(
                     CPVT_Color(CPVT_Color::kRGB, 0, 0, 0), PaintOperation::FILL)
              << sContent << "ET\n"
              << "Q\n";
   return sAppStream.MakeString();
 }
 
 CPDF_Dictionary* GenerateExtGStateDict(const CPDF_Dictionary& pAnnotDict,
                                        const CFX_ByteString& sExtGSDictName,
                                        const CFX_ByteString& sBlendMode) {
   CPDF_Dictionary* pGSDict = new CPDF_Dictionary;
-  pGSDict->SetAtString("Type", "ExtGState");
+  pGSDict->SetStringFor("Type", "ExtGState");
 
   FX_FLOAT fOpacity =
-      pAnnotDict.KeyExist("CA") ? pAnnotDict.GetNumberBy("CA") : 1;
-  pGSDict->SetAtNumber("CA", fOpacity);
-  pGSDict->SetAtNumber("ca", fOpacity);
-  pGSDict->SetAtBoolean("AIS", false);
-  pGSDict->SetAtString("BM", sBlendMode);
+      pAnnotDict.KeyExist("CA") ? pAnnotDict.GetNumberFor("CA") : 1;
+  pGSDict->SetNumberFor("CA", fOpacity);
+  pGSDict->SetNumberFor("ca", fOpacity);
+  pGSDict->SetBooleanFor("AIS", false);
+  pGSDict->SetStringFor("BM", sBlendMode);
 
   CPDF_Dictionary* pExtGStateDict = new CPDF_Dictionary;
-  pExtGStateDict->SetAt(sExtGSDictName, pGSDict);
+  pExtGStateDict->SetFor(sExtGSDictName, pGSDict);
 
   return pExtGStateDict;
 }
 
 CPDF_Dictionary* GenerateResourceFontDict(CPDF_Document* pDoc,
                                           const CFX_ByteString& sFontDictName) {
   CPDF_Dictionary* pFontDict = new CPDF_Dictionary;
-  pFontDict->SetAtName("Type", "Font");
-  pFontDict->SetAtName("Subtype", "Type1");
-  pFontDict->SetAtName("BaseFont", "Helvetica");
-  pFontDict->SetAtName("Encoding", "WinAnsiEncoding");
+  pFontDict->SetNameFor("Type", "Font");
+  pFontDict->SetNameFor("Subtype", "Type1");
+  pFontDict->SetNameFor("BaseFont", "Helvetica");
+  pFontDict->SetNameFor("Encoding", "WinAnsiEncoding");
   pDoc->AddIndirectObject(pFontDict);
 
   CPDF_Dictionary* pResourceFontDict = new CPDF_Dictionary;
-  pResourceFontDict->SetAtReference(sFontDictName, pDoc, pFontDict);
+  pResourceFontDict->SetReferenceFor(sFontDictName, pDoc, pFontDict);
 
   return pResourceFontDict;
 }
 
 // Takes ownership of |pExtGStateDict| and |pResourceFontDict|.
 CPDF_Dictionary* GenerateResourceDict(CPDF_Dictionary* pExtGStateDict,
                                       CPDF_Dictionary* pResourceFontDict) {
   CPDF_Dictionary* pResourceDict = new CPDF_Dictionary;
   if (pExtGStateDict)
-    pResourceDict->SetAt("ExtGState", pExtGStateDict);
+    pResourceDict->SetFor("ExtGState", pExtGStateDict);
 
   if (pResourceFontDict)
-    pResourceDict->SetAt("Font", pResourceFontDict);
+    pResourceDict->SetFor("Font", pResourceFontDict);
 
   return pResourceDict;
 }
 
 // Takes ownership of |pResourceDict|.
 void GenerateAndSetAPDict(CPDF_Document* pDoc,
                           CPDF_Dictionary* pAnnotDict,
                           const CFX_ByteTextBuf& sAppStream,
                           CPDF_Dictionary* pResourceDict) {
   CPDF_Dictionary* pAPDict = new CPDF_Dictionary;
-  pAnnotDict->SetAt("AP", pAPDict);
+  pAnnotDict->SetFor("AP", pAPDict);
 
   CPDF_Stream* pNormalStream = new CPDF_Stream(nullptr, 0, nullptr);
   int32_t objnum = pDoc->AddIndirectObject(pNormalStream);
-  pAnnotDict->GetDictBy("AP")->SetAtReference("N", pDoc, objnum);
+  pAnnotDict->GetDictFor("AP")->SetReferenceFor("N", pDoc, objnum);
 
   pNormalStream->SetData(sAppStream.GetBuffer(), sAppStream.GetSize(), FALSE,
                          FALSE);
 
   CPDF_Dictionary* pStreamDict = pNormalStream->GetDict();
-  pStreamDict->SetAtInteger("FormType", 1);
-  pStreamDict->SetAtString("Subtype", "Form");
-  pStreamDict->SetAtMatrix("Matrix", CFX_Matrix());
+  pStreamDict->SetIntegerFor("FormType", 1);
+  pStreamDict->SetStringFor("Subtype", "Form");
+  pStreamDict->SetMatrixFor("Matrix", CFX_Matrix());
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
-  pStreamDict->SetAtRect("BBox", rect);
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
+  pStreamDict->SetRectFor("BBox", rect);
 
-  pStreamDict->SetAt("Resources", pResourceDict);
+  pStreamDict->SetFor("Resources", pResourceDict);
 }
 
 CFX_ByteString GetPaintOperatorString(bool bIsStrokeRect, bool bIsFillRect) {
   if (bIsStrokeRect)
     return bIsFillRect ? "b" : "s";
   return bIsFillRect ? "f" : "n";
 }
 
 CFX_ByteString GenerateTextSymbolAP(const CFX_FloatRect& rect) {
   CFX_ByteTextBuf sAppStream;
@@ skipping 41 matching lines @@
                << lineRect.right << " " << lineRect.top << " l\n";
   }
   sAppStream << "B*\n";
 
   return sAppStream.MakeString();
 }
 
 }  // namespace
 
 bool FPDF_GenerateAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) {
-  if (!pAnnotDict || pAnnotDict->GetStringBy("Subtype") != "Widget")
+  if (!pAnnotDict || pAnnotDict->GetStringFor("Subtype") != "Widget")
     return false;
 
   CFX_ByteString field_type = FPDF_GetFieldAttr(pAnnotDict, "FT")->GetString();
   uint32_t flags = FPDF_GetFieldAttr(pAnnotDict, "Ff")
                        ? FPDF_GetFieldAttr(pAnnotDict, "Ff")->GetInteger()
                        : 0;
   if (field_type == "Tx") {
     return CPVT_GenerateAP::GenerateTextFieldAP(pDoc, pAnnotDict);
   }
   if (field_type == "Ch") {
     return (flags & (1 << 17))
                ? CPVT_GenerateAP::GenerateComboBoxAP(pDoc, pAnnotDict)
                : CPVT_GenerateAP::GenerateListBoxAP(pDoc, pAnnotDict);
   }
   if (field_type == "Btn") {
     if (!(flags & (1 << 16))) {
       if (!pAnnotDict->KeyExist("AS")) {
-        if (CPDF_Dictionary* pParentDict = pAnnotDict->GetDictBy("Parent")) {
+        if (CPDF_Dictionary* pParentDict = pAnnotDict->GetDictFor("Parent")) {
           if (pParentDict->KeyExist("AS")) {
-            pAnnotDict->SetAtString("AS", pParentDict->GetStringBy("AS"));
+            pAnnotDict->SetStringFor("AS", pParentDict->GetStringFor("AS"));
           }
         }
       }
     }
   }
   return false;
 }
 
 // Static.
 bool CPVT_GenerateAP::GenerateComboBoxAP(CPDF_Document* pDoc,
@@ skipping 12 matching lines @@
                                           CPDF_Dictionary* pAnnotDict) {
   return GenerateWidgetAP(pDoc, pAnnotDict, 0);
 }
 
 bool CPVT_GenerateAP::GenerateCircleAP(CPDF_Document* pDoc,
                                        CPDF_Dictionary* pAnnotDict) {
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs ";
 
-  CPDF_Array* pInteriorColor = pAnnotDict->GetArrayBy("IC");
+  CPDF_Array* pInteriorColor = pAnnotDict->GetArrayFor("IC");
   sAppStream << GetColorStringWithDefault(pInteriorColor,
                                           CPVT_Color(CPVT_Color::kTransparent),
                                           PaintOperation::FILL);
 
-  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayBy("C"),
+  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayFor("C"),
                                           CPVT_Color(CPVT_Color::kRGB, 0, 0, 0),
                                           PaintOperation::STROKE);
 
   FX_FLOAT fBorderWidth = GetBorderWidth(*pAnnotDict);
   bool bIsStrokeRect = fBorderWidth > 0;
 
   if (bIsStrokeRect) {
     sAppStream << fBorderWidth << " w ";
     sAppStream << GetDashPatternString(*pAnnotDict);
   }
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   rect.Normalize();
 
   if (bIsStrokeRect) {
     // Deflating rect because stroking a path entails painting all points whose
     // perpendicular distance from the path in user space is less than or equal
     // to half the line width.
     rect.Deflate(fBorderWidth / 2, fBorderWidth / 2);
   }
 
   const FX_FLOAT fMiddleX = (rect.left + rect.right) / 2;
@@ skipping 35 matching lines @@
   GenerateAndSetAPDict(pDoc, pAnnotDict, sAppStream, pResourceDict);
   return true;
 }
 
 bool CPVT_GenerateAP::GenerateHighlightAP(CPDF_Document* pDoc,
                                           CPDF_Dictionary* pAnnotDict) {
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs ";
 
-  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayBy("C"),
+  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayFor("C"),
                                           CPVT_Color(CPVT_Color::kRGB, 1, 1, 0),
                                           PaintOperation::FILL);
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   rect.Normalize();
 
   sAppStream << rect.left << " " << rect.top << " m " << rect.right << " "
              << rect.top << " l " << rect.right << " " << rect.bottom << " l "
              << rect.left << " " << rect.bottom << " l "
              << "h f\n";
 
   CPDF_Dictionary* pExtGStateDict =
       GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Multiply");
   CPDF_Dictionary* pResourceDict =
       GenerateResourceDict(pExtGStateDict, nullptr);
   GenerateAndSetAPDict(pDoc, pAnnotDict, sAppStream, pResourceDict);
 
   return true;
 }
 
 bool CPVT_GenerateAP::GenerateInkAP(CPDF_Document* pDoc,
                                     CPDF_Dictionary* pAnnotDict) {
   FX_FLOAT fBorderWidth = GetBorderWidth(*pAnnotDict);
   bool bIsStroke = fBorderWidth > 0;
 
   if (!bIsStroke)
     return false;
 
-  CPDF_Array* pInkList = pAnnotDict->GetArrayBy("InkList");
+  CPDF_Array* pInkList = pAnnotDict->GetArrayFor("InkList");
   if (!pInkList || pInkList->IsEmpty())
     return false;
 
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs ";
 
-  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayBy("C"),
+  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayFor("C"),
                                           CPVT_Color(CPVT_Color::kRGB, 0, 0, 0),
                                           PaintOperation::STROKE);
 
   sAppStream << fBorderWidth << " w ";
   sAppStream << GetDashPatternString(*pAnnotDict);
 
   // Set inflated rect as a new rect because paths near the border with large
   // width should not be clipped to the original rect.
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   rect.Inflate(fBorderWidth / 2, fBorderWidth / 2);
-  pAnnotDict->SetAtRect("Rect", rect);
+  pAnnotDict->SetRectFor("Rect", rect);
 
   for (size_t i = 0; i < pInkList->GetCount(); i++) {
     CPDF_Array* pInkCoordList = pInkList->GetArrayAt(i);
     if (!pInkCoordList || pInkCoordList->GetCount() < 2)
       continue;
 
     sAppStream << pInkCoordList->GetNumberAt(0) << " "
                << pInkCoordList->GetNumberAt(1) << " m ";
 
     for (size_t j = 0; j < pInkCoordList->GetCount() - 1; j += 2) {
@@ skipping 11 matching lines @@
   GenerateAndSetAPDict(pDoc, pAnnotDict, sAppStream, pResourceDict);
   return true;
 }
 
 bool CPVT_GenerateAP::GenerateTextAP(CPDF_Document* pDoc,
                                      CPDF_Dictionary* pAnnotDict) {
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs ";
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   const FX_FLOAT fNoteLength = 20;
   CFX_FloatRect noteRect(rect.left, rect.bottom, rect.left + fNoteLength,
                          rect.bottom + fNoteLength);
-  pAnnotDict->SetAtRect("Rect", noteRect);
+  pAnnotDict->SetRectFor("Rect", noteRect);
 
   sAppStream << GenerateTextSymbolAP(noteRect);
 
   CPDF_Dictionary* pExtGStateDict =
       GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal");
   CPDF_Dictionary* pResourceDict =
       GenerateResourceDict(pExtGStateDict, nullptr);
   GenerateAndSetAPDict(pDoc, pAnnotDict, sAppStream, pResourceDict);
   return true;
 }
 
 bool CPVT_GenerateAP::GenerateUnderlineAP(CPDF_Document* pDoc,
                                           CPDF_Dictionary* pAnnotDict) {
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs ";
 
-  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayBy("C"),
+  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayFor("C"),
                                           CPVT_Color(CPVT_Color::kRGB, 0, 0, 0),
                                           PaintOperation::STROKE);
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   rect.Normalize();
 
   FX_FLOAT fLineWidth = 1.0;
   sAppStream << fLineWidth << " w " << rect.left << " "
              << rect.bottom + fLineWidth << " m " << rect.right << " "
              << rect.bottom + fLineWidth << " l S\n";
 
   CPDF_Dictionary* pExtGStateDict =
       GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal");
   CPDF_Dictionary* pResourceDict =
       GenerateResourceDict(pExtGStateDict, nullptr);
   GenerateAndSetAPDict(pDoc, pAnnotDict, sAppStream, pResourceDict);
   return true;
 }
 
 bool CPVT_GenerateAP::GeneratePopupAP(CPDF_Document* pDoc,
                                       CPDF_Dictionary* pAnnotDict) {
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs\n";
 
   sAppStream << GenerateColorAP(CPVT_Color(CPVT_Color::kRGB, 1, 1, 0),
                                 PaintOperation::FILL);
   sAppStream << GenerateColorAP(CPVT_Color(CPVT_Color::kRGB, 0, 0, 0),
                                 PaintOperation::STROKE);
 
   const FX_FLOAT fBorderWidth = 1;
   sAppStream << fBorderWidth << " w\n";
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   rect.Normalize();
   rect.Deflate(fBorderWidth / 2, fBorderWidth / 2);
 
   sAppStream << rect.left << " " << rect.bottom << " " << rect.Width() << " "
              << rect.Height() << " re b\n";
 
   CFX_ByteString sFontName = "FONT";
   CPDF_Dictionary* pExtGStateDict =
       GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal");
   CPDF_Dictionary* pResourceFontDict =
       GenerateResourceFontDict(pDoc, sFontName);
   CPDF_Dictionary* pResourceDict =
       GenerateResourceDict(pResourceFontDict, pExtGStateDict);
 
   CPDF_Font* pDefFont = pDoc->LoadFont(pResourceFontDict);
   if (!pDefFont)
     return false;
 
   sAppStream << GetPopupContentsString(pDoc, *pAnnotDict, pDefFont, sFontName);
   GenerateAndSetAPDict(pDoc, pAnnotDict, sAppStream, pResourceDict);
   return true;
 }
 
 bool CPVT_GenerateAP::GenerateSquareAP(CPDF_Document* pDoc,
                                        CPDF_Dictionary* pAnnotDict) {
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs ";
 
-  CPDF_Array* pInteriorColor = pAnnotDict->GetArrayBy("IC");
+  CPDF_Array* pInteriorColor = pAnnotDict->GetArrayFor("IC");
   sAppStream << GetColorStringWithDefault(pInteriorColor,
                                           CPVT_Color(CPVT_Color::kTransparent),
                                           PaintOperation::FILL);
 
-  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayBy("C"),
+  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayFor("C"),
                                           CPVT_Color(CPVT_Color::kRGB, 0, 0, 0),
                                           PaintOperation::STROKE);
 
   FX_FLOAT fBorderWidth = GetBorderWidth(*pAnnotDict);
   bool bIsStrokeRect = fBorderWidth > 0;
 
   if (bIsStrokeRect) {
     sAppStream << fBorderWidth << " w ";
     sAppStream << GetDashPatternString(*pAnnotDict);
   }
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   rect.Normalize();
 
   if (bIsStrokeRect) {
     // Deflating rect because stroking a path entails painting all points whose
     // perpendicular distance from the path in user space is less than or equal
     // to half the line width.
     rect.Deflate(fBorderWidth / 2, fBorderWidth / 2);
   }
 
   bool bIsFillRect = pInteriorColor && (pInteriorColor->GetCount() > 0);
 
   sAppStream << rect.left << " " << rect.bottom << " " << rect.Width() << " "
              << rect.Height() << " re "
              << GetPaintOperatorString(bIsStrokeRect, bIsFillRect) << "\n";
 
   CPDF_Dictionary* pExtGStateDict =
       GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal");
   CPDF_Dictionary* pResourceDict =
       GenerateResourceDict(pExtGStateDict, nullptr);
   GenerateAndSetAPDict(pDoc, pAnnotDict, sAppStream, pResourceDict);
   return true;
 }
 
 bool CPVT_GenerateAP::GenerateSquigglyAP(CPDF_Document* pDoc,
                                          CPDF_Dictionary* pAnnotDict) {
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs ";
 
-  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayBy("C"),
+  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayFor("C"),
                                           CPVT_Color(CPVT_Color::kRGB, 0, 0, 0),
                                           PaintOperation::STROKE);
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   rect.Normalize();
 
   FX_FLOAT fLineWidth = 1.0;
   sAppStream << fLineWidth << " w ";
 
   const FX_FLOAT fDelta = 2.0;
   const FX_FLOAT fTop = rect.bottom + fDelta;
   const FX_FLOAT fBottom = rect.bottom;
 
   sAppStream << rect.left << " " << fTop << " m ";
@@ skipping 23 matching lines @@
   GenerateAndSetAPDict(pDoc, pAnnotDict, sAppStream, pResourceDict);
   return true;
 }
 
 bool CPVT_GenerateAP::GenerateStrikeOutAP(CPDF_Document* pDoc,
                                           CPDF_Dictionary* pAnnotDict) {
   CFX_ByteTextBuf sAppStream;
   CFX_ByteString sExtGSDictName = "GS";
   sAppStream << "/" << sExtGSDictName << " gs ";
 
-  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayBy("C"),
+  sAppStream << GetColorStringWithDefault(pAnnotDict->GetArrayFor("C"),
                                           CPVT_Color(CPVT_Color::kRGB, 0, 0, 0),
                                           PaintOperation::STROKE);
 
-  CFX_FloatRect rect = pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = pAnnotDict->GetRectFor("Rect");
   rect.Normalize();
 
   FX_FLOAT fLineWidth = 1.0;
   FX_FLOAT fY = (rect.top + rect.bottom) / 2;
   sAppStream << fLineWidth << " w " << rect.left << " " << fY << " m "
              << rect.right << " " << fY << " l S\n";
 
   CPDF_Dictionary* pExtGStateDict =
       GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal");
   CPDF_Dictionary* pResourceDict =
@@ skipping 262 matching lines @@
                                                  int32_t nFontIndex,
                                                  FX_FLOAT fFontSize) {
   CFX_ByteTextBuf sRet;
   if (pFontMap) {
     CFX_ByteString sFontAlias = pFontMap->GetPDFFontAlias(nFontIndex);
     if (sFontAlias.GetLength() > 0 && fFontSize > 0)
       sRet << "/" << sFontAlias << " " << fFontSize << " Tf\n";
   }
   return sRet.MakeString();
 }