Rename dictionary set and get methods

core/fpdfapi/fpdf_render/fpdf_render_loadimage.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_render/render_int.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 137 matching lines @@
                              FX_BOOL bLoadMask) {
   if (!pStream) {
     return FALSE;
   }
   m_pDocument = pDoc;
   m_pDict = pStream->GetDict();
   if (!m_pDict) {
     return FALSE;
   }
   m_pStream = pStream;
-  m_Width = m_pDict->GetIntegerBy("Width");
-  m_Height = m_pDict->GetIntegerBy("Height");
+  m_Width = m_pDict->GetIntegerFor("Width");
+  m_Height = m_pDict->GetIntegerFor("Height");
   if (m_Width <= 0 || m_Height <= 0 || m_Width > kMaxImageDimension ||
       m_Height > kMaxImageDimension) {
     return FALSE;
   }
   m_GroupFamily = GroupFamily;
   m_bLoadMask = bLoadMask;
   if (!LoadColorInfo(m_pStream->GetObjNum() != 0 ? nullptr : pFormResources,
                      pPageResources)) {
     return FALSE;
   }
@@ skipping 100 matching lines @@
                                        uint32_t GroupFamily,
                                        FX_BOOL bLoadMask) {
   if (!pStream) {
     return 0;
   }
   m_pDocument = pDoc;
   m_pDict = pStream->GetDict();
   m_pStream = pStream;
   m_bStdCS = bStdCS;
   m_bHasMask = bHasMask;
-  m_Width = m_pDict->GetIntegerBy("Width");
-  m_Height = m_pDict->GetIntegerBy("Height");
+  m_Width = m_pDict->GetIntegerFor("Width");
+  m_Height = m_pDict->GetIntegerFor("Height");
   if (m_Width <= 0 || m_Height <= 0 || m_Width > kMaxImageDimension ||
       m_Height > kMaxImageDimension) {
     return 0;
   }
   m_GroupFamily = GroupFamily;
   m_bLoadMask = bLoadMask;
   if (!LoadColorInfo(m_pStream->GetObjNum() != 0 ? nullptr : pFormResources,
                      pPageResources)) {
     return 0;
   }
@@ skipping 43 matching lines @@
   if (m_Status == 1) {
     const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
     if (decoder == "JPXDecode") {
       return 0;
     }
     CCodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
     if (!m_pJbig2Context) {
       m_pJbig2Context.reset(new CCodec_Jbig2Context());
       if (m_pStreamAcc->GetImageParam()) {
         CPDF_Stream* pGlobals =
-            m_pStreamAcc->GetImageParam()->GetStreamBy("JBIG2Globals");
+            m_pStreamAcc->GetImageParam()->GetStreamFor("JBIG2Globals");
         if (pGlobals) {
           m_pGlobalStream.reset(new CPDF_StreamAcc);
           m_pGlobalStream->LoadAllData(pGlobals, FALSE);
         }
       }
       ret = pJbig2Module->StartDecode(
           m_pJbig2Context.get(), m_pDocument->CodecContext(), m_Width, m_Height,
           m_pStreamAcc.get(), m_pGlobalStream.get(),
           m_pCachedBitmap->GetBuffer(), m_pCachedBitmap->GetPitch(), pPause);
       if (ret < 0) {
@@ skipping 42 matching lines @@
     return ret1;
   }
   if (m_Status == 2) {
     return ContinueLoadMaskDIB(pPause);
   }
   return 0;
 }
 
 bool CPDF_DIBSource::LoadColorInfo(const CPDF_Dictionary* pFormResources,
                                    const CPDF_Dictionary* pPageResources) {
-  m_bpc_orig = m_pDict->GetIntegerBy("BitsPerComponent");
-  if (m_pDict->GetIntegerBy("ImageMask"))
+  m_bpc_orig = m_pDict->GetIntegerFor("BitsPerComponent");
+  if (m_pDict->GetIntegerFor("ImageMask"))
     m_bImageMask = TRUE;
 
   if (m_bImageMask || !m_pDict->KeyExist("ColorSpace")) {
     if (!m_bImageMask) {
-      CPDF_Object* pFilter = m_pDict->GetDirectObjectBy("Filter");
+      CPDF_Object* pFilter = m_pDict->GetDirectObjectFor("Filter");
       if (pFilter) {
         CFX_ByteString filter;
         if (pFilter->IsName()) {
           filter = pFilter->GetString();
         } else if (CPDF_Array* pArray = pFilter->AsArray()) {
           filter = pArray->GetStringAt(pArray->GetCount() - 1);
         }
 
         if (filter == "JPXDecode") {
           m_bDoBpcCheck = FALSE;
           return true;
         }
       }
     }
     m_bImageMask = TRUE;
     m_bpc = m_nComponents = 1;
-    CPDF_Array* pDecode = m_pDict->GetArrayBy("Decode");
+    CPDF_Array* pDecode = m_pDict->GetArrayFor("Decode");
     m_bDefaultDecode = !pDecode || !pDecode->GetIntegerAt(0);
     return true;
   }
 
-  CPDF_Object* pCSObj = m_pDict->GetDirectObjectBy("ColorSpace");
+  CPDF_Object* pCSObj = m_pDict->GetDirectObjectFor("ColorSpace");
   if (!pCSObj)
     return false;
 
   CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
   if (pFormResources)
     m_pColorSpace = pDocPageData->GetColorSpace(pCSObj, pFormResources);
   if (!m_pColorSpace)
     m_pColorSpace = pDocPageData->GetColorSpace(pCSObj, pPageResources);
   if (!m_pColorSpace)
     return false;
@@ skipping 15 matching lines @@
   return !!m_pCompData;
 }
 
 DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode,
                                                      FX_BOOL& bColorKey) {
   if (!m_pColorSpace) {
     return nullptr;
   }
   DIB_COMP_DATA* pCompData = FX_Alloc(DIB_COMP_DATA, m_nComponents);
   int max_data = (1 << m_bpc) - 1;
-  CPDF_Array* pDecode = m_pDict->GetArrayBy("Decode");
+  CPDF_Array* pDecode = m_pDict->GetArrayFor("Decode");
   if (pDecode) {
     for (uint32_t i = 0; i < m_nComponents; i++) {
       pCompData[i].m_DecodeMin = pDecode->GetNumberAt(i * 2);
       FX_FLOAT max = pDecode->GetNumberAt(i * 2 + 1);
       pCompData[i].m_DecodeStep = (max - pCompData[i].m_DecodeMin) / max_data;
       FX_FLOAT def_value;
       FX_FLOAT def_min;
       FX_FLOAT def_max;
       m_pColorSpace->GetDefaultValue(i, def_value, def_min, def_max);
       if (m_Family == PDFCS_INDEXED) {
         def_max = max_data;
       }
       if (def_min != pCompData[i].m_DecodeMin || def_max != max) {
         bDefaultDecode = FALSE;
       }
     }
   } else {
     for (uint32_t i = 0; i < m_nComponents; i++) {
       FX_FLOAT def_value;
       m_pColorSpace->GetDefaultValue(i, def_value, pCompData[i].m_DecodeMin,
                                      pCompData[i].m_DecodeStep);
       if (m_Family == PDFCS_INDEXED) {
         pCompData[i].m_DecodeStep = max_data;
       }
       pCompData[i].m_DecodeStep =
           (pCompData[i].m_DecodeStep - pCompData[i].m_DecodeMin) / max_data;
     }
   }
   if (!m_pDict->KeyExist("SMask")) {
-    CPDF_Object* pMask = m_pDict->GetDirectObjectBy("Mask");
+    CPDF_Object* pMask = m_pDict->GetDirectObjectFor("Mask");
     if (!pMask) {
       return pCompData;
     }
     if (CPDF_Array* pArray = pMask->AsArray()) {
       if (pArray->GetCount() >= m_nComponents * 2) {
         for (uint32_t i = 0; i < m_nComponents; i++) {
           int min_num = pArray->GetIntegerAt(i * 2);
           int max_num = pArray->GetIntegerAt(i * 2 + 1);
           pCompData[i].m_ColorKeyMin = std::max(min_num, 0);
           pCompData[i].m_ColorKeyMax = std::min(max_num, max_data);
@@ skipping 31 matching lines @@
   }
   const uint8_t* src_data = m_pStreamAcc->GetData();
   uint32_t src_size = m_pStreamAcc->GetSize();
   const CPDF_Dictionary* pParams = m_pStreamAcc->GetImageParam();
   if (decoder == "CCITTFaxDecode") {
     m_pDecoder.reset(FPDFAPI_CreateFaxDecoder(src_data, src_size, m_Width,
                                               m_Height, pParams));
   } else if (decoder == "DCTDecode") {
     m_pDecoder.reset(CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
         src_data, src_size, m_Width, m_Height, m_nComponents,
-        pParams ? pParams->GetIntegerBy("ColorTransform", 1) : 1));
+        pParams ? pParams->GetIntegerFor("ColorTransform", 1) : 1));
     if (!m_pDecoder) {
       bool bTransform = false;
       int comps;
       int bpc;
       CCodec_JpegModule* pJpegModule = CPDF_ModuleMgr::Get()->GetJpegModule();
       if (pJpegModule->LoadInfo(src_data, src_size, &m_Width, &m_Height, &comps,
                                 &bpc, &bTransform)) {
         if (m_nComponents != static_cast<uint32_t>(comps)) {
           FX_Free(m_pCompData);
           m_pCompData = nullptr;
@@ skipping 128 matching lines @@
         *scanline = (*scanline) >> scale;
         ++scanline;
       }
     }
   }
   m_bpc = 8;
 }
 
 CPDF_DIBSource* CPDF_DIBSource::LoadMask(uint32_t& MatteColor) {
   MatteColor = 0xFFFFFFFF;
-  CPDF_Stream* pSoftMask = m_pDict->GetStreamBy("SMask");
+  CPDF_Stream* pSoftMask = m_pDict->GetStreamFor("SMask");
   if (pSoftMask) {
-    CPDF_Array* pMatte = pSoftMask->GetDict()->GetArrayBy("Matte");
+    CPDF_Array* pMatte = pSoftMask->GetDict()->GetArrayFor("Matte");
     if (pMatte && m_pColorSpace &&
         m_pColorSpace->CountComponents() <= m_nComponents) {
       std::vector<FX_FLOAT> colors(m_nComponents);
       for (uint32_t i = 0; i < m_nComponents; i++) {
         colors[i] = pMatte->GetFloatAt(i);
       }
       FX_FLOAT R, G, B;
       m_pColorSpace->GetRGB(colors.data(), R, G, B);
       MatteColor = FXARGB_MAKE(0, FXSYS_round(R * 255), FXSYS_round(G * 255),
                                FXSYS_round(B * 255));
     }
     return LoadMaskDIB(pSoftMask);
   }
 
-  if (CPDF_Stream* pStream = ToStream(m_pDict->GetDirectObjectBy("Mask")))
+  if (CPDF_Stream* pStream = ToStream(m_pDict->GetDirectObjectFor("Mask")))
     return LoadMaskDIB(pStream);
 
   return nullptr;
 }
 
 int CPDF_DIBSource::StratLoadMask() {
   m_MatteColor = 0XFFFFFFFF;
-  m_pMaskStream = m_pDict->GetStreamBy("SMask");
+  m_pMaskStream = m_pDict->GetStreamFor("SMask");
   if (m_pMaskStream) {
-    CPDF_Array* pMatte = m_pMaskStream->GetDict()->GetArrayBy("Matte");
+    CPDF_Array* pMatte = m_pMaskStream->GetDict()->GetArrayFor("Matte");
     if (pMatte && m_pColorSpace &&
         m_pColorSpace->CountComponents() <= m_nComponents) {
       FX_FLOAT R, G, B;
       std::vector<FX_FLOAT> colors(m_nComponents);
       for (uint32_t i = 0; i < m_nComponents; i++) {
         colors[i] = pMatte->GetFloatAt(i);
       }
       m_pColorSpace->GetRGB(colors.data(), R, G, B);
       m_MatteColor = FXARGB_MAKE(0, FXSYS_round(R * 255), FXSYS_round(G * 255),
                                  FXSYS_round(B * 255));
     }
     return StartLoadMaskDIB();
   }
 
-  m_pMaskStream = ToStream(m_pDict->GetDirectObjectBy("Mask"));
+  m_pMaskStream = ToStream(m_pDict->GetDirectObjectFor("Mask"));
   return m_pMaskStream ? StartLoadMaskDIB() : 1;
 }
 
 int CPDF_DIBSource::ContinueLoadMaskDIB(IFX_Pause* pPause) {
   if (!m_pMask) {
     return 1;
   }
   int ret = m_pMask->ContinueLoadDIBSource(pPause);
   if (ret == 2) {
     return ret;
@@ skipping 106 matching lines @@
         m_pColorSpace->GetRGB(color_value, R, G, B);
       }
       SetPaletteArgb(i, ArgbEncode(255, FXSYS_round(R * 255),
                                    FXSYS_round(G * 255), FXSYS_round(B * 255)));
     }
   }
 }
 
 void CPDF_DIBSource::ValidateDictParam() {
   m_bpc = m_bpc_orig;
-  CPDF_Object* pFilter = m_pDict->GetDirectObjectBy("Filter");
+  CPDF_Object* pFilter = m_pDict->GetDirectObjectFor("Filter");
   if (pFilter) {
     if (pFilter->IsName()) {
       CFX_ByteString filter = pFilter->GetString();
       if (filter == "CCITTFaxDecode" || filter == "JBIG2Decode") {
         m_bpc = 1;
         m_nComponents = 1;
       } else if (filter == "RunLengthDecode") {
         if (m_bpc != 1) {
           m_bpc = 8;
         }
@@ skipping 667 matching lines @@
                                    IFX_Pause* pPause) {
   return LoadHandle->Continue(pPause);
 }
 
 CPDF_ImageLoader::~CPDF_ImageLoader() {
   if (!m_bCached) {
     delete m_pBitmap;
     delete m_pMask;
   }
 }