Remove FX_DWORD from core/ and delete definition

core/fxcodec/codec/fx_codec.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/include/fxcodec/fx_codec.h"
 
 #include <cmath>
 #include <utility>
@@ skipping 14 matching lines @@
       m_pPngModule(new CCodec_PngModule),
       m_pGifModule(new CCodec_GifModule),
       m_pBmpModule(new CCodec_BmpModule),
       m_pTiffModule(new CCodec_TiffModule),
 #endif  // PDF_ENABLE_XFA
       m_pFlateModule(new CCodec_FlateModule) {
 }
 
 CCodec_ScanlineDecoder::ImageDataCache::ImageDataCache(int width,
                                                        int height,
-                                                       FX_DWORD pitch)
+                                                       uint32_t pitch)
     : m_Width(width), m_Height(height), m_Pitch(pitch), m_nCachedLines(0) {}
 
 CCodec_ScanlineDecoder::ImageDataCache::~ImageDataCache() {}
 
 bool CCodec_ScanlineDecoder::ImageDataCache::AllocateCache() {
   if (m_Pitch == 0 || m_Height < 0)
     return false;
 
   FX_SAFE_SIZE_T size = m_Pitch;
   size *= m_Height;
@@ skipping 94 matching lines @@
 
   std::unique_ptr<ImageDataCache> cache(
       new ImageDataCache(m_OutputWidth, m_OutputHeight, m_Pitch));
   if (!cache->AllocateCache())
     return;
 
   m_pDataCache = std::move(cache);
 }
 
 FX_BOOL CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf,
-                                            FX_DWORD src_size,
+                                            uint32_t src_size,
                                             uint8_t*& dest_buf,
-                                            FX_DWORD& dest_size) {
+                                            uint32_t& dest_size) {
   return FALSE;
 }
 
 #define EXPONENT_DETECT(ptr)                 \
   for (;; ptr++) {                           \
     if (!std::isdigit(*ptr)) {               \
       if (endptr)                            \
         *endptr = (char*)ptr;                \
       break;                                 \
     } else {                                 \
@@ skipping 86 matching lines @@
   } else {
     while (exp_ret--) {
       ret /= 10.0;
     }
   }
   return is_negative ? -ret : ret;
 }
 #undef EXPONENT_DETECT
 
 FX_BOOL CCodec_BasicModule::A85Encode(const uint8_t* src_buf,
-                                      FX_DWORD src_size,
+                                      uint32_t src_size,
                                       uint8_t*& dest_buf,
-                                      FX_DWORD& dest_size) {
+                                      uint32_t& dest_size) {
   return FALSE;
 }
 
 #ifdef PDF_ENABLE_XFA
 CFX_DIBAttribute::CFX_DIBAttribute()
     : m_nXDPI(-1),
       m_nYDPI(-1),
       m_fAspectRatio(-1.0f),
       m_wDPIUnit(0),
       m_nGifLeft(0),
       m_nGifTop(0),
       m_pGifLocalPalette(nullptr),
       m_nGifLocalPalNum(0),
       m_nBmpCompressType(0) {
   FXSYS_memset(m_strTime, 0, sizeof(m_strTime));
 }
 CFX_DIBAttribute::~CFX_DIBAttribute() {
   for (const auto& pair : m_Exif)
     FX_Free(pair.second);
 }
 #endif  // PDF_ENABLE_XFA
 
 class CCodec_RLScanlineDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_RLScanlineDecoder();
   ~CCodec_RLScanlineDecoder() override;
 
   FX_BOOL Create(const uint8_t* src_buf,
-                 FX_DWORD src_size,
+                 uint32_t src_size,
                  int width,
                  int height,
                  int nComps,
                  int bpc);
 
   // CCodec_ScanlineDecoder
   void v_DownScale(int dest_width, int dest_height) override {}
   FX_BOOL v_Rewind() override;
   uint8_t* v_GetNextLine() override;
-  FX_DWORD GetSrcOffset() override { return m_SrcOffset; }
+  uint32_t GetSrcOffset() override { return m_SrcOffset; }
 
  protected:
   FX_BOOL CheckDestSize();
   void GetNextOperator();
   void UpdateOperator(uint8_t used_bytes);
 
   uint8_t* m_pScanline;
   const uint8_t* m_pSrcBuf;
