Remove FX_DWORD from core/ and delete definition

core/fxge/ge/fx_ge_fontmap.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 <vector>
 
 #include "core/fxge/fontdata/chromefontdata/chromefontdata.h"
 #include "core/fxge/ge/fx_text_int.h"
 #include "core/include/fxge/fx_freetype.h"
 #include "core/include/fxge/fx_ge.h"
 #include "third_party/base/stl_util.h"
 
 #define GET_TT_SHORT(w) (uint16_t)(((w)[0] << 8) | (w)[1])
 #define GET_TT_LONG(w) \
-  (FX_DWORD)(((w)[0] << 24) | ((w)[1] << 16) | ((w)[2] << 8) | (w)[3])
+  (uint32_t)(((w)[0] << 24) | ((w)[1] << 16) | ((w)[2] << 8) | (w)[3])
 
 #define FX_FONT_STYLE_None 0x00
 #define FX_FONT_STYLE_Bold 0x01
 #define FX_FONT_STYLE_Italic 0x02
 #define FX_FONT_STYLE_BoldBold 0x04
 
 namespace {
 
 struct BuiltinFont {
   const uint8_t* m_pFontData;
-  FX_DWORD m_dwSize;
+  uint32_t m_dwSize;
 };
 
 const BuiltinFont g_FoxitFonts[14] = {
     {g_FoxitFixedFontData, 17597},
     {g_FoxitFixedBoldFontData, 18055},
     {g_FoxitFixedBoldItalicFontData, 19151},
     {g_FoxitFixedItalicFontData, 18746},
     {g_FoxitSansFontData, 15025},
     {g_FoxitSansBoldFontData, 16344},
     {g_FoxitSansBoldItalicFontData, 16418},
@@ skipping 163 matching lines @@
 } g_Codepage2CharsetTable[] = {
     {0, 1},      {42, 2},     {437, 254},  {850, 255},  {874, 222},
     {932, 128},  {936, 134},  {949, 129},  {950, 136},  {1250, 238},
     {1251, 204}, {1252, 0},   {1253, 161}, {1254, 162}, {1255, 177},
     {1256, 178}, {1257, 186}, {1258, 163}, {1361, 130}, {10000, 77},
     {10001, 78}, {10002, 81}, {10003, 79}, {10004, 84}, {10005, 83},
     {10006, 85}, {10007, 89}, {10008, 80}, {10021, 87}, {10029, 88},
     {10081, 86},
 };
 
-const FX_DWORD kTableNAME = FXDWORD_GET_MSBFIRST("name");
-const FX_DWORD kTableTTCF = FXDWORD_GET_MSBFIRST("ttcf");
+const uint32_t kTableNAME = FXDWORD_GET_MSBFIRST("name");
+const uint32_t kTableTTCF = FXDWORD_GET_MSBFIRST("ttcf");
 
 int CompareFontFamilyString(const void* key, const void* element) {
   CFX_ByteString str_key((const FX_CHAR*)key);
   if (str_key.Find(((AltFontFamily*)element)->m_pFontName) != -1) {
     return 0;
   }
   return FXSYS_stricmp((const FX_CHAR*)key,
                        ((AltFontFamily*)element)->m_pFontName);
 }
 
 int CompareString(const void* key, const void* element) {
   return FXSYS_stricmp((const FX_CHAR*)key, ((AltFontName*)element)->m_pName);
 }
 
 CFX_ByteString KeyNameFromFace(const CFX_ByteString& face_name,
                                int weight,
                                FX_BOOL bItalic) {
   CFX_ByteString key(face_name);
   key += ',';
   key += CFX_ByteString::FormatInteger(weight);
   key += bItalic ? 'I' : 'N';
   return key;
 }
 
-CFX_ByteString KeyNameFromSize(int ttc_size, FX_DWORD checksum) {
+CFX_ByteString KeyNameFromSize(int ttc_size, uint32_t checksum) {
   CFX_ByteString key;
   key.Format("%d:%d", ttc_size, checksum);
   return key;
 }
 
 CFX_ByteString TT_NormalizeName(const FX_CHAR* family) {
   CFX_ByteString norm(family);
   norm.Remove(' ');
   norm.Remove('-');
   norm.Remove(',');
   int pos = norm.Find('+');
   if (pos > 0) {
     norm = norm.Left(pos);
   }
   norm.MakeLower();
   return norm;
 }
 
-CFX_ByteString FPDF_ReadStringFromFile(FXSYS_FILE* pFile, FX_DWORD size) {
+CFX_ByteString FPDF_ReadStringFromFile(FXSYS_FILE* pFile, uint32_t size) {
   CFX_ByteString buffer;
   if (!FXSYS_fread(buffer.GetBuffer(size), size, 1, pFile)) {
     return CFX_ByteString();
   }
   buffer.ReleaseBuffer(size);
   return buffer;
 }
 
 CFX_ByteString FPDF_LoadTableFromTT(FXSYS_FILE* pFile,
                                     const uint8_t* pTables,
-                                    FX_DWORD nTables,
-                                    FX_DWORD tag) {
-  for (FX_DWORD i = 0; i < nTables; i++) {
+                                    uint32_t nTables,
+                                    uint32_t tag) {
+  for (uint32_t i = 0; i < nTables; i++) {
     const uint8_t* p = pTables + i * 16;
     if (GET_TT_LONG(p) == tag) {
-      FX_DWORD offset = GET_TT_LONG(p + 8);
-      FX_DWORD size = GET_TT_LONG(p + 12);
+      uint32_t offset = GET_TT_LONG(p + 8);
+      uint32_t size = GET_TT_LONG(p + 12);
       FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET);
       return FPDF_ReadStringFromFile(pFile, size);
     }
   }
   return CFX_ByteString();
 }
 
 uint8_t GetCharsetFromCodePage(uint16_t codepage) {
   const CODEPAGE_MAP* pEnd =
       g_Codepage2CharsetTable + FX_ArraySize(g_Codepage2CharsetTable);
@@ skipping 68 matching lines @@
 }
 
 FX_BOOL CheckSupportThirdPartFont(CFX_ByteString name, int& PitchFamily) {
   if (name == "MyriadPro") {
     PitchFamily &= ~FXFONT_FF_ROMAN;
     return TRUE;
   }
   return FALSE;
 }
 
-FX_DWORD GetCharset(int charset) {
+uint32_t GetCharset(int charset) {
   switch (charset) {
     case FXFONT_SHIFTJIS_CHARSET:
       return CHARSET_FLAG_SHIFTJIS;
     case FXFONT_GB2312_CHARSET:
       return CHARSET_FLAG_GB;
     case FXFONT_CHINESEBIG5_CHARSET:
       return CHARSET_FLAG_BIG5;
     case FXFONT_HANGEUL_CHARSET:
       return CHARSET_FLAG_KOREAN;
     case FXFONT_SYMBOL_CHARSET:
       return CHARSET_FLAG_SYMBOL;
     case FXFONT_ANSI_CHARSET:
       return CHARSET_FLAG_ANSI;
     default:
       break;
   }
   return 0;
 }
 
 int32_t GetSimilarValue(int weight,
                         FX_BOOL bItalic,
                         int pitch_family,
-                        FX_DWORD style) {
+                        uint32_t style) {
   int32_t iSimilarValue = 0;
   if (!!(style & FXFONT_BOLD) == (weight > 400)) {
     iSimilarValue += 16;
   }
   if (!!(style & FXFONT_ITALIC) == bItalic) {
     iSimilarValue += 16;
   }
   if (!!(style & FXFONT_SERIF) == !!(pitch_family & FXFONT_FF_ROMAN)) {
     iSimilarValue += 16;
   }
@@ skipping 74 matching lines @@
     return;
   FXFT_Init_FreeType(&m_FTLibrary);
 }
 
 void CFX_FontMgr::SetSystemFontInfo(IFX_SystemFontInfo* pFontInfo) {
   m_pBuiltinMapper->SetSystemFontInfo(pFontInfo);
 }
 
 FXFT_Face CFX_FontMgr::FindSubstFont(const CFX_ByteString& face_name,
                                      FX_BOOL bTrueType,
-                                     FX_DWORD flags,
+                                     uint32_t flags,
                                      int weight,
                                      int italic_angle,
                                      int CharsetCP,
                                      CFX_SubstFont* pSubstFont) {
   InitFTLibrary();
   return m_pBuiltinMapper->FindSubstFont(face_name, bTrueType, flags, weight,
                                          italic_angle, CharsetCP, pSubstFont);
 }
 
 FXFT_Face CFX_FontMgr::GetCachedFace(const CFX_ByteString& face_name,
                                      int weight,
                                      FX_BOOL bItalic,
                                      uint8_t*& pFontData) {
   auto it = m_FaceMap.find(KeyNameFromFace(face_name, weight, bItalic));
   if (it == m_FaceMap.end())
     return nullptr;
 
   CTTFontDesc* pFontDesc = it->second;
   pFontData = pFontDesc->m_pFontData;
   pFontDesc->m_RefCount++;
   return pFontDesc->m_SingleFace.m_pFace;
 }
 FXFT_Face CFX_FontMgr::AddCachedFace(const CFX_ByteString& face_name,
                                      int weight,
                                      FX_BOOL bItalic,
                                      uint8_t* pData,
-                                     FX_DWORD size,
+                                     uint32_t size,
                                      int face_index) {
   CTTFontDesc* pFontDesc = new CTTFontDesc;
   pFontDesc->m_Type = 1;
   pFontDesc->m_SingleFace.m_pFace = NULL;
   pFontDesc->m_SingleFace.m_bBold = weight;
   pFontDesc->m_SingleFace.m_bItalic = bItalic;
   pFontDesc->m_pFontData = pData;
   pFontDesc->m_RefCount = 1;
 
   InitFTLibrary();
   FXFT_Library library = m_FTLibrary;
   int ret = FXFT_New_Memory_Face(library, pData, size, face_index,
                                  &pFontDesc->m_SingleFace.m_pFace);
   if (ret) {
     delete pFontDesc;
     return NULL;
   }
   ret = FXFT_Set_Pixel_Sizes(pFontDesc->m_SingleFace.m_pFace, 64, 64);
   if (ret) {
     delete pFontDesc;
     return NULL;
   }
   m_FaceMap[KeyNameFromFace(face_name, weight, bItalic)] = pFontDesc;
   return pFontDesc->m_SingleFace.m_pFace;
 }
 
 int GetTTCIndex(const uint8_t* pFontData,
-                FX_DWORD ttc_size,
-                FX_DWORD font_offset) {
+                uint32_t ttc_size,
+                uint32_t font_offset) {
   int face_index = 0;
   const uint8_t* p = pFontData + 8;
-  FX_DWORD nfont = GET_TT_LONG(p);
-  FX_DWORD index;
+  uint32_t nfont = GET_TT_LONG(p);
+  uint32_t index;
   for (index = 0; index < nfont; index++) {
     p = pFontData + 12 + index * 4;
     if (GET_TT_LONG(p) == font_offset) {
       break;
     }
   }
   if (index >= nfont) {
     face_index = 0;
   } else {
     face_index = index;
   }
   return face_index;
 }
 FXFT_Face CFX_FontMgr::GetCachedTTCFace(int ttc_size,
-                                        FX_DWORD checksum,
+                                        uint32_t checksum,
                                         int font_offset,
                                         uint8_t*& pFontData) {
   auto it = m_FaceMap.find(KeyNameFromSize(ttc_size, checksum));
   if (it == m_FaceMap.end())
     return nullptr;
 
   CTTFontDesc* pFontDesc = it->second;
   pFontData = pFontDesc->m_pFontData;
   pFontDesc->m_RefCount++;
   int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
   if (!pFontDesc->m_TTCFace.m_pFaces[face_index]) {
     pFontDesc->m_TTCFace.m_pFaces[face_index] =
         GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
   }
   return pFontDesc->m_TTCFace.m_pFaces[face_index];
 }
 FXFT_Face CFX_FontMgr::AddCachedTTCFace(int ttc_size,
-                                        FX_DWORD checksum,
+                                        uint32_t checksum,
                                         uint8_t* pData,
-                                        FX_DWORD size,
+                                        uint32_t size,
                                         int font_offset) {
   CTTFontDesc* pFontDesc = new CTTFontDesc;
   pFontDesc->m_Type = 2;
   pFontDesc->m_pFontData = pData;
   for (int i = 0; i < 16; i++) {
     pFontDesc->m_TTCFace.m_pFaces[i] = NULL;
   }
   pFontDesc->m_RefCount++;
   m_FaceMap[KeyNameFromSize(ttc_size, checksum)] = pFontDesc;
   int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
   pFontDesc->m_TTCFace.m_pFaces[face_index] =
       GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
   return pFontDesc->m_TTCFace.m_pFaces[face_index];
 }
 
 FXFT_Face CFX_FontMgr::GetFixedFace(const uint8_t* pData,
-                                    FX_DWORD size,
+                                    uint32_t size,
                                     int face_index) {
   InitFTLibrary();
   FXFT_Library library = m_FTLibrary;
   FXFT_Face face = nullptr;
   if (FXFT_New_Memory_Face(library, pData, size, face_index, &face))
     return nullptr;
   return FXFT_Set_Pixel_Sizes(face, 64, 64) ? nullptr : face;
 }
 
 FXFT_Face CFX_FontMgr::GetFileFace(const FX_CHAR* filename, int face_index) {
@@ skipping 20 matching lines @@
     if (nRet == 0)
       m_FaceMap.erase(temp);
     break;
   }
   if (bNeedFaceDone && !m_pBuiltinMapper->IsBuiltinFace(face))
     FXFT_Done_Face(face);
 }
 
 bool CFX_FontMgr::GetBuiltinFont(size_t index,
                                  const uint8_t** pFontData,
-                                 FX_DWORD* size) {
+                                 uint32_t* size) {
   if (index < FX_ArraySize(g_FoxitFonts)) {
     *pFontData = g_FoxitFonts[index].m_pFontData;
     *size = g_FoxitFonts[index].m_dwSize;
     return true;
   }
   index -= FX_ArraySize(g_FoxitFonts);
   if (index < FX_ArraySize(g_MMFonts)) {
     *pFontData = g_MMFonts[index].m_pFontData;
     *size = g_MMFonts[index].m_dwSize;
     return true;
@@ skipping 28 matching lines @@
 void CFX_FontMapper::SetSystemFontInfo(IFX_SystemFontInfo* pFontInfo) {
   if (!pFontInfo) {
     return;
   }
   if (m_pFontInfo) {
     m_pFontInfo->Release();
   }
   m_pFontInfo = pFontInfo;
 }
 static CFX_ByteString GetStringFromTable(const uint8_t* string_ptr,
-                                         FX_DWORD string_ptr_length,
+                                         uint32_t string_ptr_length,
                                          uint16_t offset,
                                          uint16_t length) {
   if (string_ptr_length < offset + length) {
     return CFX_ByteString();
   }
   return CFX_ByteStringC(string_ptr + offset, length);
 }
 CFX_ByteString GetNameFromTT(const uint8_t* name_table,
-                             FX_DWORD name_table_size,
-                             FX_DWORD name_id) {
+                             uint32_t name_table_size,
+                             uint32_t name_id) {
   if (!name_table || name_table_size < 6) {
     return CFX_ByteString();
   }
-  FX_DWORD name_count = GET_TT_SHORT(name_table + 2);
-  FX_DWORD string_offset = GET_TT_SHORT(name_table + 4);
+  uint32_t name_count = GET_TT_SHORT(name_table + 2);
+  uint32_t string_offset = GET_TT_SHORT(name_table + 4);
   // We will ignore the possibility of overlap of structures and
   // string table as if it's all corrupt there's not a lot we can do.
   if (name_table_size < string_offset) {
     return CFX_ByteString();
   }
 
   const uint8_t* string_ptr = name_table + string_offset;
-  FX_DWORD string_ptr_size = name_table_size - string_offset;
+  uint32_t string_ptr_size = name_table_size - string_offset;
   name_table += 6;
   name_table_size -= 6;
   if (name_table_size < name_count * 12) {
     return CFX_ByteString();
   }
 
-  for (FX_DWORD i = 0; i < name_count; i++, name_table += 12) {
+  for (uint32_t i = 0; i < name_count; i++, name_table += 12) {
     if (GET_TT_SHORT(name_table + 6) == name_id &&
         GET_TT_SHORT(name_table) == 1 && GET_TT_SHORT(name_table + 2) == 0) {
       return GetStringFromTable(string_ptr, string_ptr_size,
                                 GET_TT_SHORT(name_table + 10),
                                 GET_TT_SHORT(name_table + 8));
     }
   }
   return CFX_ByteString();
 }
 
 CFX_ByteString CFX_FontMapper::GetPSNameFromTT(void* hFont) {
   if (!m_pFontInfo)
     return CFX_ByteString();
 
-  FX_DWORD size = m_pFontInfo->GetFontData(hFont, kTableNAME, nullptr, 0);
+  uint32_t size = m_pFontInfo->GetFontData(hFont, kTableNAME, nullptr, 0);
   if (!size)
     return CFX_ByteString();
 
   std::vector<uint8_t> buffer(size);
   uint8_t* buffer_ptr = buffer.data();
-  FX_DWORD bytes_read =
+  uint32_t bytes_read =
       m_pFontInfo->GetFontData(hFont, kTableNAME, buffer_ptr, size);
   return bytes_read == size ? GetNameFromTT(buffer_ptr, bytes_read, 6)
                             : CFX_ByteString();
 }
 
 void CFX_FontMapper::AddInstalledFont(const CFX_ByteString& name, int charset) {
   if (!m_pFontInfo) {
     return;
   }
-  if (m_CharsetArray.Find((FX_DWORD)charset) == -1) {
-    m_CharsetArray.Add((FX_DWORD)charset);
+  if (m_CharsetArray.Find((uint32_t)charset) == -1) {
+    m_CharsetArray.Add((uint32_t)charset);
     m_FaceArray.push_back(name);
   }
   if (name == m_LastFamily) {
     return;
   }
   const uint8_t* ptr = name;
   FX_BOOL bLocalized = FALSE;
   for (int i = 0; i < name.GetLength(); i++)
     if (ptr[i] > 0x80) {
       bLocalized = TRUE;
@@ skipping 55 matching lines @@
 FXFT_Face CFX_FontMapper::UseInternalSubst(CFX_SubstFont* pSubstFont,
                                            int iBaseFont,
                                            int italic_angle,
                                            int weight,
                                            int picthfamily) {
   if (iBaseFont < 12) {
     if (m_FoxitFaces[iBaseFont]) {
       return m_FoxitFaces[iBaseFont];
     }
     const uint8_t* pFontData = NULL;
-    FX_DWORD size = 0;
+    uint32_t size = 0;
     if (m_pFontMgr->GetBuiltinFont(iBaseFont, &pFontData, &size)) {
       m_FoxitFaces[iBaseFont] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
       return m_FoxitFaces[iBaseFont];
     }
   }
   pSubstFont->m_SubstFlags |= FXFONT_SUBST_MM;
   pSubstFont->m_ItalicAngle = italic_angle;
   if (weight) {
     pSubstFont->m_Weight = weight;
   }
   if (picthfamily & FXFONT_FF_ROMAN) {
     pSubstFont->m_Weight = pSubstFont->m_Weight * 4 / 5;
     pSubstFont->m_Family = "Chrome Serif";
     if (m_MMFaces[1]) {
       return m_MMFaces[1];
     }
     const uint8_t* pFontData = NULL;
-    FX_DWORD size = 0;
+    uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(14, &pFontData, &size);
     m_MMFaces[1] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_MMFaces[1];
   }
   pSubstFont->m_Family = "Chrome Sans";
   if (m_MMFaces[0]) {
     return m_MMFaces[0];
   }
   const uint8_t* pFontData = NULL;
-  FX_DWORD size = 0;
+  uint32_t size = 0;
   m_pFontMgr->GetBuiltinFont(15, &pFontData, &size);
   m_MMFaces[0] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
   return m_MMFaces[0];
 }
 
 FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name,
                                         FX_BOOL bTrueType,
-                                        FX_DWORD flags,
+                                        uint32_t flags,
                                         int weight,
                                         int italic_angle,
                                         int WindowCP,
                                         CFX_SubstFont* pSubstFont) {
   if (!(flags & FXFONT_USEEXTERNATTR)) {
     weight = FXFONT_FW_NORMAL;
     italic_angle = 0;
   }
   CFX_ByteString SubstName = name;
   SubstName.Remove(0x20);
   if (bTrueType) {
     if (name[0] == '@') {
       SubstName = name.Mid(1);
     }
   }
   PDF_GetStandardFontName(&SubstName);
   if (SubstName == "Symbol" && !bTrueType) {
     pSubstFont->m_Family = "Chrome Symbol";
     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     if (m_FoxitFaces[12]) {
       return m_FoxitFaces[12];
     }
     const uint8_t* pFontData = NULL;
-    FX_DWORD size = 0;
+    uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(12, &pFontData, &size);
     m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_FoxitFaces[12];
   }
   if (SubstName == "ZapfDingbats") {
     pSubstFont->m_Family = "Chrome Dingbats";
     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     if (m_FoxitFaces[13]) {
       return m_FoxitFaces[13];
     }
     const uint8_t* pFontData = NULL;
-    FX_DWORD size = 0;
+    uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(13, &pFontData, &size);
     m_FoxitFaces[13] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_FoxitFaces[13];
   }
   int iBaseFont = 0;
   CFX_ByteString family, style;
   FX_BOOL bHasComma = FALSE;
   FX_BOOL bHasHypen = FALSE;
   int find = SubstName.Find(",", 0);
   if (find >= 0) {
     family = SubstName.Left(find);
     PDF_GetStandardFontName(&family);
     style = SubstName.Mid(find + 1);
     bHasComma = TRUE;
   } else {
     family = SubstName;
   }
   for (; iBaseFont < 12; iBaseFont++)
     if (family == CFX_ByteStringC(g_Base14FontNames[iBaseFont])) {
       break;
     }
   int PitchFamily = 0;
   FX_BOOL bItalic = FALSE;
-  FX_DWORD nStyle = 0;
+  uint32_t nStyle = 0;
   FX_BOOL bStyleAvail = FALSE;
   if (iBaseFont < 12) {
     family = g_Base14FontNames[iBaseFont];
     if ((iBaseFont % 4) == 1 || (iBaseFont % 4) == 2) {
       nStyle |= FX_FONT_STYLE_Bold;
     }
     if ((iBaseFont % 4) / 2) {
       nStyle |= FX_FONT_STYLE_Italic;
     }
     if (iBaseFont < 4) {
@@ skipping 200 matching lines @@
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_
         if (SubstName == "Symbol") {
           pSubstFont->m_Family = "Chrome Symbol";
           pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
           pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
           if (m_FoxitFaces[12]) {
             return m_FoxitFaces[12];
           }
           const uint8_t* pFontData = NULL;
-          FX_DWORD size = 0;
+          uint32_t size = 0;
           m_pFontMgr->GetBuiltinFont(12, &pFontData, &size);
           m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
           return m_FoxitFaces[12];
         }
 #endif
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
         return FindSubstFont(family, bTrueType, flags & ~FXFONT_SYMBOLIC,
                              weight, italic_angle, 0, pSubstFont);
       }
       if (Charset == FXFONT_ANSI_CHARSET) {
@@ skipping 10 matching lines @@
     }
   }
   pSubstFont->m_ExtHandle = m_pFontInfo->RetainFont(hFont);
   if (!hFont)
     return nullptr;
 
   m_pFontInfo->GetFaceName(hFont, SubstName);
   if (Charset == FXFONT_DEFAULT_CHARSET) {
     m_pFontInfo->GetFontCharset(hFont, Charset);
   }
-  FX_DWORD ttc_size = m_pFontInfo->GetFontData(hFont, kTableTTCF, nullptr, 0);
-  FX_DWORD font_size = m_pFontInfo->GetFontData(hFont, 0, nullptr, 0);
+  uint32_t ttc_size = m_pFontInfo->GetFontData(hFont, kTableTTCF, nullptr, 0);
+  uint32_t font_size = m_pFontInfo->GetFontData(hFont, 0, nullptr, 0);
   if (font_size == 0 && ttc_size == 0) {
     m_pFontInfo->DeleteFont(hFont);
     return nullptr;
   }
   FXFT_Face face = nullptr;
   if (ttc_size) {
     uint8_t temp[1024];
     m_pFontInfo->GetFontData(hFont, kTableTTCF, temp, 1024);
-    FX_DWORD checksum = 0;
+    uint32_t checksum = 0;
     for (int i = 0; i < 256; i++) {
-      checksum += ((FX_DWORD*)temp)[i];
+      checksum += ((uint32_t*)temp)[i];
     }
     uint8_t* pFontData;
     face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum,
                                         ttc_size - font_size, pFontData);
     if (!face) {
       pFontData = FX_Alloc(uint8_t, ttc_size);
       m_pFontInfo->GetFontData(hFont, kTableTTCF, pFontData, ttc_size);
       face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData,
                                           ttc_size, ttc_size - font_size);
     }
@@ skipping 36 matching lines @@
       italic_angle = -12;
     } else if (FXSYS_abs(italic_angle) < 5) {
       italic_angle = 0;
     }
     pSubstFont->m_ItalicAngle = italic_angle;
   }
   m_pFontInfo->DeleteFont(hFont);
   return face;
 }
 #ifdef PDF_ENABLE_XFA
-FXFT_Face CFX_FontMapper::FindSubstFontByUnicode(FX_DWORD dwUnicode,
-                                                 FX_DWORD flags,
+FXFT_Face CFX_FontMapper::FindSubstFontByUnicode(uint32_t dwUnicode,
+                                                 uint32_t flags,
                                                  int weight,
                                                  int italic_angle) {
   if (m_pFontInfo == NULL) {
     return NULL;
   }
   FX_BOOL bItalic = (flags & FXFONT_ITALIC) != 0;
   int PitchFamily = 0;
   if (flags & FXFONT_SERIF) {
     PitchFamily |= FXFONT_FF_ROMAN;
   }
   if (flags & FXFONT_SCRIPT) {
     PitchFamily |= FXFONT_FF_SCRIPT;
   }
   if (flags & FXFONT_FIXED_PITCH) {
     PitchFamily |= FXFONT_FF_FIXEDPITCH;
   }
   void* hFont =
       m_pFontInfo->MapFontByUnicode(dwUnicode, weight, bItalic, PitchFamily);
   if (hFont == NULL) {
     return NULL;
   }
-  FX_DWORD ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, NULL, 0);
-  FX_DWORD font_size = m_pFontInfo->GetFontData(hFont, 0, NULL, 0);
+  uint32_t ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, NULL, 0);
+  uint32_t font_size = m_pFontInfo->GetFontData(hFont, 0, NULL, 0);
   if (font_size == 0 && ttc_size == 0) {
     m_pFontInfo->DeleteFont(hFont);
     return NULL;
   }
   FXFT_Face face = NULL;
   if (ttc_size) {
     uint8_t temp[1024];
     m_pFontInfo->GetFontData(hFont, 0x74746366, temp, 1024);
-    FX_DWORD checksum = 0;
+    uint32_t checksum = 0;
     for (int i = 0; i < 256; i++) {
-      checksum += ((FX_DWORD*)temp)[i];
+      checksum += ((uint32_t*)temp)[i];
     }
     uint8_t* pFontData;
     face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum,
                                         ttc_size - font_size, pFontData);
     if (face == NULL) {
       pFontData = FX_Alloc(uint8_t, ttc_size);
       if (pFontData) {
         m_pFontInfo->GetFontData(hFont, 0x74746366, pFontData, ttc_size);
         face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData,
                                             ttc_size, ttc_size - font_size);
@@ skipping 13 matching lines @@
       m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
       face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData,
                                        font_size,
                                        m_pFontInfo->GetFaceIndex(hFont));
     }
   }
   m_pFontInfo->DeleteFont(hFont);
   return face;
 }
 
-void* IFX_SystemFontInfo::MapFontByUnicode(FX_DWORD dwUnicode,
+void* IFX_SystemFontInfo::MapFontByUnicode(uint32_t dwUnicode,
                                            int weight,
                                            FX_BOOL bItalic,
                                            int pitch_family) {
   return nullptr;
 }
 #endif  // PDF_ENABLE_XFA
 
 int IFX_SystemFontInfo::GetFaceIndex(void* hFont) {
   return 0;
 }
@@ skipping 86 matching lines @@
     }
   }
   FX_CloseFolder(handle);
 }
 void CFX_FolderFontInfo::ScanFile(const CFX_ByteString& path) {
   FXSYS_FILE* pFile = FXSYS_fopen(path, "rb");
   if (!pFile) {
     return;
   }
   FXSYS_fseek(pFile, 0, FXSYS_SEEK_END);
-  FX_DWORD filesize = FXSYS_ftell(pFile);
+  uint32_t filesize = FXSYS_ftell(pFile);
   uint8_t buffer[16];
   FXSYS_fseek(pFile, 0, FXSYS_SEEK_SET);
   size_t readCnt = FXSYS_fread(buffer, 12, 1, pFile);
   if (readCnt != 1) {
     FXSYS_fclose(pFile);
     return;
   }
 
   if (GET_TT_LONG(buffer) == kTableTTCF) {
-    FX_DWORD nFaces = GET_TT_LONG(buffer + 8);
-    if (nFaces > std::numeric_limits<FX_DWORD>::max() / 4) {
+    uint32_t nFaces = GET_TT_LONG(buffer + 8);
+    if (nFaces > std::numeric_limits<uint32_t>::max() / 4) {
       FXSYS_fclose(pFile);
       return;
     }
-    FX_DWORD face_bytes = nFaces * 4;
+    uint32_t face_bytes = nFaces * 4;
     uint8_t* offsets = FX_Alloc(uint8_t, face_bytes);
     readCnt = FXSYS_fread(offsets, 1, face_bytes, pFile);
     if (readCnt != face_bytes) {
       FX_Free(offsets);
       FXSYS_fclose(pFile);
       return;
     }
-    for (FX_DWORD i = 0; i < nFaces; i++) {
+    for (uint32_t i = 0; i < nFaces; i++) {
       uint8_t* p = offsets + i * 4;
       ReportFace(path, pFile, filesize, GET_TT_LONG(p));
     }
     FX_Free(offsets);
   } else {
     ReportFace(path, pFile, filesize, 0);
   }
   FXSYS_fclose(pFile);
 }
 void CFX_FolderFontInfo::ReportFace(const CFX_ByteString& path,
                                     FXSYS_FILE* pFile,
-                                    FX_DWORD filesize,
-                                    FX_DWORD offset) {
+                                    uint32_t filesize,
+                                    uint32_t offset) {
   FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET);
   char buffer[16];
   if (!FXSYS_fread(buffer, 12, 1, pFile)) {
     return;
   }
-  FX_DWORD nTables = GET_TT_SHORT(buffer + 4);
+  uint32_t nTables = GET_TT_SHORT(buffer + 4);
   CFX_ByteString tables = FPDF_ReadStringFromFile(pFile, nTables * 16);
   if (tables.IsEmpty()) {
     return;
   }
   CFX_ByteString names =
       FPDF_LoadTableFromTT(pFile, tables, nTables, 0x6e616d65);
   if (names.IsEmpty()) {
     return;
   }
   CFX_ByteString facename = GetNameFromTT(names, names.GetLength(), 1);
   if (facename.IsEmpty()) {
     return;
   }
   CFX_ByteString style = GetNameFromTT(names, names.GetLength(), 2);
   if (style != "Regular") {
     facename += " " + style;
   }
   if (pdfium::ContainsKey(m_FontList, facename))
     return;
 
   CFX_FontFaceInfo* pInfo =
       new CFX_FontFaceInfo(path, facename, tables, offset, filesize);
   CFX_ByteString os2 = FPDF_LoadTableFromTT(pFile, tables, nTables, 0x4f532f32);
   if (os2.GetLength() >= 86) {
     const uint8_t* p = (const uint8_t*)os2 + 78;
-    FX_DWORD codepages = GET_TT_LONG(p);
+    uint32_t codepages = GET_TT_LONG(p);
     if (codepages & (1 << 17)) {
       m_pMapper->AddInstalledFont(facename, FXFONT_SHIFTJIS_CHARSET);
       pInfo->m_Charsets |= CHARSET_FLAG_SHIFTJIS;
     }
     if (codepages & (1 << 18)) {
       m_pMapper->AddInstalledFont(facename, FXFONT_GB2312_CHARSET);
       pInfo->m_Charsets |= CHARSET_FLAG_GB;
     }
     if (codepages & (1 << 20)) {
       m_pMapper->AddInstalledFont(facename, FXFONT_CHINESEBIG5_CHARSET);
@@ skipping 36 matching lines @@
 void* CFX_FolderFontInfo::FindFont(int weight,
                                    FX_BOOL bItalic,
                                    int charset,
                                    int pitch_family,
                                    const FX_CHAR* family,
                                    FX_BOOL bMatchName) {
   CFX_FontFaceInfo* pFind = nullptr;
   if (charset == FXFONT_ANSI_CHARSET && (pitch_family & FXFONT_FF_FIXEDPITCH)) {
     return GetFont("Courier New");
   }
-  FX_DWORD charset_flag = GetCharset(charset);
+  uint32_t charset_flag = GetCharset(charset);
   int32_t iBestSimilar = 0;
   for (const auto& it : m_FontList) {
     const CFX_ByteString& bsName = it.first;
     CFX_FontFaceInfo* pFont = it.second;
     if (!(pFont->m_Charsets & charset_flag) &&
         charset != FXFONT_DEFAULT_CHARSET) {
       continue;
     }
     int32_t index = bsName.Find(family);
     if (bMatchName && index < 0) {
@@ skipping 11 matching lines @@
 void* CFX_FolderFontInfo::MapFont(int weight,
                                   FX_BOOL bItalic,
                                   int charset,
                                   int pitch_family,
                                   const FX_CHAR* family,
                                   int& iExact) {
   return NULL;
 }
 
 #ifdef PDF_ENABLE_XFA
-void* CFX_FolderFontInfo::MapFontByUnicode(FX_DWORD dwUnicode,
+void* CFX_FolderFontInfo::MapFontByUnicode(uint32_t dwUnicode,
                                            int weight,
                                            FX_BOOL bItalic,
                                            int pitch_family) {
   return NULL;
 }
 #endif  // PDF_ENABLE_XFA
 
 void* CFX_FolderFontInfo::GetFont(const FX_CHAR* face) {
   auto it = m_FontList.find(face);
   return it != m_FontList.end() ? it->second : nullptr;
 }
 
-FX_DWORD CFX_FolderFontInfo::GetFontData(void* hFont,
-                                         FX_DWORD table,
+uint32_t CFX_FolderFontInfo::GetFontData(void* hFont,
+                                         uint32_t table,
                                          uint8_t* buffer,
-                                         FX_DWORD size) {
+                                         uint32_t size) {
   if (!hFont)
     return 0;
 
   const CFX_FontFaceInfo* pFont = static_cast<CFX_FontFaceInfo*>(hFont);
-  FX_DWORD datasize = 0;
-  FX_DWORD offset = 0;
+  uint32_t datasize = 0;
+  uint32_t offset = 0;
   if (table == 0) {
     datasize = pFont->m_FontOffset ? 0 : pFont->m_FileSize;
   } else if (table == kTableTTCF) {
     datasize = pFont->m_FontOffset ? pFont->m_FileSize : 0;
   } else {
-    FX_DWORD nTables = pFont->m_FontTables.GetLength() / 16;
-    for (FX_DWORD i = 0; i < nTables; i++) {
+    uint32_t nTables = pFont->m_FontTables.GetLength() / 16;
+    for (uint32_t i = 0; i < nTables; i++) {
       const uint8_t* p =
           static_cast<const uint8_t*>(pFont->m_FontTables) + i * 16;
       if (GET_TT_LONG(p) == table) {
         offset = GET_TT_LONG(p + 8);
         datasize = GET_TT_LONG(p + 12);
       }
     }
   }
 
   if (!datasize || size < datasize)
@@ skipping 27 matching lines @@
 int PDF_GetStandardFontName(CFX_ByteString* name) {
   AltFontName* found = static_cast<AltFontName*>(
       FXSYS_bsearch(name->c_str(), g_AltFontNames, FX_ArraySize(g_AltFontNames),
                     sizeof(AltFontName), CompareString));
   if (!found)
     return -1;
 
   *name = g_Base14FontNames[found->m_Index];
   return found->m_Index;
 }