Merge to XFA: Member function name refactoring

core/src/fpdfapi/fpdf_page/fpdf_page_func.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 "pageint.h"
 
 #include <limits.h>
 
@@ skipping 482 matching lines @@
   delete m_pSampleStream;
   FX_Free(m_pEncodeInfo);
   FX_Free(m_pDecodeInfo);
 }
 FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj) {
   CPDF_Stream* pStream = pObj->AsStream();
   if (!pStream)
     return false;
 
   CPDF_Dictionary* pDict = pStream->GetDict();
-  CPDF_Array* pSize = pDict->GetArray("Size");
-  CPDF_Array* pEncode = pDict->GetArray("Encode");
-  CPDF_Array* pDecode = pDict->GetArray("Decode");
-  m_nBitsPerSample = pDict->GetInteger("BitsPerSample");
+  CPDF_Array* pSize = pDict->GetArrayBy("Size");
+  CPDF_Array* pEncode = pDict->GetArrayBy("Encode");
+  CPDF_Array* pDecode = pDict->GetArrayBy("Decode");
+  m_nBitsPerSample = pDict->GetIntegerBy("BitsPerSample");
   if (m_nBitsPerSample > 32) {
     return FALSE;
   }
   m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
   m_pSampleStream = new CPDF_StreamAcc;
   m_pSampleStream->LoadAllData(pStream, FALSE);
   m_pEncodeInfo = FX_Alloc(SampleEncodeInfo, m_nInputs);
   FX_SAFE_DWORD nTotalSampleBits = 1;
   for (int i = 0; i < m_nInputs; i++) {
-    m_pEncodeInfo[i].sizes = pSize ? pSize->GetInteger(i) : 0;
+    m_pEncodeInfo[i].sizes = pSize ? pSize->GetIntegerAt(i) : 0;
     if (!pSize && i == 0) {
-      m_pEncodeInfo[i].sizes = pDict->GetInteger("Size");
+      m_pEncodeInfo[i].sizes = pDict->GetIntegerBy("Size");
     }
     nTotalSampleBits *= m_pEncodeInfo[i].sizes;
     if (pEncode) {
-      m_pEncodeInfo[i].encode_min = pEncode->GetFloat(i * 2);
-      m_pEncodeInfo[i].encode_max = pEncode->GetFloat(i * 2 + 1);
+      m_pEncodeInfo[i].encode_min = pEncode->GetFloatAt(i * 2);
+      m_pEncodeInfo[i].encode_max = pEncode->GetFloatAt(i * 2 + 1);
     } else {
       m_pEncodeInfo[i].encode_min = 0;
       if (m_pEncodeInfo[i].sizes == 1) {
         m_pEncodeInfo[i].encode_max = 1;
       } else {
         m_pEncodeInfo[i].encode_max = (FX_FLOAT)m_pEncodeInfo[i].sizes - 1;
       }
     }
   }
   nTotalSampleBits *= m_nBitsPerSample;
   nTotalSampleBits *= m_nOutputs;
   FX_SAFE_DWORD nTotalSampleBytes = nTotalSampleBits;
   nTotalSampleBytes += 7;
   nTotalSampleBytes /= 8;
   if (!nTotalSampleBytes.IsValid() || nTotalSampleBytes.ValueOrDie() == 0 ||
       nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) {
     return FALSE;
   }
   m_pDecodeInfo = FX_Alloc(SampleDecodeInfo, m_nOutputs);
   for (int i = 0; i < m_nOutputs; i++) {
     if (pDecode) {
-      m_pDecodeInfo[i].decode_min = pDecode->GetFloat(2 * i);
-      m_pDecodeInfo[i].decode_max = pDecode->GetFloat(2 * i + 1);
+      m_pDecodeInfo[i].decode_min = pDecode->GetFloatAt(2 * i);
+      m_pDecodeInfo[i].decode_max = pDecode->GetFloatAt(2 * i + 1);
     } else {
       m_pDecodeInfo[i].decode_min = m_pRanges[i * 2];
       m_pDecodeInfo[i].decode_max = m_pRanges[i * 2 + 1];
     }
   }
   return TRUE;
 }
 FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const {
   int pos = 0;
   CFX_FixedBufGrow<FX_FLOAT, 16> encoded_input_buf(m_nInputs);
@@ skipping 122 matching lines @@
 }
 CPDF_ExpIntFunc::~CPDF_ExpIntFunc() {
     FX_Free(m_pBeginValues);
     FX_Free(m_pEndValues);
 }
 FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj) {
   CPDF_Dictionary* pDict = pObj->GetDict();
   if (!pDict) {
     return FALSE;
   }
-  CPDF_Array* pArray0 = pDict->GetArray("C0");
+  CPDF_Array* pArray0 = pDict->GetArrayBy("C0");
   if (m_nOutputs == 0) {
     m_nOutputs = 1;
     if (pArray0) {
       m_nOutputs = pArray0->GetCount();
     }
   }
-  CPDF_Array* pArray1 = pDict->GetArray("C1");
+  CPDF_Array* pArray1 = pDict->GetArrayBy("C1");
   m_pBeginValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
   m_pEndValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
   for (int i = 0; i < m_nOutputs; i++) {
-    m_pBeginValues[i] = pArray0 ? pArray0->GetFloat(i) : 0.0f;
-    m_pEndValues[i] = pArray1 ? pArray1->GetFloat(i) : 1.0f;
+    m_pBeginValues[i] = pArray0 ? pArray0->GetFloatAt(i) : 0.0f;
+    m_pEndValues[i] = pArray1 ? pArray1->GetFloatAt(i) : 1.0f;
   }
-  m_Exponent = pDict->GetFloat("N");
+  m_Exponent = pDict->GetFloatBy("N");
   m_nOrigOutputs = m_nOutputs;
   if (m_nOutputs && m_nInputs > INT_MAX / m_nOutputs) {
     return FALSE;
   }
   m_nOutputs *= m_nInputs;
   return TRUE;
 }
 FX_BOOL CPDF_ExpIntFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const {
   for (int i = 0; i < m_nInputs; i++)
     for (int j = 0; j < m_nOrigOutputs; j++) {
@@ skipping 33 matching lines @@
   FX_Free(m_pEncode);
 }
 FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj) {
   CPDF_Dictionary* pDict = pObj->GetDict();
   if (!pDict) {
     return FALSE;
   }
   if (m_nInputs != kRequiredNumInputs) {
     return FALSE;
   }
-  CPDF_Array* pArray = pDict->GetArray("Functions");
+  CPDF_Array* pArray = pDict->GetArrayBy("Functions");
   if (!pArray) {
     return FALSE;
   }
   FX_DWORD nSubs = pArray->GetCount();
   if (nSubs == 0) {
     return FALSE;
   }
   m_nOutputs = 0;
   for (FX_DWORD i = 0; i < nSubs; i++) {
     CPDF_Object* pSub = pArray->GetElementValue(i);
@@ skipping 13 matching lines @@
       if (m_nOutputs)
         return FALSE;
 
       m_nOutputs = pFunc->CountOutputs();
     }
 
     m_pSubFunctions.push_back(pFunc.release());
   }
   m_pBounds = FX_Alloc(FX_FLOAT, nSubs + 1);
   m_pBounds[0] = m_pDomains[0];
