Remove FX_DWORD from core/ and delete definition

core/fxcodec/codec/fx_codec_fax.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/fxcodec/codec/codec_int.h"
 #include "core/include/fxcodec/fx_codec.h"
 
 namespace {
@@ skipping 239 matching lines @@
     0x16,       2240 % 256, 2240 / 256, 0x17,       2304 % 256, 2304 / 256,
     0x1c,       2368 % 256, 2368 / 256, 0x1d,       2432 % 256, 2432 / 256,
     0x1e,       2496 % 256, 2496 / 256, 0x1f,       2560 % 256, 2560 / 256,
     0xff,
 };
 
 int FaxGetRun(const uint8_t* ins_array,
               const uint8_t* src_buf,
               int& bitpos,
               int bitsize) {
-  FX_DWORD code = 0;
+  uint32_t code = 0;
   int ins_off = 0;
   while (1) {
     uint8_t ins = ins_array[ins_off++];
     if (ins == 0xff) {
       return -1;
     }
     if (bitpos >= bitsize) {
       return -1;
     }
     code <<= 1;
@@ skipping 324 matching lines @@
 }
 
 }  // namespace
 
 class CCodec_FaxDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_FaxDecoder();
   ~CCodec_FaxDecoder() override;
 
   FX_BOOL Create(const uint8_t* src_buf,
-                 FX_DWORD src_size,
+                 uint32_t src_size,
                  int width,
                  int height,
                  int K,
                  FX_BOOL EndOfLine,
                  FX_BOOL EncodedByteAlign,
                  FX_BOOL BlackIs1,
                  int Columns,
                  int Rows);
 
   // 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;
+  uint32_t GetSrcOffset() override;
 
   int m_Encoding, m_bEndOfLine, m_bByteAlign, m_bBlack;
   int bitpos;
   const uint8_t* m_pSrcBuf;
-  FX_DWORD m_SrcSize;
+  uint32_t m_SrcSize;
   uint8_t* m_pScanlineBuf;
   uint8_t* m_pRefBuf;
 };
 
 CCodec_FaxDecoder::CCodec_FaxDecoder() {
   m_pScanlineBuf = NULL;
   m_pRefBuf = NULL;
 }
 CCodec_FaxDecoder::~CCodec_FaxDecoder() {
   FX_Free(m_pScanlineBuf);
   FX_Free(m_pRefBuf);
 }
 FX_BOOL CCodec_FaxDecoder::Create(const uint8_t* src_buf,
-                                  FX_DWORD src_size,
+                                  uint32_t src_size,
                                   int width,
                                   int height,
                                   int K,
                                   FX_BOOL EndOfLine,
                                   FX_BOOL EncodedByteAlign,
                                   FX_BOOL BlackIs1,
                                   int Columns,
                                   int Rows) {
   m_Encoding = K;
   m_bEndOfLine = EndOfLine;
   m_bByteAlign = EncodedByteAlign;
   m_bBlack = BlackIs1;
   m_OrigWidth = Columns;
   m_OrigHeight = Rows;
   if (m_OrigWidth == 0) {
     m_OrigWidth = width;
   }
   if (m_OrigHeight == 0) {
     m_OrigHeight = height;
   }
   // Should not overflow. Checked by FPDFAPI_CreateFaxDecoder.
-  m_Pitch = (static_cast<FX_DWORD>(m_OrigWidth) + 31) / 32 * 4;
+  m_Pitch = (static_cast<uint32_t>(m_OrigWidth) + 31) / 32 * 4;
   m_OutputWidth = m_OrigWidth;
   m_OutputHeight = m_OrigHeight;
   m_pScanlineBuf = FX_Alloc(uint8_t, m_Pitch);
   m_pRefBuf = FX_Alloc(uint8_t, m_Pitch);
   m_pSrcBuf = src_buf;
   m_SrcSize = src_size;
   m_nComps = 1;
   m_bpc = 1;
   m_bColorTransformed = FALSE;
   return TRUE;
@@ skipping 39 matching lines @@
         m_bByteAlign = FALSE;
       } else {
         bitpos0++;
       }
     }
     if (m_bByteAlign) {
       bitpos = bitpos1;
     }
   }
   if (m_bBlack) {
-    for (FX_DWORD i = 0; i < m_Pitch; i++) {
+    for (uint32_t i = 0; i < m_Pitch; i++) {
       m_pScanlineBuf[i] = ~m_pScanlineBuf[i];
     }
   }
   return m_pScanlineBuf;
 }
