Fix the Skia build after 9b1a0ee.

core/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 "core/fpdfapi/fpdf_page/pageint.h"
 
 #include <limits.h>
 
@@ skipping 497 matching lines @@
   int result = 0;
   for (int i = 0; i < nbits; i++) {
     if (pData[(bitpos + i) / 8] & (1 << (7 - (bitpos + i) % 8)))
       result |= 1 << (nbits - i - 1);
   }
   return result;
 }
 
 class CPDF_PSFunc : public CPDF_Function {
  public:
-  CPDF_PSFunc() {}
+  CPDF_PSFunc() : CPDF_Function(Type::kType4PostScript) {}
   ~CPDF_PSFunc() override {}
 
   // CPDF_Function
   FX_BOOL v_Init(CPDF_Object* pObj) override;
   FX_BOOL v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const override;
 
  private:
   CPDF_PSEngine m_PS;
 };
 
@@ skipping 12 matching lines @@
   PS.Execute();
   if (PS.GetStackSize() < m_nOutputs)
     return FALSE;
   for (uint32_t i = 0; i < m_nOutputs; i++)
     results[m_nOutputs - i - 1] = PS.Pop();
   return TRUE;
 }
 
 }  // namespace
 
-CPDF_SampledFunc::CPDF_SampledFunc() {}
+CPDF_SampledFunc::CPDF_SampledFunc() : CPDF_Function(Type::kType0Sampled) {}
 
 CPDF_SampledFunc::~CPDF_SampledFunc() {}
 
 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->GetArrayBy("Size");
   CPDF_Array* pEncode = pDict->GetArrayBy("Encode");
   CPDF_Array* pDecode = pDict->GetArrayBy("Decode");
   m_nBitsPerSample = pDict->GetIntegerBy("BitsPerSample");
   if (!IsValidBitsPerSample(m_nBitsPerSample))
     return FALSE;
 
   m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
   m_pSampleStream.reset(new CPDF_StreamAcc);
   m_pSampleStream->LoadAllData(pStream, FALSE);
   FX_SAFE_UINT32 nTotalSampleBits = 1;
-  m_pEncodeInfo.resize(m_nInputs);
+  m_EncodeInfo.resize(m_nInputs);
   for (uint32_t i = 0; i < m_nInputs; i++) {
-    m_pEncodeInfo[i].sizes = pSize ? pSize->GetIntegerAt(i) : 0;
+    m_EncodeInfo[i].sizes = pSize ? pSize->GetIntegerAt(i) : 0;
     if (!pSize && i == 0)
-      m_pEncodeInfo[i].sizes = pDict->GetIntegerBy("Size");
-    nTotalSampleBits *= m_pEncodeInfo[i].sizes;
+      m_EncodeInfo[i].sizes = pDict->GetIntegerBy("Size");
+    nTotalSampleBits *= m_EncodeInfo[i].sizes;
     if (pEncode) {
-      m_pEncodeInfo[i].encode_min = pEncode->GetFloatAt(i * 2);
-      m_pEncodeInfo[i].encode_max = pEncode->GetFloatAt(i * 2 + 1);
+      m_EncodeInfo[i].encode_min = pEncode->GetFloatAt(i * 2);
+      m_EncodeInfo[i].encode_max = pEncode->GetFloatAt(i * 2 + 1);
     } else {
-      m_pEncodeInfo[i].encode_min = 0;
-      m_pEncodeInfo[i].encode_max = m_pEncodeInfo[i].sizes == 1
-                                        ? 1
-                                        : (FX_FLOAT)m_pEncodeInfo[i].sizes - 1;
+      m_EncodeInfo[i].encode_min = 0;
+      m_EncodeInfo[i].encode_max =
+          m_EncodeInfo[i].sizes == 1 ? 1 : (FX_FLOAT)m_EncodeInfo[i].sizes - 1;
     }
   }
   nTotalSampleBits *= m_nBitsPerSample;
   nTotalSampleBits *= m_nOutputs;
   FX_SAFE_UINT32 nTotalSampleBytes = nTotalSampleBits;
   nTotalSampleBytes += 7;
   nTotalSampleBytes /= 8;
   if (!nTotalSampleBytes.IsValid() || nTotalSampleBytes.ValueOrDie() == 0 ||
       nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) {
     return FALSE;
   }
