Remove FX_DWORD from core/ and delete definition

core/fxcrt/include/fx_basic.h

 // 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
 
 #ifndef CORE_FXCRT_INCLUDE_FX_BASIC_H_
 #define CORE_FXCRT_INCLUDE_FX_BASIC_H_
 
 #include <algorithm>
@@ skipping 69 matching lines @@
   std::unique_ptr<uint8_t, FxFreeDeleter> m_pBuffer;
 };
 
 class CFX_ByteTextBuf : public CFX_BinaryBuf {
  public:
   void AppendChar(int ch) { AppendByte((uint8_t)ch); }
   FX_STRSIZE GetLength() const { return m_DataSize; }
   CFX_ByteStringC GetByteString() const;
 
   CFX_ByteTextBuf& operator<<(int i);
-  CFX_ByteTextBuf& operator<<(FX_DWORD i);
+  CFX_ByteTextBuf& operator<<(uint32_t i);
   CFX_ByteTextBuf& operator<<(double f);
   CFX_ByteTextBuf& operator<<(const CFX_ByteStringC& lpsz);
   CFX_ByteTextBuf& operator<<(const CFX_ByteTextBuf& buf);
 };
 
 class CFX_WideTextBuf : public CFX_BinaryBuf {
  public:
   void AppendChar(FX_WCHAR wch);
   FX_STRSIZE GetLength() const { return m_DataSize / sizeof(FX_WCHAR); }
   FX_WCHAR* GetBuffer() const {
@@ skipping 16 matching lines @@
 
 #ifdef PDF_ENABLE_XFA
 class CFX_ArchiveSaver {
  public:
   CFX_ArchiveSaver() : m_pStream(NULL) {}
 
   CFX_ArchiveSaver& operator<<(uint8_t i);
 
   CFX_ArchiveSaver& operator<<(int i);
 
-  CFX_ArchiveSaver& operator<<(FX_DWORD i);
+  CFX_ArchiveSaver& operator<<(uint32_t i);
 
   CFX_ArchiveSaver& operator<<(FX_FLOAT i);
 
   CFX_ArchiveSaver& operator<<(double i);
 
   CFX_ArchiveSaver& operator<<(const CFX_ByteStringC& bstr);
 
   CFX_ArchiveSaver& operator<<(const FX_WCHAR* bstr);
 
   CFX_ArchiveSaver& operator<<(const CFX_WideString& wstr);
 
   void Write(const void* pData, FX_STRSIZE dwSize);
 
   intptr_t GetLength() { return m_SavingBuf.GetSize(); }
 
   const uint8_t* GetBuffer() { return m_SavingBuf.GetBuffer(); }
 
   void SetStream(IFX_FileStream* pStream) { m_pStream = pStream; }
 
  protected:
   CFX_BinaryBuf m_SavingBuf;
 
   IFX_FileStream* m_pStream;
 };
 class CFX_ArchiveLoader {
  public:
-  CFX_ArchiveLoader(const uint8_t* pData, FX_DWORD dwSize);
+  CFX_ArchiveLoader(const uint8_t* pData, uint32_t dwSize);
 
   CFX_ArchiveLoader& operator>>(uint8_t& i);
 
   CFX_ArchiveLoader& operator>>(int& i);
 
-  CFX_ArchiveLoader& operator>>(FX_DWORD& i);
+  CFX_ArchiveLoader& operator>>(uint32_t& i);
 
   CFX_ArchiveLoader& operator>>(FX_FLOAT& i);
 
   CFX_ArchiveLoader& operator>>(double& i);
 
   CFX_ArchiveLoader& operator>>(CFX_ByteString& bstr);
 
   CFX_ArchiveLoader& operator>>(CFX_WideString& wstr);
 
   FX_BOOL IsEOF();
 
-  FX_BOOL Read(void* pBuf, FX_DWORD dwSize);
+  FX_BOOL Read(void* pBuf, uint32_t dwSize);
 
  protected:
-  FX_DWORD m_LoadingPos;
+  uint32_t m_LoadingPos;
 
   const uint8_t* m_pLoadingBuf;
 
-  FX_DWORD m_LoadingSize;
+  uint32_t m_LoadingSize;
 };
 #endif  // PDF_ENABLE_XFA
 
 class CFX_FileBufferArchive {
  public:
   CFX_FileBufferArchive();
   ~CFX_FileBufferArchive();
 
   void Clear();
   bool Flush();
   int32_t AppendBlock(const void* pBuf, size_t size);
   int32_t AppendByte(uint8_t byte);
-  int32_t AppendDWord(FX_DWORD i);
+  int32_t AppendDWord(uint32_t i);
   int32_t AppendString(const CFX_ByteStringC& lpsz);
 
   // |pFile| must outlive the CFX_FileBufferArchive.
   void AttachFile(IFX_StreamWrite* pFile);
 
  private:
   static const size_t kBufSize = 32768;
 
   size_t m_Length;
   std::unique_ptr<uint8_t, FxFreeDeleter> m_pBuffer;
@@ skipping 12 matching lines @@
 };
 
 class CFX_UTF8Decoder {
  public:
   CFX_UTF8Decoder() { m_PendingBytes = 0; }
 
   void Clear();
 
   void Input(uint8_t byte);
 
-  void AppendChar(FX_DWORD ch);
+  void AppendChar(uint32_t ch);
 
   void ClearStatus() { m_PendingBytes = 0; }
 
   CFX_WideStringC GetResult() const { return m_Buffer.GetWideString(); }
 
  protected:
   int m_PendingBytes;
 
-  FX_DWORD m_PendingChar;
+  uint32_t m_PendingChar;
 
   CFX_WideTextBuf m_Buffer;
 };
 
 class CFX_UTF8Encoder {
  public:
   CFX_UTF8Encoder() {}
 
   void Input(FX_WCHAR unicode);
   void AppendStr(const CFX_ByteStringC& str) { m_Buffer << str; }
@@ skipping 379 matching lines @@
   void RemoveAll();
 
   FX_POSITION GetStartPosition() const {
     return (m_nCount == 0) ? NULL : (FX_POSITION)-1;
   }
 
   void GetNextAssoc(FX_POSITION& rNextPosition,
                     void*& rKey,
                     void*& rValue) const;
 
-  FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
+  uint32_t GetHashTableSize() const { return m_nHashTableSize; }
 
-  void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
+  void InitHashTable(uint32_t hashSize, FX_BOOL bAllocNow = TRUE);
 
  protected:
   CAssoc** m_pHashTable;
 
-  FX_DWORD m_nHashTableSize;
+  uint32_t m_nHashTableSize;
 
   int m_nCount;
 
   CAssoc* m_pFreeList;
 
   struct CFX_Plex* m_pBlocks;
 
   int m_nBlockSize;
 
-  FX_DWORD HashKey(void* key) const;
+  uint32_t HashKey(void* key) const;
 
   CAssoc* NewAssoc();
 
   void FreeAssoc(CAssoc* pAssoc);
 
-  CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
+  CAssoc* GetAssocAt(void* key, uint32_t& hash) const;
 };
 
 template <class KeyType, class ValueType>
 class CFX_MapPtrTemplate : public CFX_MapPtrToPtr {
  public:
   CFX_MapPtrTemplate() : CFX_MapPtrToPtr(10) {}
 
   FX_BOOL Lookup(KeyType key, ValueType& rValue) const {
     void* pValue = NULL;
     if (!CFX_MapPtrToPtr::Lookup((void*)(uintptr_t)key, pValue)) {
@@ skipping 117 matching lines @@
   void SetPrivateData(void* module_id,
                       void* pData,
                       PD_CALLBACK_FREEDATA callback);
   void SetPrivateObj(void* module_id, CFX_DestructObject* pObj);
 
   void* GetPrivateData(void* module_id);
   FX_BOOL LookupPrivateData(void* module_id, void*& pData) const {
     if (!module_id) {
       return FALSE;
     }
-    FX_DWORD nCount = m_DataList.GetSize();
-    for (FX_DWORD n = 0; n < nCount; n++) {
+    uint32_t nCount = m_DataList.GetSize();
+    for (uint32_t n = 0; n < nCount; n++) {
       if (m_DataList[n].m_pModuleId == module_id) {
         pData = m_DataList[n].m_pData;
         return TRUE;
       }
     }
     return FALSE;
   }
 
   FX_BOOL RemovePrivateData(void* module_id);
 
  protected:
   CFX_ArrayTemplate<FX_PRIVATEDATA> m_DataList;
 
   void AddData(void* module_id,
                void* pData,
                PD_CALLBACK_FREEDATA callback,
                FX_BOOL bSelfDestruct);
 };
 
 class CFX_BitStream {
  public:
-  void Init(const uint8_t* pData, FX_DWORD dwSize);
+  void Init(const uint8_t* pData, uint32_t dwSize);
 
-  FX_DWORD GetBits(FX_DWORD nBits);
+  uint32_t GetBits(uint32_t nBits);
 
   void ByteAlign();
 
   FX_BOOL IsEOF() { return m_BitPos >= m_BitSize; }
 
-  void SkipBits(FX_DWORD nBits) { m_BitPos += nBits; }
+  void SkipBits(uint32_t nBits) { m_BitPos += nBits; }
 
   void Rewind() { m_BitPos = 0; }
 
-  FX_DWORD GetPos() const { return m_BitPos; }
+  uint32_t GetPos() const { return m_BitPos; }
 
-  FX_DWORD BitsRemaining() const {
+  uint32_t BitsRemaining() const {
     return m_BitSize >= m_BitPos ? m_BitSize - m_BitPos : 0;
   }
 
  protected:
-  FX_DWORD m_BitPos;
+  uint32_t m_BitPos;
 
-  FX_DWORD m_BitSize;
+  uint32_t m_BitSize;
 
   const uint8_t* m_pData;
 };
 template <class ObjClass>
 class CFX_CountRef {
  public:
   typedef CFX_CountRef<ObjClass> Ref;
 
   class CountedObj : public ObjClass {
    public:
@@ skipping 234 matching lines @@
  protected:
   T1 m_Data;
 };
 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_FILESIZE)>,
                               FX_FILESIZE> CFX_FileSizeListArray;
 
 #ifdef PDF_ENABLE_XFA
 class IFX_Unknown {
  public:
   virtual ~IFX_Unknown() {}
-  virtual FX_DWORD Release() = 0;
-  virtual FX_DWORD AddRef() = 0;
+  virtual uint32_t Release() = 0;
+  virtual uint32_t AddRef() = 0;
 };
 #define FX_IsOdd(a) ((a)&1)
 #endif  // PDF_ENABLE_XFA
 
 class CFX_Vector_3by1 {
  public:
   CFX_Vector_3by1() : a(0.0f), b(0.0f), c(0.0f) {}
 
   CFX_Vector_3by1(FX_FLOAT a1, FX_FLOAT b1, FX_FLOAT c1)
       : a(a1), b(b1), c(c1) {}
@@ skipping 37 matching lines @@
   FX_FLOAT c;
   FX_FLOAT d;
   FX_FLOAT e;
   FX_FLOAT f;
   FX_FLOAT g;
   FX_FLOAT h;
   FX_FLOAT i;
 };
 
 #endif  // CORE_FXCRT_INCLUDE_FX_BASIC_H_