-FX_DWORD CCodec_FaxDecoder::GetSrcOffset() {
-  FX_DWORD ret = (bitpos + 7) / 8;
+uint32_t CCodec_FaxDecoder::GetSrcOffset() {
+  uint32_t ret = (bitpos + 7) / 8;
   if (ret > m_SrcSize) {
     ret = m_SrcSize;
   }
   return ret;
 }
 
 void FaxG4Decode(const uint8_t* src_buf,
-                 FX_DWORD src_size,
+                 uint32_t src_size,
                  int* pbitpos,
                  uint8_t* dest_buf,
                  int width,
                  int height,
                  int pitch) {
   if (pitch == 0) {
     pitch = (width + 7) / 8;
   }
   uint8_t* ref_buf = FX_Alloc(uint8_t, pitch);
   FXSYS_memset(ref_buf, 0xff, pitch);
   int bitpos = *pbitpos;
   for (int iRow = 0; iRow < height; iRow++) {
     uint8_t* line_buf = dest_buf + iRow * pitch;
     FXSYS_memset(line_buf, 0xff, pitch);
     FaxG4GetRow(src_buf, src_size << 3, bitpos, line_buf, ref_buf, width);
     FXSYS_memcpy(ref_buf, line_buf, pitch);
   }
   FX_Free(ref_buf);
   *pbitpos = bitpos;
 }
 
 class CCodec_FaxEncoder {
  public:
   CCodec_FaxEncoder(const uint8_t* src_buf, int width, int height, int pitch);
   ~CCodec_FaxEncoder();
-  void Encode(uint8_t*& dest_buf, FX_DWORD& dest_size);
+  void Encode(uint8_t*& dest_buf, uint32_t& dest_size);
   void Encode2DLine(const uint8_t* scan_line);
   CFX_BinaryBuf m_DestBuf;
   uint8_t* m_pRefLine;
   uint8_t* m_pLineBuf;
   int m_Cols, m_Rows, m_Pitch;
   const uint8_t* m_pSrcBuf;
 };
 CCodec_FaxEncoder::CCodec_FaxEncoder(const uint8_t* src_buf,
                                      int width,
                                      int height,
                                      int pitch) {
   m_pSrcBuf = src_buf;
   m_Cols = width;
   m_Rows = height;
   m_Pitch = pitch;
   m_pRefLine = FX_Alloc(uint8_t, m_Pitch);
   FXSYS_memset(m_pRefLine, 0xff, m_Pitch);
   m_pLineBuf = FX_Alloc2D(uint8_t, m_Pitch, 8);
   m_DestBuf.EstimateSize(0, 10240);
 }
 CCodec_FaxEncoder::~CCodec_FaxEncoder() {
   FX_Free(m_pRefLine);
   FX_Free(m_pLineBuf);
 }
-void CCodec_FaxEncoder::Encode(uint8_t*& dest_buf, FX_DWORD& dest_size) {
+void CCodec_FaxEncoder::Encode(uint8_t*& dest_buf, uint32_t& dest_size) {
   int dest_bitpos = 0;
   uint8_t last_byte = 0;
   for (int i = 0; i < m_Rows; i++) {
     const uint8_t* scan_line = m_pSrcBuf + i * m_Pitch;
     FXSYS_memset(m_pLineBuf, 0, m_Pitch * 8);
     m_pLineBuf[0] = last_byte;
     FaxEncode2DLine(m_pLineBuf, dest_bitpos, scan_line, m_pRefLine, m_Cols);
     m_DestBuf.AppendBlock(m_pLineBuf, dest_bitpos / 8);
     last_byte = m_pLineBuf[dest_bitpos / 8];
     dest_bitpos %= 8;
     FXSYS_memcpy(m_pRefLine, scan_line, m_Pitch);
   }
   if (dest_bitpos) {
     m_DestBuf.AppendByte(last_byte);
   }
   dest_size = m_DestBuf.GetSize();
   dest_buf = m_DestBuf.DetachBuffer();
 }
 FX_BOOL CCodec_FaxModule::Encode(const uint8_t* src_buf,
                                  int width,
                                  int height,
                                  int pitch,
                                  uint8_t*& dest_buf,
-                                 FX_DWORD& dest_size) {
+                                 uint32_t& dest_size) {
   CCodec_FaxEncoder encoder(src_buf, width, height, pitch);
   encoder.Encode(dest_buf, dest_size);
   return TRUE;
 }
 ICodec_ScanlineDecoder* CCodec_FaxModule::CreateDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     int K,
     FX_BOOL EndOfLine,
     FX_BOOL EncodedByteAlign,
     FX_BOOL BlackIs1,
     int Columns,
     int Rows) {
   CCodec_FaxDecoder* pDecoder = new CCodec_FaxDecoder;
   pDecoder->Create(src_buf, src_size, width, height, K, EndOfLine,
                    EncodedByteAlign, BlackIs1, Columns, Rows);
   return pDecoder;
 }