Merge to XFA: Member function name refactoring

core/src/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 "render_int.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 204 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->GetInteger("Width");
-  m_Height = m_pDict->GetInteger("Height");
+  m_Width = m_pDict->GetIntegerBy("Width");
+  m_Height = m_pDict->GetIntegerBy("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 ? NULL : pFormResources,
                      pPageResources)) {
     return FALSE;
   }
@@ skipping 98 matching lines @@
                                        FX_DWORD 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->GetInteger("Width");
-  m_Height = m_pDict->GetInteger("Height");
+  m_Width = m_pDict->GetIntegerBy("Width");
+  m_Height = m_pDict->GetIntegerBy("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 ? NULL : pFormResources,
                      pPageResources)) {
     return 0;
   }
@@ skipping 42 matching lines @@
   if (m_Status == 1) {
     const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
     if (decoder == "JPXDecode") {
       return 0;
     }
     ICodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
     if (!m_pJbig2Context) {
       m_pJbig2Context = pJbig2Module->CreateJbig2Context();
       if (m_pStreamAcc->GetImageParam()) {
         CPDF_Stream* pGlobals =
-            m_pStreamAcc->GetImageParam()->GetStream("JBIG2Globals");
+            m_pStreamAcc->GetImageParam()->GetStreamBy("JBIG2Globals");
         if (pGlobals) {
           m_pGlobalStream = new CPDF_StreamAcc;
           m_pGlobalStream->LoadAllData(pGlobals, FALSE);
         }
       }
       ret = pJbig2Module->StartDecode(m_pJbig2Context, m_pDocument, m_Width,
                                       m_Height, m_pStreamAcc, m_pGlobalStream,
                                       m_pCachedBitmap->GetBuffer(),
                                       m_pCachedBitmap->GetPitch(), pPause);
       if (ret < 0) {
@@ skipping 46 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->GetInteger("BitsPerComponent");
-  if (m_pDict->GetInteger("ImageMask"))
+  m_bpc_orig = m_pDict->GetIntegerBy("BitsPerComponent");
+  if (m_pDict->GetIntegerBy("ImageMask"))
     m_bImageMask = TRUE;
 
   if (m_bImageMask || !m_pDict->KeyExist("ColorSpace")) {
     if (!m_bImageMask) {
       CPDF_Object* pFilter = m_pDict->GetElementValue("Filter");
       if (pFilter) {
         CFX_ByteString filter;
         if (pFilter->IsName()) {
           filter = pFilter->GetString();
         } else if (CPDF_Array* pArray = pFilter->AsArray()) {
-          filter = pArray->GetString(pArray->GetCount() - 1);
+          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->GetArray("Decode");
-    m_bDefaultDecode = !pDecode || !pDecode->GetInteger(0);
+    CPDF_Array* pDecode = m_pDict->GetArrayBy("Decode");
+    m_bDefaultDecode = !pDecode || !pDecode->GetIntegerAt(0);
     return true;
   }
 
   CPDF_Object* pCSObj = m_pDict->GetElementValue("ColorSpace");
   if (!pCSObj)
     return false;
 
   CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
   if (pFormResources)
     m_pColorSpace = pDocPageData->GetColorSpace(pCSObj, pFormResources);
@@ skipping 19 matching lines @@
   return !!m_pCompData;
 }
 
 DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode,
                                                      FX_BOOL& bColorKey) {
   if (!m_pColorSpace) {
     return NULL;
   }
   DIB_COMP_DATA* pCompData = FX_Alloc(DIB_COMP_DATA, m_nComponents);
   int max_data = (1 << m_bpc) - 1;
-  CPDF_Array* pDecode = m_pDict->GetArray("Decode");
+  CPDF_Array* pDecode = m_pDict->GetArrayBy("Decode");
   if (pDecode) {
     for (FX_DWORD i = 0; i < m_nComponents; i++) {
-      pCompData[i].m_DecodeMin = pDecode->GetNumber(i * 2);
-      FX_FLOAT max = pDecode->GetNumber(i * 2 + 1);
+      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, def_min, def_max;
       m_pColorSpace->GetDefaultValue(i, def_value, def_min, def_max);
       if (m_Family == PDFCS_INDEXED) {
         def_max = (FX_FLOAT)max_data;
       }
       if (def_min != pCompData[i].m_DecodeMin || def_max != max) {
         bDefaultDecode = FALSE;
       }
     }
@@ skipping 10 matching lines @@
     }
   }
   if (!m_pDict->KeyExist("SMask")) {
     CPDF_Object* pMask = m_pDict->GetElementValue("Mask");
     if (!pMask) {
       return pCompData;
     }
     if (CPDF_Array* pArray = pMask->AsArray()) {
       if (pArray->GetCount() >= m_nComponents * 2) {
         for (FX_DWORD i = 0; i < m_nComponents; i++) {
-          int min_num = pArray->GetInteger(i * 2);
-          int max_num = pArray->GetInteger(i * 2 + 1);
+          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);
         }
       }
       bColorKey = TRUE;
     }
   }
   return pCompData;
 }
 ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
@@ skipping 20 matching lines @@
   }
   const uint8_t* src_data = m_pStreamAcc->GetData();
   FX_DWORD src_size = m_pStreamAcc->GetSize();
   const CPDF_Dictionary* pParams = m_pStreamAcc->GetImageParam();
   if (decoder == "CCITTFaxDecode") {
     m_pDecoder = FPDFAPI_CreateFaxDecoder(src_data, src_size, m_Width, m_Height,
                                           pParams);
   } else if (decoder == "DCTDecode") {
     m_pDecoder = CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
         src_data, src_size, m_Width, m_Height, m_nComponents,
-        pParams ? pParams->GetInteger("ColorTransform", 1) : 1);
+        pParams ? pParams->GetIntegerBy("ColorTransform", 1) : 1);
     if (!m_pDecoder) {
       FX_BOOL bTransform = FALSE;
       int comps, bpc;
       ICodec_JpegModule* pJpegModule = CPDF_ModuleMgr::Get()->GetJpegModule();
       if (pJpegModule->LoadInfo(src_data, src_size, m_Width, m_Height, comps,
                                 bpc, bTransform)) {
         if (m_nComponents != comps) {
           FX_Free(m_pCompData);
           m_nComponents = comps;
           if (m_Family == PDFCS_LAB && m_nComponents != 3) {
@@ skipping 124 matching lines @@
       for (FX_DWORD col = 0; col < width; ++col) {
         *scanline = (*scanline) >> scale;
         ++scanline;
       }
     }
   }
   m_bpc = 8;
 }
 CPDF_DIBSource* CPDF_DIBSource::LoadMask(FX_DWORD& MatteColor) {
   MatteColor = 0xFFFFFFFF;
-  CPDF_Stream* pSoftMask = m_pDict->GetStream("SMask");
+  CPDF_Stream* pSoftMask = m_pDict->GetStreamBy("SMask");
   if (pSoftMask) {
-    CPDF_Array* pMatte = pSoftMask->GetDict()->GetArray("Matte");
+    CPDF_Array* pMatte = pSoftMask->GetDict()->GetArrayBy("Matte");
     if (pMatte && m_pColorSpace &&
         (FX_DWORD)m_pColorSpace->CountComponents() <= m_nComponents) {
       FX_FLOAT* pColor = FX_Alloc(FX_FLOAT, m_nComponents);
       for (FX_DWORD i = 0; i < m_nComponents; i++) {
-        pColor[i] = pMatte->GetFloat(i);
+        pColor[i] = pMatte->GetFloatAt(i);
       }
       FX_FLOAT R, G, B;
       m_pColorSpace->GetRGB(pColor, R, G, B);
       FX_Free(pColor);
       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->GetElementValue("Mask")))
     return LoadMaskDIB(pStream);
 
   return nullptr;
 }
 int CPDF_DIBSource::StratLoadMask() {
   m_MatteColor = 0XFFFFFFFF;
-  m_pMaskStream = m_pDict->GetStream("SMask");
+  m_pMaskStream = m_pDict->GetStreamBy("SMask");
   if (m_pMaskStream) {
-    CPDF_Array* pMatte = m_pMaskStream->GetDict()->GetArray("Matte");
+    CPDF_Array* pMatte = m_pMaskStream->GetDict()->GetArrayBy("Matte");
     if (pMatte && m_pColorSpace &&
         (FX_DWORD)m_pColorSpace->CountComponents() <= m_nComponents) {
       FX_FLOAT R, G, B;
       FX_FLOAT* pColor = FX_Alloc(FX_FLOAT, m_nComponents);
       for (FX_DWORD i = 0; i < m_nComponents; i++) {
-        pColor[i] = pMatte->GetFloat(i);
+        pColor[i] = pMatte->GetFloatAt(i);
       }
       m_pColorSpace->GetRGB(pColor, R, G, B);
       FX_Free(pColor);
       m_MatteColor = FXARGB_MAKE(0, FXSYS_round(R * 255), FXSYS_round(G * 255),
                                  FXSYS_round(B * 255));
     }
     return StartLoadMaskDIB();
   }
 
   m_pMaskStream = ToStream(m_pDict->GetElementValue("Mask"));
@@ skipping 126 matching lines @@
         m_bpc = 1;
         m_nComponents = 1;
       } else if (filter == "RunLengthDecode") {
         if (m_bpc != 1) {
           m_bpc = 8;
         }
       } else if (filter == "DCTDecode") {
         m_bpc = 8;
       }
     } else if (CPDF_Array* pArray = pFilter->AsArray()) {
-      CFX_ByteString filter = pArray->GetString(pArray->GetCount() - 1);
+      CFX_ByteString filter = pArray->GetStringAt(pArray->GetCount() - 1);
       if (filter == "CCITTFaxDecode" || filter == "JBIG2Decode") {
         m_bpc = 1;
         m_nComponents = 1;
       } else if (filter == "DCTDecode") {
         // Previously, filter == "RunLengthDecode" was checked in the "if"
         // statement as well, but too many documents don't conform to it.
         m_bpc = 8;
       }
     }
   }
@@ skipping 668 matching lines @@
 FX_BOOL CPDF_ImageLoader::Continue(CPDF_ImageLoaderHandle* LoadHandle,
                                    IFX_Pause* pPause) {
   return LoadHandle->Continue(pPause);
 }
 CPDF_ImageLoader::~CPDF_ImageLoader() {
   if (!m_bCached) {
     delete m_pBitmap;
     delete m_pMask;
   }
 }