Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_page/fpdf_page_parser_old.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 13 matching lines @@
 #include "core/fpdfapi/fpdf_parser/include/cpdf_number.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_string.h"
 #include "core/fpdfapi/fpdf_parser/include/fpdf_parser_decode.h"
 #include "core/fpdfapi/include/cpdf_modulemgr.h"
 #include "core/fxcrt/include/fx_ext.h"
 #include "core/fxcrt/include/fx_safe_types.h"
 #include "core/include/fxcodec/fx_codec.h"
 
-CPDF_StreamParser::CPDF_StreamParser(const uint8_t* pData, FX_DWORD dwSize) {
+CPDF_StreamParser::CPDF_StreamParser(const uint8_t* pData, uint32_t dwSize) {
   m_pBuf = pData;
   m_Size = dwSize;
   m_Pos = 0;
   m_pLastObj = NULL;
 }
 
 CPDF_StreamParser::~CPDF_StreamParser() {
   if (m_pLastObj) {
     m_pLastObj->Release();
   }
 }
 
-FX_DWORD DecodeAllScanlines(ICodec_ScanlineDecoder* pDecoder,
+uint32_t DecodeAllScanlines(ICodec_ScanlineDecoder* pDecoder,
                             uint8_t*& dest_buf,
-                            FX_DWORD& dest_size) {
+                            uint32_t& dest_size) {
   if (!pDecoder) {
-    return static_cast<FX_DWORD>(-1);
+    return static_cast<uint32_t>(-1);
   }
   int ncomps = pDecoder->CountComps();
   int bpc = pDecoder->GetBPC();
   int width = pDecoder->GetWidth();
   int height = pDecoder->GetHeight();
   int pitch = (width * ncomps * bpc + 7) / 8;
   if (height == 0 || pitch > (1 << 30) / height) {
     delete pDecoder;
-    return static_cast<FX_DWORD>(-1);
+    return static_cast<uint32_t>(-1);
   }
   dest_buf = FX_Alloc2D(uint8_t, pitch, height);
   dest_size = pitch * height;  // Safe since checked alloc returned.
   for (int row = 0; row < height; row++) {
     const uint8_t* pLine = pDecoder->GetScanline(row);
     if (!pLine)
       break;
 
     FXSYS_memcpy(dest_buf + row * pitch, pLine, pitch);
   }
-  FX_DWORD srcoff = pDecoder->GetSrcOffset();
+  uint32_t srcoff = pDecoder->GetSrcOffset();
   delete pDecoder;
   return srcoff;
 }
 
 ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     const CPDF_Dictionary* pParams);
 
-FX_DWORD PDF_DecodeInlineStream(const uint8_t* src_buf,
-                                FX_DWORD limit,
+uint32_t PDF_DecodeInlineStream(const uint8_t* src_buf,
+                                uint32_t limit,
                                 int width,
                                 int height,
                                 CFX_ByteString& decoder,
                                 CPDF_Dictionary* pParam,
                                 uint8_t*& dest_buf,
-                                FX_DWORD& dest_size) {
+                                uint32_t& dest_size) {
   if (decoder == "CCITTFaxDecode" || decoder == "CCF") {
     ICodec_ScanlineDecoder* pDecoder =
         FPDFAPI_CreateFaxDecoder(src_buf, limit, width, height, pParam);
     return DecodeAllScanlines(pDecoder, dest_buf, dest_size);
   }
   if (decoder == "ASCII85Decode" || decoder == "A85") {
     return A85Decode(src_buf, limit, dest_buf, dest_size);
   }
   if (decoder == "ASCIIHexDecode" || decoder == "AHx") {
     return HexDecode(src_buf, limit, dest_buf, dest_size);
@@ skipping 11 matching lines @@
         CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
             src_buf, limit, width, height, 0,
             pParam ? pParam->GetIntegerBy("ColorTransform", 1) : 1);
     return DecodeAllScanlines(pDecoder, dest_buf, dest_size);
   }
   if (decoder == "RunLengthDecode" || decoder == "RL") {
     return RunLengthDecode(src_buf, limit, dest_buf, dest_size);
   }
   dest_size = 0;
   dest_buf = 0;
-  return (FX_DWORD)-1;
+  return (uint32_t)-1;
 }
 
 CPDF_Stream* CPDF_StreamParser::ReadInlineStream(CPDF_Document* pDoc,
                                                  CPDF_Dictionary* pDict,
                                                  CPDF_Object* pCSObj,
                                                  FX_BOOL bDecode) {
   if (m_Pos == m_Size)
     return nullptr;
 
   if (PDFCharIsWhitespace(m_pBuf[m_Pos]))
     m_Pos++;
 
   CFX_ByteString Decoder;
   CPDF_Dictionary* pParam = nullptr;
   CPDF_Object* pFilter = pDict->GetElementValue("Filter");
   if (pFilter) {
     if (CPDF_Array* pArray = pFilter->AsArray()) {
       Decoder = pArray->GetStringAt(0);
       CPDF_Array* pParams = pDict->GetArrayBy("DecodeParms");
       if (pParams)
         pParam = pParams->GetDictAt(0);
     } else {
       Decoder = pFilter->GetString();
       pParam = pDict->GetDictBy("DecodeParms");
     }
   }
-  FX_DWORD width = pDict->GetIntegerBy("Width");
-  FX_DWORD height = pDict->GetIntegerBy("Height");
-  FX_DWORD OrigSize = 0;
+  uint32_t width = pDict->GetIntegerBy("Width");
+  uint32_t height = pDict->GetIntegerBy("Height");
+  uint32_t OrigSize = 0;
   if (pCSObj) {
-    FX_DWORD bpc = pDict->GetIntegerBy("BitsPerComponent");
-    FX_DWORD nComponents = 1;
+    uint32_t bpc = pDict->GetIntegerBy("BitsPerComponent");
+    uint32_t nComponents = 1;
     CPDF_ColorSpace* pCS = pDoc->LoadColorSpace(pCSObj);
     if (!pCS) {
       nComponents = 3;
     } else {
       nComponents = pCS->CountComponents();
       pDoc->GetPageData()->ReleaseColorSpace(pCSObj);
     }
-    FX_DWORD pitch = width;
+    uint32_t pitch = width;
     if (bpc && pitch > INT_MAX / bpc) {
       return NULL;
     }
     pitch *= bpc;
     if (nComponents && pitch > INT_MAX / nComponents) {
       return NULL;
     }
     pitch *= nComponents;
     if (pitch > INT_MAX - 7) {
       return NULL;
     }
     pitch += 7;
     pitch /= 8;
     OrigSize = pitch;
   } else {
     if (width > INT_MAX - 7) {
       return NULL;
     }
     OrigSize = ((width + 7) / 8);
   }
   if (height && OrigSize > INT_MAX / height) {
     return NULL;
   }
   OrigSize *= height;
   uint8_t* pData = NULL;
-  FX_DWORD dwStreamSize;
+  uint32_t dwStreamSize;
   if (Decoder.IsEmpty()) {
     if (OrigSize > m_Size - m_Pos) {
       OrigSize = m_Size - m_Pos;
     }
     pData = FX_Alloc(uint8_t, OrigSize);
     FXSYS_memcpy(pData, m_pBuf + m_Pos, OrigSize);
     dwStreamSize = OrigSize;
     m_Pos += OrigSize;
   } else {
-    FX_DWORD dwDestSize = OrigSize;
+    uint32_t dwDestSize = OrigSize;
     dwStreamSize =
         PDF_DecodeInlineStream(m_pBuf + m_Pos, m_Size - m_Pos, width, height,
                                Decoder, pParam, pData, dwDestSize);
     if ((int)dwStreamSize < 0) {
       FX_Free(pData);
       return NULL;
     }
     if (bDecode) {
       m_Pos += dwStreamSize;
       dwStreamSize = dwDestSize;
       if (CPDF_Array* pArray = pFilter->AsArray()) {
         pArray->RemoveAt(0);
         CPDF_Array* pParams = pDict->GetArrayBy("DecodeParms");
         if (pParams)
           pParams->RemoveAt(0);
       } else {
         pDict->RemoveAt("Filter");
         pDict->RemoveAt("DecodeParms");
       }
     } else {
       FX_Free(pData);
-      FX_DWORD dwSavePos = m_Pos;
+      uint32_t dwSavePos = m_Pos;
       m_Pos += dwStreamSize;
       while (1) {
-        FX_DWORD dwPrevPos = m_Pos;
+        uint32_t dwPrevPos = m_Pos;
         CPDF_StreamParser::SyntaxType type = ParseNextElement();
         if (type == CPDF_StreamParser::EndOfData) {
           break;
         }
         if (type != CPDF_StreamParser::Keyword) {
           dwStreamSize += m_Pos - dwPrevPos;
           continue;
         }
         if (GetWordSize() == 2 && GetWordBuf()[0] == 'E' &&
             GetWordBuf()[1] == 'I') {
@@ skipping 91 matching lines @@
   } else if (m_WordSize == 5) {
     if (memcmp(m_WordBuffer, "false", 5) == 0) {
       m_pLastObj = new CPDF_Boolean(FALSE);
       return Others;
     }
   }
   return Keyword;
 }
 
 void CPDF_StreamParser::SkipPathObject() {
-  FX_DWORD command_startpos = m_Pos;
+  uint32_t command_startpos = m_Pos;
   if (!PositionIsInBounds())
     return;
 
   int ch = m_pBuf[m_Pos++];
   while (1) {
     while (PDFCharIsWhitespace(ch)) {
       if (!PositionIsInBounds())
         return;
       ch = m_pBuf[m_Pos++];
     }
@@ skipping 12 matching lines @@
 
       while (PDFCharIsWhitespace(ch)) {
         if (!PositionIsInBounds())
           return;
         ch = m_pBuf[m_Pos++];
       }
 
       if (PDFCharIsNumeric(ch))
         continue;
 
-      FX_DWORD op_startpos = m_Pos - 1;
+      uint32_t op_startpos = m_Pos - 1;
       while (!PDFCharIsWhitespace(ch) && !PDFCharIsDelimiter(ch)) {
         if (!PositionIsInBounds())
           return;
         ch = m_pBuf[m_Pos++];
       }
 
       if (IsPathOperator(&m_pBuf[op_startpos], m_Pos - 1 - op_startpos)) {
         command_startpos = m_Pos;
         break;
       }
@@ skipping 422 matching lines @@
           for (const auto& stream : m_StreamArray) {
             safeSize += stream->GetSize();
             safeSize += 1;
           }
           if (!safeSize.IsValid()) {
             m_Status = Done;
             return;
           }
           m_Size = safeSize.ValueOrDie();
           m_pData = FX_Alloc(uint8_t, m_Size);
-          FX_DWORD pos = 0;
+          uint32_t pos = 0;
           for (const auto& stream : m_StreamArray) {
             FXSYS_memcpy(m_pData + pos, stream->GetData(), stream->GetSize());
             pos += stream->GetSize();
             m_pData[pos++] = ' ';
           }
           m_StreamArray.clear();
         } else {
           m_pData = (uint8_t*)m_pSingleStream->GetData();
           m_Size = m_pSingleStream->GetSize();
         }
@@ skipping 63 matching lines @@
       }
       m_Status = Done;
       return;
     }
     steps++;
     if (pPause && pPause->NeedToPauseNow()) {
       break;
     }
   }
 }