Remove FX_DWORD from core/ and delete definition

core/fxge/ge/fx_ge_font.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/fxge/ge/fx_text_int.h"
 #include "core/include/fxge/fx_freetype.h"
 #include "core/include/fxge/fx_ge.h"
 
 #define EM_ADJUST(em, a) (em == 0 ? (a) : (a)*1000 / em)
 
 namespace {
 
 #ifdef PDF_ENABLE_XFA
-const FX_DWORD g_EncodingID[] = {
+const uint32_t g_EncodingID[] = {
     FXFM_ENCODING_MS_SYMBOL,     FXFM_ENCODING_UNICODE,
     FXFM_ENCODING_MS_SJIS,       FXFM_ENCODING_MS_GB2312,
     FXFM_ENCODING_MS_BIG5,       FXFM_ENCODING_MS_WANSUNG,
     FXFM_ENCODING_MS_JOHAB,      FXFM_ENCODING_ADOBE_STANDARD,
     FXFM_ENCODING_ADOBE_EXPERT,  FXFM_ENCODING_ADOBE_CUSTOM,
     FXFM_ENCODING_ADOBE_LATIN_1, FXFM_ENCODING_OLD_LATIN_2,
     FXFM_ENCODING_APPLE_ROMAN,
 };
 
 CFX_UnicodeEncodingEx* _FXFM_CreateFontEncoding(CFX_Font* pFont,
-                                                FX_DWORD nEncodingID) {
+                                                uint32_t nEncodingID) {
   if (FXFT_Select_Charmap(pFont->GetFace(), nEncodingID))
     return nullptr;
   return new CFX_UnicodeEncodingEx(pFont, nEncodingID);
 }
 #endif  // PDF_ENABLE_XFA
 
 FXFT_Face FT_LoadFont(const uint8_t* pData, int size) {
   return CFX_GEModule::Get()->GetFontMgr()->GetFixedFace(pData, size, 0);
 }
 
@@ skipping 82 matching lines @@
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
   ReleasePlatformResource();
 #endif
 }
 void CFX_Font::DeleteFace() {
   FXFT_Done_Face(m_Face);
   m_Face = NULL;
 }
 void CFX_Font::LoadSubst(const CFX_ByteString& face_name,
                          FX_BOOL bTrueType,
-                         FX_DWORD flags,
+                         uint32_t flags,
                          int weight,
                          int italic_angle,
                          int CharsetCP,
                          FX_BOOL bVertical) {
   m_bEmbedded = FALSE;
   m_bVertical = bVertical;
   m_pSubstFont = new CFX_SubstFont;
   m_Face = CFX_GEModule::Get()->GetFontMgr()->FindSubstFont(
       face_name, bTrueType, flags, weight, italic_angle, CharsetCP,
       m_pSubstFont);
@@ skipping 65 matching lines @@
     return FALSE;
 
   if (pFaceCount)
     *pFaceCount = (int)m_Face->num_faces;
   m_pOwnedStream = stream;
   FXFT_Set_Pixel_Sizes(m_Face, 0, 64);
   return TRUE;
 }
 #endif  // PDF_ENABLE_XFA
 
-int CFX_Font::GetGlyphWidth(FX_DWORD glyph_index) {
+int CFX_Font::GetGlyphWidth(uint32_t glyph_index) {
   if (!m_Face) {
     return 0;
   }
   if (m_pSubstFont && (m_pSubstFont->m_SubstFlags & FXFONT_SUBST_MM)) {
     AdjustMMParams(glyph_index, 0, 0);
   }
   int err = FXFT_Load_Glyph(
       m_Face, glyph_index,
       FXFT_LOAD_NO_SCALE | FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH);
   if (err) {
     return 0;
   }
   int width = EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face),
                         FXFT_Get_Glyph_HoriAdvance(m_Face));
   return width;
 }
 
-FX_BOOL CFX_Font::LoadEmbedded(const uint8_t* data, FX_DWORD size) {
+FX_BOOL CFX_Font::LoadEmbedded(const uint8_t* data, uint32_t size) {
   m_pFontDataAllocation = FX_Alloc(uint8_t, size);
   FXSYS_memcpy(m_pFontDataAllocation, data, size);
   m_Face = FT_LoadFont(m_pFontDataAllocation, size);
   m_pFontData = m_pFontDataAllocation;
   m_bEmbedded = TRUE;
   m_dwSize = size;
   return m_Face != NULL;
 }
 
 FX_BOOL CFX_Font::IsTTFont() const {
   if (!m_Face)
     return FALSE;
   return FXFT_Is_Face_TT_OT(m_Face) == FXFT_FACE_FLAG_SFNT;
 }
 
 int CFX_Font::GetAscent() const {
   if (!m_Face)
     return 0;
   return EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face),
                    FXFT_Get_Face_Ascender(m_Face));
 }
 
 int CFX_Font::GetDescent() const {
   if (!m_Face)
     return 0;
   return EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face),
                    FXFT_Get_Face_Descender(m_Face));
 }
 