-  FX_DWORD m_SrcSize;
-  FX_DWORD m_dwLineBytes;
-  FX_DWORD m_SrcOffset;
+  uint32_t m_SrcSize;
+  uint32_t m_dwLineBytes;
+  uint32_t m_SrcOffset;
   FX_BOOL m_bEOD;
   uint8_t m_Operator;
 };
 CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder()
     : m_pScanline(NULL),
       m_pSrcBuf(NULL),
       m_SrcSize(0),
       m_dwLineBytes(0),
       m_SrcOffset(0),
       m_bEOD(FALSE),
       m_Operator(0) {}
 CCodec_RLScanlineDecoder::~CCodec_RLScanlineDecoder() {
   FX_Free(m_pScanline);
 }
 FX_BOOL CCodec_RLScanlineDecoder::CheckDestSize() {
-  FX_DWORD i = 0;
-  FX_DWORD old_size = 0;
-  FX_DWORD dest_size = 0;
+  uint32_t i = 0;
+  uint32_t old_size = 0;
+  uint32_t dest_size = 0;
   while (i < m_SrcSize) {
     if (m_pSrcBuf[i] < 128) {
       old_size = dest_size;
       dest_size += m_pSrcBuf[i] + 1;
       if (dest_size < old_size) {
         return FALSE;
       }
       i += m_pSrcBuf[i] + 2;
     } else if (m_pSrcBuf[i] > 128) {
       old_size = dest_size;
       dest_size += 257 - m_pSrcBuf[i];
       if (dest_size < old_size) {
         return FALSE;
       }
       i += 2;
     } else {
       break;
     }
   }
-  if (((FX_DWORD)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 >
+  if (((uint32_t)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 >
       dest_size) {
     return FALSE;
   }
   return TRUE;
 }
 FX_BOOL CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf,
-                                         FX_DWORD src_size,
+                                         uint32_t src_size,
                                          int width,
                                          int height,
                                          int nComps,
                                          int bpc) {
   m_pSrcBuf = src_buf;
   m_SrcSize = src_size;
   m_OutputWidth = m_OrigWidth = width;
   m_OutputHeight = m_OrigHeight = height;
   m_nComps = nComps;
   m_bpc = bpc;
   m_bColorTransformed = FALSE;
   m_DownScale = 1;
   // Aligning the pitch to 4 bytes requires an integer overflow check.
   FX_SAFE_DWORD pitch = width;
   pitch *= nComps;
   pitch *= bpc;
   pitch += 31;
   pitch /= 32;
   pitch *= 4;
   if (!pitch.IsValid()) {
     return FALSE;
   }
   m_Pitch = pitch.ValueOrDie();
   // Overflow should already have been checked before this is called.
-  m_dwLineBytes = (static_cast<FX_DWORD>(width) * nComps * bpc + 7) / 8;
+  m_dwLineBytes = (static_cast<uint32_t>(width) * nComps * bpc + 7) / 8;
   m_pScanline = FX_Alloc(uint8_t, m_Pitch);
   return CheckDestSize();
 }
 FX_BOOL CCodec_RLScanlineDecoder::v_Rewind() {
   FXSYS_memset(m_pScanline, 0, m_Pitch);
   m_SrcOffset = 0;
   m_bEOD = FALSE;
   m_Operator = 0;
   return TRUE;
 }
 uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine() {
   if (m_SrcOffset == 0) {
     GetNextOperator();
   } else {
     if (m_bEOD) {
       return NULL;
     }
   }
   FXSYS_memset(m_pScanline, 0, m_Pitch);
-  FX_DWORD col_pos = 0;
+  uint32_t col_pos = 0;
   FX_BOOL eol = FALSE;
   while (m_SrcOffset < m_SrcSize && !eol) {
     if (m_Operator < 128) {
-      FX_DWORD copy_len = m_Operator + 1;
+      uint32_t copy_len = m_Operator + 1;
       if (col_pos + copy_len >= m_dwLineBytes) {
         copy_len = m_dwLineBytes - col_pos;
         eol = TRUE;
       }
       if (copy_len >= m_SrcSize - m_SrcOffset) {
         copy_len = m_SrcSize - m_SrcOffset;
         m_bEOD = TRUE;
       }
       FXSYS_memcpy(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len);
       col_pos += copy_len;
       UpdateOperator((uint8_t)copy_len);
     } else if (m_Operator > 128) {
       int fill = 0;
       if (m_SrcOffset - 1 < m_SrcSize - 1) {
         fill = m_pSrcBuf[m_SrcOffset];
       }
-      FX_DWORD duplicate_len = 257 - m_Operator;
+      uint32_t duplicate_len = 257 - m_Operator;
       if (col_pos + duplicate_len >= m_dwLineBytes) {
         duplicate_len = m_dwLineBytes - col_pos;
         eol = TRUE;
       }
       FXSYS_memset(m_pScanline + col_pos, fill, duplicate_len);
       col_pos += duplicate_len;
       UpdateOperator((uint8_t)duplicate_len);
     } else {
       m_bEOD = TRUE;
       break;
     }
   }
   return m_pScanline;
 }
 void CCodec_RLScanlineDecoder::GetNextOperator() {
   if (m_SrcOffset >= m_SrcSize) {
     m_Operator = 128;
     return;
   }
   m_Operator = m_pSrcBuf[m_SrcOffset];
   m_SrcOffset++;
 }
 void CCodec_RLScanlineDecoder::UpdateOperator(uint8_t used_bytes) {
   if (used_bytes == 0) {
     return;
   }
   if (m_Operator < 128) {
-    FXSYS_assert((FX_DWORD)m_Operator + 1 >= used_bytes);
+    FXSYS_assert((uint32_t)m_Operator + 1 >= used_bytes);
     if (used_bytes == m_Operator + 1) {
       m_SrcOffset += used_bytes;
       GetNextOperator();
       return;
     }
     m_Operator -= used_bytes;
     m_SrcOffset += used_bytes;
     if (m_SrcOffset >= m_SrcSize) {
       m_Operator = 128;
     }
     return;
   }
   uint8_t count = 257 - m_Operator;
-  FXSYS_assert((FX_DWORD)count >= used_bytes);
+  FXSYS_assert((uint32_t)count >= used_bytes);
   if (used_bytes == count) {
     m_SrcOffset++;
     GetNextOperator();
     return;
   }
   count -= used_bytes;
   m_Operator = 257 - count;
 }
 ICodec_ScanlineDecoder* CCodec_BasicModule::CreateRunLengthDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     int nComps,
     int bpc) {
   CCodec_RLScanlineDecoder* pRLScanlineDecoder = new CCodec_RLScanlineDecoder;
   if (!pRLScanlineDecoder->Create(src_buf, src_size, width, height, nComps,
                                   bpc)) {
     delete pRLScanlineDecoder;
     return NULL;
   }
   return pRLScanlineDecoder;
 }