Remove FX_DWORD from core/ and delete definition

core/fxcrt/fx_basic_buffer.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 <algorithm>
 #include <limits>
 
 #include "core/fxcrt/include/fx_basic.h"
@@ skipping 98 matching lines @@
   return *this;
 }
 
 CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(int i) {
   char buf[32];
   FXSYS_itoa(i, buf, 10);
   AppendBlock(buf, FXSYS_strlen(buf));
   return *this;
 }
 
-CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(FX_DWORD i) {
+CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(uint32_t i) {
   char buf[32];
   FXSYS_itoa(i, buf, 10);
   AppendBlock(buf, FXSYS_strlen(buf));
   return *this;
 }
 
 CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(double f) {
   char buf[32];
   FX_STRSIZE len = FX_ftoa((FX_FLOAT)f, buf);
   AppendBlock(buf, len);
@@ skipping 71 matching lines @@
   return *this;
 }
 CFX_ArchiveSaver& CFX_ArchiveSaver::operator<<(int i) {
   if (m_pStream) {
     m_pStream->WriteBlock(&i, sizeof(int));
   } else {
     m_SavingBuf.AppendBlock(&i, sizeof(int));
   }
   return *this;
 }
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator<<(FX_DWORD i) {
+CFX_ArchiveSaver& CFX_ArchiveSaver::operator<<(uint32_t i) {
   if (m_pStream) {
-    m_pStream->WriteBlock(&i, sizeof(FX_DWORD));
+    m_pStream->WriteBlock(&i, sizeof(uint32_t));
   } else {
-    m_SavingBuf.AppendBlock(&i, sizeof(FX_DWORD));
+    m_SavingBuf.AppendBlock(&i, sizeof(uint32_t));
   }
   return *this;
 }
 CFX_ArchiveSaver& CFX_ArchiveSaver::operator<<(FX_FLOAT f) {
   if (m_pStream) {
     m_pStream->WriteBlock(&f, sizeof(FX_FLOAT));
   } else {
     m_SavingBuf.AppendBlock(&f, sizeof(FX_FLOAT));
   }
   return *this;
@@ skipping 24 matching lines @@
   CFX_ByteString encoded = wstr.UTF16LE_Encode();
   return operator<<(encoded);
 }
 void CFX_ArchiveSaver::Write(const void* pData, FX_STRSIZE dwSize) {
   if (m_pStream) {
     m_pStream->WriteBlock(pData, dwSize);
   } else {
     m_SavingBuf.AppendBlock(pData, dwSize);
   }
 }
-CFX_ArchiveLoader::CFX_ArchiveLoader(const uint8_t* pData, FX_DWORD dwSize) {
+CFX_ArchiveLoader::CFX_ArchiveLoader(const uint8_t* pData, uint32_t dwSize) {
   m_pLoadingBuf = pData;
   m_LoadingPos = 0;
   m_LoadingSize = dwSize;
 }
 FX_BOOL CFX_ArchiveLoader::IsEOF() {
   return m_LoadingPos >= m_LoadingSize;
 }
 CFX_ArchiveLoader& CFX_ArchiveLoader::operator>>(uint8_t& i) {
   if (m_LoadingPos >= m_LoadingSize) {
     return *this;
   }
   i = m_pLoadingBuf[m_LoadingPos++];
   return *this;
 }
 CFX_ArchiveLoader& CFX_ArchiveLoader::operator>>(int& i) {
   Read(&i, sizeof(int));
   return *this;
 }
-CFX_ArchiveLoader& CFX_ArchiveLoader::operator>>(FX_DWORD& i) {
-  Read(&i, sizeof(FX_DWORD));
+CFX_ArchiveLoader& CFX_ArchiveLoader::operator>>(uint32_t& i) {
+  Read(&i, sizeof(uint32_t));
   return *this;
 }
 CFX_ArchiveLoader& CFX_ArchiveLoader::operator>>(FX_FLOAT& i) {
   Read(&i, sizeof(FX_FLOAT));
   return *this;
 }
 CFX_ArchiveLoader& CFX_ArchiveLoader::operator>>(CFX_ByteString& str) {
   if (m_LoadingPos + 4 > m_LoadingSize) {
     return *this;
   }
@@ skipping 10 matching lines @@
   return *this;
 }
 CFX_ArchiveLoader& CFX_ArchiveLoader::operator>>(CFX_WideString& str) {
   CFX_ByteString encoded;
   operator>>(encoded);
   str = CFX_WideString::FromUTF16LE(
       reinterpret_cast<const unsigned short*>(encoded.c_str()),
       encoded.GetLength() / sizeof(unsigned short));
   return *this;
 }
-FX_BOOL CFX_ArchiveLoader::Read(void* pBuf, FX_DWORD dwSize) {
+FX_BOOL CFX_ArchiveLoader::Read(void* pBuf, uint32_t dwSize) {
   if (m_LoadingPos + dwSize > m_LoadingSize) {
     return FALSE;
   }
   FXSYS_memcpy(pBuf, m_pLoadingBuf + m_LoadingPos, dwSize);
   m_LoadingPos += dwSize;
   return TRUE;
 }
 #endif  // PDF_ENABLE_XFA
 
-void CFX_BitStream::Init(const uint8_t* pData, FX_DWORD dwSize) {
+void CFX_BitStream::Init(const uint8_t* pData, uint32_t dwSize) {
   m_pData = pData;
   m_BitSize = dwSize * 8;
   m_BitPos = 0;
 }
 void CFX_BitStream::ByteAlign() {
   int mod = m_BitPos % 8;
   if (mod == 0) {
     return;
   }
   m_BitPos += 8 - mod;
 }
-FX_DWORD CFX_BitStream::GetBits(FX_DWORD nBits) {
+uint32_t CFX_BitStream::GetBits(uint32_t nBits) {
   if (nBits > m_BitSize || m_BitPos + nBits > m_BitSize) {
     return 0;
   }
   if (nBits == 1) {
     int bit = (m_pData[m_BitPos / 8] & (1 << (7 - m_BitPos % 8))) ? 1 : 0;
     m_BitPos++;
     return bit;
   }
-  FX_DWORD byte_pos = m_BitPos / 8;
-  FX_DWORD bit_pos = m_BitPos % 8, bit_left = nBits;
-  FX_DWORD result = 0;
+  uint32_t byte_pos = m_BitPos / 8;
+  uint32_t bit_pos = m_BitPos % 8, bit_left = nBits;
+  uint32_t result = 0;
   if (bit_pos) {
     if (8 - bit_pos >= bit_left) {
       result =
           (m_pData[byte_pos] & (0xff >> bit_pos)) >> (8 - bit_pos - bit_left);
       m_BitPos += bit_left;
       return result;
     }
     bit_left -= 8 - bit_pos;
     result = (m_pData[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left;
   }
@@ skipping 50 matching lines @@
     temp_size -= buf_size;
     buffer += buf_size;
   }
   return pdfium::base::checked_cast<int32_t>(size);
 }
 
 int32_t CFX_FileBufferArchive::AppendByte(uint8_t byte) {
   return AppendBlock(&byte, 1);
 }
 
-int32_t CFX_FileBufferArchive::AppendDWord(FX_DWORD i) {
+int32_t CFX_FileBufferArchive::AppendDWord(uint32_t i) {
   char buf[32];
   FXSYS_itoa(i, buf, 10);
   return AppendBlock(buf, (size_t)FXSYS_strlen(buf));
 }
 
 int32_t CFX_FileBufferArchive::AppendString(const CFX_ByteStringC& lpsz) {
   return AppendBlock(lpsz.GetPtr(), lpsz.GetLength());
 }
 
 void CFX_FileBufferArchive::AttachFile(IFX_StreamWrite* pFile) {
   FXSYS_assert(pFile);
   m_pFile = pFile;
 }