-FX_BOOL CFX_Font::GetGlyphBBox(FX_DWORD glyph_index, FX_RECT& bbox) {
+FX_BOOL CFX_Font::GetGlyphBBox(uint32_t glyph_index, FX_RECT& bbox) {
   if (!m_Face)
     return FALSE;
 
   if (FXFT_Is_Face_Tricky(m_Face)) {
     int error = FXFT_Set_Char_Size(m_Face, 0, 1000 * 64, 72, 72);
     if (error) {
       return FALSE;
     }
     error = FXFT_Load_Glyph(m_Face, glyph_index,
                             FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH);
@@ skipping 166 matching lines @@
     return 0;
 
   return EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face),
                    FXFT_Get_Face_UnderLineThickness(m_Face));
 }
 
 CFX_UnicodeEncoding::CFX_UnicodeEncoding(CFX_Font* pFont) : m_pFont(pFont) {}
 
 CFX_UnicodeEncoding::~CFX_UnicodeEncoding() {}
 
-FX_DWORD CFX_UnicodeEncoding::GlyphFromCharCode(FX_DWORD charcode) {
+uint32_t CFX_UnicodeEncoding::GlyphFromCharCode(uint32_t charcode) {
   FXFT_Face face = m_pFont->GetFace();
   if (!face)
     return charcode;
 
   if (FXFT_Select_Charmap(face, FXFT_ENCODING_UNICODE) == 0)
     return FXFT_Get_Char_Index(face, charcode);
 
   if (m_pFont->GetSubstFont() && m_pFont->GetSubstFont()->m_Charset == 2) {
-    FX_DWORD index = 0;
+    uint32_t index = 0;
     if (FXFT_Select_Charmap(face, FXFT_ENCODING_MS_SYMBOL) == 0)
       index = FXFT_Get_Char_Index(face, charcode);
     if (!index && !FXFT_Select_Charmap(face, FXFT_ENCODING_APPLE_ROMAN))
       return FXFT_Get_Char_Index(face, charcode);
   }
   return charcode;
 }
 
 #ifdef PDF_ENABLE_XFA
 CFX_UnicodeEncodingEx::CFX_UnicodeEncodingEx(CFX_Font* pFont,
-                                             FX_DWORD EncodingID)
+                                             uint32_t EncodingID)
     : CFX_UnicodeEncoding(pFont), m_nEncodingID(EncodingID) {}
 
 CFX_UnicodeEncodingEx::~CFX_UnicodeEncodingEx() {}
 
-FX_DWORD CFX_UnicodeEncodingEx::GlyphFromCharCode(FX_DWORD charcode) {
+uint32_t CFX_UnicodeEncodingEx::GlyphFromCharCode(uint32_t charcode) {
   FXFT_Face face = m_pFont->GetFace();
   FT_UInt nIndex = FXFT_Get_Char_Index(face, charcode);
   if (nIndex > 0) {
     return nIndex;
   }
   int nmaps = FXFT_Get_Face_CharmapCount(face);
   int m = 0;
   while (m < nmaps) {
-    FX_DWORD nEncodingID =
+    uint32_t nEncodingID =
         FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[m++]);
     if (m_nEncodingID == nEncodingID) {
       continue;
     }
     int error = FXFT_Select_Charmap(face, nEncodingID);
     if (error) {
       continue;
     }
     nIndex = FXFT_Get_Char_Index(face, charcode);
     if (nIndex > 0) {
       m_nEncodingID = nEncodingID;
       return nIndex;
     }
   }
   FXFT_Select_Charmap(face, m_nEncodingID);
   return 0;
 }
 
-FX_DWORD CFX_UnicodeEncodingEx::CharCodeFromUnicode(FX_WCHAR Unicode) const {
+uint32_t CFX_UnicodeEncodingEx::CharCodeFromUnicode(FX_WCHAR Unicode) const {
   if (m_nEncodingID == FXFM_ENCODING_UNICODE ||
       m_nEncodingID == FXFM_ENCODING_MS_SYMBOL) {
     return Unicode;
   }
   FXFT_Face face = m_pFont->GetFace();
   int nmaps = FXFT_Get_Face_CharmapCount(face);
   for (int i = 0; i < nmaps; i++) {
     int nEncodingID =
         FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[i]);
     if (nEncodingID == FXFM_ENCODING_UNICODE ||
         nEncodingID == FXFM_ENCODING_MS_SYMBOL) {
       return Unicode;
     }
   }
-  return static_cast<FX_DWORD>(-1);
+  return static_cast<uint32_t>(-1);
 }
 
 CFX_UnicodeEncodingEx* FX_CreateFontEncodingEx(CFX_Font* pFont,
-                                               FX_DWORD nEncodingID) {
+                                               uint32_t nEncodingID) {
   if (!pFont || !pFont->GetFace())
     return nullptr;
 
   if (nEncodingID != FXFM_ENCODING_NONE)
     return _FXFM_CreateFontEncoding(pFont, nEncodingID);
 
   for (size_t i = 0; i < FX_ArraySize(g_EncodingID); ++i) {
     CFX_UnicodeEncodingEx* pFontEncoding =
         _FXFM_CreateFontEncoding(pFont, g_EncodingID[i]);
     if (pFontEncoding) {
       return pFontEncoding;
     }
   }
   return NULL;
 }
 #endif  // PDF_ENABLE_XFA