-  pArray = pDict->GetArray("Bounds");
+  pArray = pDict->GetArrayBy("Bounds");
   if (!pArray) {
     return FALSE;
   }
   for (FX_DWORD i = 0; i < nSubs - 1; i++) {
-    m_pBounds[i + 1] = pArray->GetFloat(i);
+    m_pBounds[i + 1] = pArray->GetFloatAt(i);
   }
   m_pBounds[nSubs] = m_pDomains[1];
   m_pEncode = FX_Alloc2D(FX_FLOAT, nSubs, 2);
-  pArray = pDict->GetArray("Encode");
+  pArray = pDict->GetArrayBy("Encode");
   if (!pArray) {
     return FALSE;
   }
   for (FX_DWORD i = 0; i < nSubs * 2; i++) {
-    m_pEncode[i] = pArray->GetFloat(i);
+    m_pEncode[i] = pArray->GetFloatAt(i);
   }
   return TRUE;
 }
 FX_BOOL CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const {
   FX_FLOAT input = inputs[0];
   size_t i;
   for (i = 0; i < m_pSubFunctions.size() - 1; i++)
     if (input < m_pBounds[i + 1]) {
       break;
     }
   if (!m_pSubFunctions[i]) {
     return FALSE;
   }
   input = PDF_Interpolate(input, m_pBounds[i], m_pBounds[i + 1],
                           m_pEncode[i * 2], m_pEncode[i * 2 + 1]);
   int nresults;
   m_pSubFunctions[i]->Call(&input, kRequiredNumInputs, outputs, nresults);
   return TRUE;
 }
 CPDF_Function* CPDF_Function::Load(CPDF_Object* pFuncObj) {
   if (!pFuncObj) {
     return NULL;
   }
   CPDF_Function* pFunc = NULL;
   int type;
   if (CPDF_Stream* pStream = pFuncObj->AsStream()) {
-    type = pStream->GetDict()->GetInteger("FunctionType");
+    type = pStream->GetDict()->GetIntegerBy("FunctionType");
   } else if (CPDF_Dictionary* pDict = pFuncObj->AsDictionary()) {
-    type = pDict->GetInteger("FunctionType");
+    type = pDict->GetIntegerBy("FunctionType");
   } else {
     return NULL;
   }
   if (type == 0) {
     pFunc = new CPDF_SampledFunc;
   } else if (type == 2) {
     pFunc = new CPDF_ExpIntFunc;
   } else if (type == 3) {
     pFunc = new CPDF_StitchFunc;
   } else if (type == 4) {
@@ skipping 12 matching lines @@
   m_pRanges = NULL;
 }
 CPDF_Function::~CPDF_Function() {
   FX_Free(m_pDomains);
   FX_Free(m_pRanges);
 }
 FX_BOOL CPDF_Function::Init(CPDF_Object* pObj) {
   CPDF_Stream* pStream = pObj->AsStream();
   CPDF_Dictionary* pDict = pStream ? pStream->GetDict() : pObj->AsDictionary();
 
-  CPDF_Array* pDomains = pDict->GetArray("Domain");
+  CPDF_Array* pDomains = pDict->GetArrayBy("Domain");
   if (!pDomains)
     return FALSE;
 
   m_nInputs = pDomains->GetCount() / 2;
   if (m_nInputs == 0)
     return FALSE;
 
   m_pDomains = FX_Alloc2D(FX_FLOAT, m_nInputs, 2);
   for (int i = 0; i < m_nInputs * 2; i++) {
-    m_pDomains[i] = pDomains->GetFloat(i);
+    m_pDomains[i] = pDomains->GetFloatAt(i);
   }
-  CPDF_Array* pRanges = pDict->GetArray("Range");
+  CPDF_Array* pRanges = pDict->GetArrayBy("Range");
   m_nOutputs = 0;
   if (pRanges) {
     m_nOutputs = pRanges->GetCount() / 2;
     m_pRanges = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
     for (int i = 0; i < m_nOutputs * 2; i++) {
-      m_pRanges[i] = pRanges->GetFloat(i);
+      m_pRanges[i] = pRanges->GetFloatAt(i);
     }
   }
   FX_DWORD old_outputs = m_nOutputs;
   if (!v_Init(pObj)) {
     return FALSE;
   }
   if (m_pRanges && m_nOutputs > (int)old_outputs) {
     m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);
     if (m_pRanges) {
       FXSYS_memset(m_pRanges + (old_outputs * 2), 0,
@@ skipping 22 matching lines @@
     for (int i = 0; i < m_nOutputs; i++) {
       if (results[i] < m_pRanges[i * 2]) {
         results[i] = m_pRanges[i * 2];
       } else if (results[i] > m_pRanges[i * 2 + 1]) {
         results[i] = m_pRanges[i * 2 + 1];
       }
     }
   }
   return TRUE;
 }