-  m_pDecodeInfo.resize(m_nOutputs);
+  m_DecodeInfo.resize(m_nOutputs);
   for (uint32_t i = 0; i < m_nOutputs; i++) {
     if (pDecode) {
-      m_pDecodeInfo[i].decode_min = pDecode->GetFloatAt(2 * i);
-      m_pDecodeInfo[i].decode_max = pDecode->GetFloatAt(2 * i + 1);
+      m_DecodeInfo[i].decode_min = pDecode->GetFloatAt(2 * i);
+      m_DecodeInfo[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];
+      m_DecodeInfo[i].decode_min = m_pRanges[i * 2];
+      m_DecodeInfo[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);
   FX_FLOAT* encoded_input = encoded_input_buf;
   CFX_FixedBufGrow<uint32_t, 32> int_buf(m_nInputs * 2);
   uint32_t* index = int_buf;
   uint32_t* blocksize = index + m_nInputs;
   for (uint32_t i = 0; i < m_nInputs; i++) {
     if (i == 0)
       blocksize[i] = 1;
     else
-      blocksize[i] = blocksize[i - 1] * m_pEncodeInfo[i - 1].sizes;
-    encoded_input[i] = PDF_Interpolate(
-        inputs[i], m_pDomains[i * 2], m_pDomains[i * 2 + 1],
-        m_pEncodeInfo[i].encode_min, m_pEncodeInfo[i].encode_max);
+      blocksize[i] = blocksize[i - 1] * m_EncodeInfo[i - 1].sizes;
+    encoded_input[i] =
+        PDF_Interpolate(inputs[i], m_pDomains[i * 2], m_pDomains[i * 2 + 1],
+                        m_EncodeInfo[i].encode_min, m_EncodeInfo[i].encode_max);
     index[i] = std::min((uint32_t)std::max(0.f, encoded_input[i]),
-                        m_pEncodeInfo[i].sizes - 1);
+                        m_EncodeInfo[i].sizes - 1);
     pos += index[i] * blocksize[i];
   }
   FX_SAFE_INT32 bits_to_output = m_nOutputs;
   bits_to_output *= m_nBitsPerSample;
   if (!bits_to_output.IsValid())
     return FALSE;
 
   FX_SAFE_INT32 bitpos = pos;
   bitpos *= bits_to_output.ValueOrDie();
   if (!bitpos.IsValid())
     return FALSE;
 
   FX_SAFE_INT32 range_check = bitpos;
   range_check += bits_to_output.ValueOrDie();
   if (!range_check.IsValid())
     return FALSE;
 
   const uint8_t* pSampleData = m_pSampleStream->GetData();
   if (!pSampleData)
     return FALSE;
 
   for (uint32_t j = 0; j < m_nOutputs; j++) {
     uint32_t sample =
         GetBits32(pSampleData, bitpos.ValueOrDie() + j * m_nBitsPerSample,
                   m_nBitsPerSample);
     FX_FLOAT encoded = (FX_FLOAT)sample;
     for (uint32_t i = 0; i < m_nInputs; i++) {
-      if (index[i] == m_pEncodeInfo[i].sizes - 1) {
+      if (index[i] == m_EncodeInfo[i].sizes - 1) {
         if (index[i] == 0)
           encoded = encoded_input[i] * (FX_FLOAT)sample;
       } else {
         FX_SAFE_INT32 bitpos2 = blocksize[i];
         bitpos2 += pos;
         bitpos2 *= m_nOutputs;
         bitpos2 += j;
         bitpos2 *= m_nBitsPerSample;
         if (!bitpos2.IsValid())
           return FALSE;
         uint32_t sample1 =
             GetBits32(pSampleData, bitpos2.ValueOrDie(), m_nBitsPerSample);
         encoded += (encoded_input[i] - index[i]) *
                    ((FX_FLOAT)sample1 - (FX_FLOAT)sample);
       }
     }
-    results[j] = PDF_Interpolate(encoded, 0, (FX_FLOAT)m_SampleMax,
-                                 m_pDecodeInfo[j].decode_min,
-                                 m_pDecodeInfo[j].decode_max);
+    results[j] =
+        PDF_Interpolate(encoded, 0, (FX_FLOAT)m_SampleMax,
+                        m_DecodeInfo[j].decode_min, m_DecodeInfo[j].decode_max);
   }
   return TRUE;
 }
 
-CPDF_ExpIntFunc::CPDF_ExpIntFunc() {
-  m_pBeginValues = NULL;
-  m_pEndValues = NULL;
-}
+CPDF_ExpIntFunc::CPDF_ExpIntFunc()
+    : CPDF_Function(Type::kType2ExpotentialInterpolation),
+      m_pBeginValues(nullptr),
+      m_pEndValues(nullptr) {}
 
 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;
   }
@@ skipping 23 matching lines @@
   for (uint32_t i = 0; i < m_nInputs; i++)
     for (uint32_t j = 0; j < m_nOrigOutputs; j++) {
       results[i * m_nOrigOutputs + j] =
           m_pBeginValues[j] +
           (FX_FLOAT)FXSYS_pow(inputs[i], m_Exponent) *
               (m_pEndValues[j] - m_pBeginValues[j]);
     }
   return TRUE;
 }
 
-CPDF_StitchFunc::CPDF_StitchFunc() {
-  m_pBounds = NULL;
-  m_pEncode = NULL;
-}
+CPDF_StitchFunc::CPDF_StitchFunc()
+    : CPDF_Function(Type::kType3Stitching),
+      m_pBounds(nullptr),
+      m_pEncode(nullptr) {}
 
 CPDF_StitchFunc::~CPDF_StitchFunc() {
   FX_Free(m_pBounds);
   FX_Free(m_pEncode);
 }
 
 FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj) {
   CPDF_Dictionary* pDict = pObj->GetDict();
   if (!pDict) {
     return FALSE;
@@ skipping 94 matching lines @@
     case 0:
     case 2:
     case 3:
     case 4:
       return static_cast<Type>(iType);
     default:
       return Type::kTypeInvalid;
   }
 }
 
-CPDF_Function::CPDF_Function() {
-  m_pDomains = NULL;
-  m_pRanges = NULL;
-}
+CPDF_Function::CPDF_Function(Type type)
+    : m_pDomains(nullptr), m_pRanges(nullptr), m_Type(type) {}
 
 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();
 
@@ skipping 48 matching lines @@
   if (m_pRanges) {
     for (uint32_t 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;
 }
+
+const CPDF_SampledFunc* CPDF_Function::ToSampledFunc() const {
+  return m_Type == Type::kType0Sampled
+             ? static_cast<const CPDF_SampledFunc*>(this)
+             : nullptr;
+}
+
+const CPDF_ExpIntFunc* CPDF_Function::ToExpIntFunc() const {
+  return m_Type == Type::kType2ExpotentialInterpolation
+             ? static_cast<const CPDF_ExpIntFunc*>(this)
+             : nullptr;
+}
+
+const CPDF_StitchFunc* CPDF_Function::ToStitchFunc() const {
+  return m_Type == Type::kType3Stitching
+             ? static_cast<const CPDF_StitchFunc*>(this)
+             : nullptr;
+}