Rename GetElementValue() to GetDirectObject{By,At}().

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 402 matching lines @@
 }
 
 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_bImageMask = TRUE;
 
   if (m_bImageMask || !m_pDict->KeyExist("ColorSpace")) {
     if (!m_bImageMask) {
-      CPDF_Object* pFilter = m_pDict->GetElementValue("Filter");
+      CPDF_Object* pFilter = m_pDict->GetDirectObjectBy("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");
     m_bDefaultDecode = !pDecode || !pDecode->GetIntegerAt(0);
     return true;
   }
 
-  CPDF_Object* pCSObj = m_pDict->GetElementValue("ColorSpace");
+  CPDF_Object* pCSObj = m_pDict->GetDirectObjectBy("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 45 matching lines @@
       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->GetElementValue("Mask");
+    CPDF_Object* pMask = m_pDict->GetDirectObjectBy("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 198 matching lines @@
         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->GetElementValue("Mask")))
+  if (CPDF_Stream* pStream = ToStream(m_pDict->GetDirectObjectBy("Mask")))
     return LoadMaskDIB(pStream);
 
   return nullptr;
 }
 
 int CPDF_DIBSource::StratLoadMask() {
   m_MatteColor = 0XFFFFFFFF;
   m_pMaskStream = m_pDict->GetStreamBy("SMask");
   if (m_pMaskStream) {
     CPDF_Array* pMatte = m_pMaskStream->GetDict()->GetArrayBy("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->GetElementValue("Mask"));
+  m_pMaskStream = ToStream(m_pDict->GetDirectObjectBy("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->GetElementValue("Filter");
+  CPDF_Object* pFilter = m_pDict->GetDirectObjectBy("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 689 matching lines @@
                                    IFX_Pause* pPause) {
   return LoadHandle->Continue(pPause);
 }
 
 CPDF_ImageLoader::~CPDF_ImageLoader() {
   if (!m_bCached) {
     delete m_pBitmap;
     delete m_pMask;
   }
 }