Remove FX_DWORD from core/ and delete definition

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 472 matching lines @@
   }
   return TRUE;
 }
 static FX_FLOAT PDF_Interpolate(FX_FLOAT x,
                                 FX_FLOAT xmin,
                                 FX_FLOAT xmax,
                                 FX_FLOAT ymin,
                                 FX_FLOAT ymax) {
   return ((x - xmin) * (ymax - ymin) / (xmax - xmin)) + ymin;
 }
-static FX_DWORD _GetBits32(const uint8_t* pData, int bitpos, int nbits) {
+static uint32_t _GetBits32(const uint8_t* pData, int bitpos, int nbits) {
   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;
 }
 typedef struct {
   FX_FLOAT encode_max, encode_min;
   int sizes;
 } SampleEncodeInfo;
 typedef struct { FX_FLOAT decode_max, decode_min; } SampleDecodeInfo;
 
 class CPDF_SampledFunc : public CPDF_Function {
  public:
   CPDF_SampledFunc();
   ~CPDF_SampledFunc() override;
 
   // CPDF_Function
   FX_BOOL v_Init(CPDF_Object* pObj) override;
   FX_BOOL v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const override;
 
   SampleEncodeInfo* m_pEncodeInfo;
   SampleDecodeInfo* m_pDecodeInfo;
-  FX_DWORD m_nBitsPerSample;
-  FX_DWORD m_SampleMax;
+  uint32_t m_nBitsPerSample;
+  uint32_t m_SampleMax;
   CPDF_StreamAcc* m_pSampleStream;
 };
 
 CPDF_SampledFunc::CPDF_SampledFunc() : CPDF_Function(Type::kType0Sampled) {
   m_pSampleStream = NULL;
   m_pEncodeInfo = NULL;
   m_pDecodeInfo = NULL;
 }
 
 CPDF_SampledFunc::~CPDF_SampledFunc() {
@@ skipping 95 matching lines @@
   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 (int j = 0; j < m_nOutputs; j++) {
-    FX_DWORD sample =
+    uint32_t sample =
         _GetBits32(pSampleData, bitpos.ValueOrDie() + j * m_nBitsPerSample,
                    m_nBitsPerSample);
     FX_FLOAT encoded = (FX_FLOAT)sample;
     for (int i = 0; i < m_nInputs; i++) {
       if (index[i] == m_pEncodeInfo[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;
         }
-        FX_DWORD sample1 =
+        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);
   }
   return TRUE;
@@ skipping 99 matching lines @@
   if (!pDict) {
     return FALSE;
   }
   if (m_nInputs != kRequiredNumInputs) {
     return FALSE;
   }
   CPDF_Array* pArray = pDict->GetArrayBy("Functions");
   if (!pArray) {
     return FALSE;
   }
-  FX_DWORD nSubs = pArray->GetCount();
+  uint32_t nSubs = pArray->GetCount();
   if (nSubs == 0) {
     return FALSE;
   }
   m_nOutputs = 0;
-  for (FX_DWORD i = 0; i < nSubs; i++) {
+  for (uint32_t i = 0; i < nSubs; i++) {
     CPDF_Object* pSub = pArray->GetElementValue(i);
     if (pSub == pObj) {
       return FALSE;
     }
     std::unique_ptr<CPDF_Function> pFunc(CPDF_Function::Load(pSub));
     if (!pFunc) {
       return FALSE;
     }
     // Check that the input dimensionality is 1, and that all output
     // dimensionalities are the same.
     if (pFunc->CountInputs() != kRequiredNumInputs) {
       return FALSE;
     }
     if (pFunc->CountOutputs() != m_nOutputs) {
       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->GetArrayBy("Bounds");
   if (!pArray) {
     return FALSE;
   }
-  for (FX_DWORD i = 0; i < nSubs - 1; i++) {
+  for (uint32_t i = 0; i < nSubs - 1; i++) {
     m_pBounds[i + 1] = pArray->GetFloatAt(i);
   }
   m_pBounds[nSubs] = m_pDomains[1];
   m_pEncode = FX_Alloc2D(FX_FLOAT, nSubs, 2);
   pArray = pDict->GetArrayBy("Encode");
   if (!pArray) {
     return FALSE;
   }
-  for (FX_DWORD i = 0; i < nSubs * 2; i++) {
+  for (uint32_t i = 0; i < nSubs * 2; 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;
@@ skipping 66 matching lines @@
   }
   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->GetFloatAt(i);
     }
   }
-  FX_DWORD old_outputs = m_nOutputs;
+  uint32_t 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,
                    sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
     }
   }
@@ skipping 19 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;
 }