Remove FX_DWORD from XFA.

xfa/fgas/font/fgas_stdfontmgr.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 "xfa/fgas/font/fgas_stdfontmgr.h"
 
 #include "core/fxcrt/include/fx_stream.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
@@ skipping 40 matching lines @@
   for (int32_t i = m_Fonts.GetUpperBound(); i >= 0; i--) {
     IFX_Font* pFont = (IFX_Font*)m_Fonts[i];
     if (pFont != NULL) {
       pFont->Release();
     }
   }
   m_Fonts.RemoveAll();
 }
 IFX_Font* CFX_StdFontMgrImp::GetDefFontByCodePage(
     uint16_t wCodePage,
-    FX_DWORD dwFontStyles,
+    uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
-  FX_DWORD dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
+  uint32_t dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
   IFX_Font* pFont = NULL;
   if (m_CPFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
   }
   FX_LPCFONTDESCRIPTOR pFD;
   if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {
     if ((pFD = FindFont(NULL, dwFontStyles, TRUE, wCodePage)) == NULL) {
       if ((pFD = FindFont(NULL, dwFontStyles, FALSE, wCodePage)) == NULL)
         return NULL;
     }
   }
   FXSYS_assert(pFD != NULL);
   pFont = IFX_Font::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
   if (pFont != NULL) {
     m_Fonts.Add(pFont);
     m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     dwHash = FGAS_GetFontFamilyHash(pFD->wsFontFace, dwFontStyles, wCodePage);
     m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return NULL;
 }
 IFX_Font* CFX_StdFontMgrImp::GetDefFontByCharset(
     uint8_t nCharset,
-    FX_DWORD dwFontStyles,
+    uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles,
                               pszFontFamily);
 }
 
 IFX_Font* CFX_StdFontMgrImp::GetDefFontByUnicode(
     FX_WCHAR wUnicode,
-    FX_DWORD dwFontStyles,
+    uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   const FGAS_FONTUSB* pRet = FGAS_GetUnicodeBitField(wUnicode);
   if (pRet->wBitField == 999)
     return nullptr;
 
-  FX_DWORD dwHash =
+  uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, pRet->wBitField);
   IFX_Font* pFont = nullptr;
   if (m_UnicodeFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont))
     return pFont ? LoadFont(pFont, dwFontStyles, pRet->wCodePage) : nullptr;
 
   FX_LPCFONTDESCRIPTOR pFD =
       FindFont(pszFontFamily, dwFontStyles, FALSE, pRet->wCodePage,
                pRet->wBitField, wUnicode);
   if (!pFD && pszFontFamily) {
     pFD = FindFont(nullptr, dwFontStyles, FALSE, pRet->wCodePage,
@@ skipping 12 matching lines @@
     m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     dwHash = FGAS_GetFontFamilyHash(pFontFace, dwFontStyles, wCodePage);
     m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return nullptr;
 }
 
 IFX_Font* CFX_StdFontMgrImp::GetDefFontByLanguage(
     uint16_t wLanguage,
-    FX_DWORD dwFontStyles,
+    uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage),
                               dwFontStyles, pszFontFamily);
 }
 IFX_Font* CFX_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFontFamily,
-                                      FX_DWORD dwFontStyles,
+                                      uint32_t dwFontStyles,
                                       uint16_t wCodePage) {
-  FX_DWORD dwHash =
+  uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, wCodePage);
   IFX_Font* pFont = NULL;
   if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
   }
   FX_LPCFONTDESCRIPTOR pFD = NULL;
   if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {
     if ((pFD = FindFont(pszFontFamily, dwFontStyles, FALSE, wCodePage)) ==
         NULL) {
       return NULL;
@@ skipping 24 matching lines @@
   pFont = IFX_Font::LoadFont(pBuffer, iLength, this);
   if (pFont != NULL) {
     m_Fonts.Add(pFont);
     m_BufferFonts.SetAt((void*)pBuffer, pFont);
     return pFont->Retain();
   }
   return NULL;
 }
 IFX_Font* CFX_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFileName) {
   FXSYS_assert(pszFileName != NULL);
-  FX_DWORD dwHash = FX_HashCode_String_GetW(pszFileName, -1);
+  uint32_t dwHash = FX_HashCode_String_GetW(pszFileName, -1);
   IFX_Font* pFont = NULL;
   if (m_FileFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     if (pFont != NULL) {
       return pFont->Retain();
     }
   }
   pFont = IFX_Font::LoadFont(pszFileName, NULL);
   if (pFont != NULL) {
     m_Fonts.Add(pFont);
     m_FileFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return pFont->Retain();
   }
   return NULL;
 }
 IFX_Font* CFX_StdFontMgrImp::LoadFont(IFX_Stream* pFontStream,
                                       const FX_WCHAR* pszFontAlias,
-                                      FX_DWORD dwFontStyles,
+                                      uint32_t dwFontStyles,
                                       uint16_t wCodePage,
                                       FX_BOOL bSaveStream) {
   FXSYS_assert(pFontStream != NULL && pFontStream->GetLength() > 0);
   IFX_Font* pFont = NULL;
   if (m_StreamFonts.Lookup((void*)pFontStream, (void*&)pFont)) {
     if (pFont != NULL) {
       if (pszFontAlias != NULL) {
-        FX_DWORD dwHash =
+        uint32_t dwHash =
             FGAS_GetFontFamilyHash(pszFontAlias, dwFontStyles, wCodePage);
         m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
       }
       return LoadFont(pFont, dwFontStyles, wCodePage);
     }
   }
   pFont = IFX_Font::LoadFont(pFontStream, this, bSaveStream);
   if (pFont != NULL) {
     m_Fonts.Add(pFont);
     m_StreamFonts.SetAt((void*)pFontStream, (void*)pFont);
     if (pszFontAlias != NULL) {
-      FX_DWORD dwHash =
+      uint32_t dwHash =
           FGAS_GetFontFamilyHash(pszFontAlias, dwFontStyles, wCodePage);
       m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     }
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return NULL;
 }
 IFX_Font* CFX_StdFontMgrImp::LoadFont(IFX_Font* pSrcFont,
-                                      FX_DWORD dwFontStyles,
+                                      uint32_t dwFontStyles,
                                       uint16_t wCodePage) {
   FXSYS_assert(pSrcFont != NULL);
   if (pSrcFont->GetFontStyles() == dwFontStyles) {
     return pSrcFont->Retain();
   }
   void* buffer[3] = {pSrcFont, (void*)(uintptr_t)dwFontStyles,
                      (void*)(uintptr_t)wCodePage};
-  FX_DWORD dwHash =
+  uint32_t dwHash =
       FX_HashCode_String_GetA((const FX_CHAR*)buffer, 3 * sizeof(void*));
   IFX_Font* pFont = NULL;
   if (m_DeriveFonts.GetCount() > 0) {
     m_DeriveFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont);
     if (pFont != NULL) {
       return pFont->Retain();
     }
   }
   pFont = pSrcFont->Derive(dwFontStyles, wCodePage);
   if (pFont != NULL) {
@@ skipping 37 matching lines @@
   RemoveFont(m_BufferFonts, pFont);
   RemoveFont(m_FileFonts, pFont);
   RemoveFont(m_StreamFonts, pFont);
   RemoveFont(m_DeriveFonts, pFont);
   int32_t iFind = m_Fonts.Find(pFont);
   if (iFind > -1) {
     m_Fonts.RemoveAt(iFind, 1);
   }
 }
 FX_LPCFONTDESCRIPTOR CFX_StdFontMgrImp::FindFont(const FX_WCHAR* pszFontFamily,
-                                                 FX_DWORD dwFontStyles,
-                                                 FX_DWORD dwMatchFlags,
+                                                 uint32_t dwFontStyles,
+                                                 uint32_t dwMatchFlags,
                                                  uint16_t wCodePage,
-                                                 FX_DWORD dwUSB,
+                                                 uint32_t dwUSB,
                                                  FX_WCHAR wUnicode) {
   if (m_pMatcher == NULL) {
     return NULL;
   }
   FX_FONTMATCHPARAMS params;
   FXSYS_memset(&params, 0, sizeof(params));
   params.dwUSB = dwUSB;
   params.wUnicode = wUnicode;
   params.wCodePage = wCodePage;
   params.pwsFamily = pszFontFamily;
@@ skipping 46 matching lines @@
     }
     if (pFont->uCharSet == FX_CHARSET_Symbol) {
       continue;
     }
     if (pParams->wCodePage != 0xFFFF) {
       if (FX_GetCodePageFromCharset(pFont->uCharSet) != pParams->wCodePage) {
         continue;
       }
     } else {
       if (pParams->dwUSB < 128) {
-        FX_DWORD dwByte = pParams->dwUSB / 32;
-        FX_DWORD dwUSB = 1 << (pParams->dwUSB % 32);
+        uint32_t dwByte = pParams->dwUSB / 32;
+        uint32_t dwUSB = 1 << (pParams->dwUSB % 32);
         if ((pFont->FontSignature.fsUsb[dwByte] & dwUSB) == 0) {
           continue;
         }
       }
     }
     if (bMatchStyle) {
       if ((pFont->dwFontStyles & 0x0F) == (pParams->dwFontStyles & 0x0F)) {
         return pFont;
       } else {
         continue;
       }
     }
     if (pParams->pwsFamily != NULL) {
       if (FXSYS_wcsicmp(pParams->pwsFamily, pFont->wsFontFace) == 0) {
         return pFont;
       }
     }
     int32_t iSimilarValue = FX_GetSimilarValue(pFont, pParams->dwFontStyles);
     if (iBestSimilar < iSimilarValue) {
       iBestSimilar = iSimilarValue;
       pBestFont = pFont;
     }
   }
   return iBestSimilar < 1 ? NULL : pBestFont;
 }
-int32_t FX_GetSimilarValue(FX_LPCFONTDESCRIPTOR pFont, FX_DWORD dwFontStyles) {
+int32_t FX_GetSimilarValue(FX_LPCFONTDESCRIPTOR pFont, uint32_t dwFontStyles) {
   int32_t iValue = 0;
   if ((dwFontStyles & FX_FONTSTYLE_Symbolic) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_Symbolic)) {
     iValue += 64;
   }
   if ((dwFontStyles & FX_FONTSTYLE_FixedPitch) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_FixedPitch)) {
     iValue += 32;
   }
   if ((dwFontStyles & FX_FONTSTYLE_Serif) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_Serif)) {
     iValue += 16;
   }
   if ((dwFontStyles & FX_FONTSTYLE_Script) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_Script)) {
     iValue += 8;
   }
   return iValue;
 }
 FX_LPMatchFont FX_GetDefFontMatchor() {
   return FX_DefFontMatcher;
 }
-FX_DWORD FX_GetGdiFontStyles(const LOGFONTW& lf) {
-  FX_DWORD dwStyles = 0;
+uint32_t FX_GetGdiFontStyles(const LOGFONTW& lf) {
+  uint32_t dwStyles = 0;
   if ((lf.lfPitchAndFamily & 0x03) == FIXED_PITCH) {
     dwStyles |= FX_FONTSTYLE_FixedPitch;
   }
   uint8_t nFamilies = lf.lfPitchAndFamily & 0xF0;
   if (nFamilies == FF_ROMAN) {
     dwStyles |= FX_FONTSTYLE_Serif;
   }
   if (nFamilies == FF_SCRIPT) {
     dwStyles |= FX_FONTSTYLE_Script;
   }
@@ skipping 205 matching lines @@
   if (EnumFontsFromFontMapper())
     return TRUE;
   return EnumFontsFromFiles();
 }
 void CFX_FontMgrImp::Release() {
   for (int32_t i = 0; i < m_InstalledFonts.GetSize(); i++) {
     delete m_InstalledFonts[i];
   }
   FX_POSITION pos = m_Hash2CandidateList.GetStartPosition();
   while (pos) {
-    FX_DWORD dwHash;
+    uint32_t dwHash;
     CFX_FontDescriptorInfos* pDescs;
     m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs);
     if (NULL != pDescs) {
       delete pDescs;
     }
   }
   pos = m_Hash2Fonts.GetStartPosition();
   while (pos) {
-    FX_DWORD dwHash;
+    uint32_t dwHash;
     CFX_ArrayTemplate<IFX_Font*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
     if (NULL != pFonts) {
       delete pFonts;
     }
   }
   m_Hash2Fonts.RemoveAll();
   pos = m_Hash2FileAccess.GetStartPosition();
   while (pos) {
-    FX_DWORD dwHash;
+    uint32_t dwHash;
     IFX_FileAccess* pFileAccess;
     m_Hash2FileAccess.GetNextAssoc(pos, dwHash, pFileAccess);
     if (NULL != pFileAccess) {
       pFileAccess->Release();
     }
   }
   pos = m_FileAccess2IFXFont.GetStartPosition();
   while (pos) {
-    FX_DWORD dwHash;
+    uint32_t dwHash;
     IFX_Font* pFont;
     m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pFont);
     if (NULL != pFont) {
       pFont->Release();
     }
   }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     IFX_Font* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
   delete this;
 }
 IFX_Font* CFX_FontMgrImp::GetDefFontByCodePage(uint16_t wCodePage,
-                                               FX_DWORD dwFontStyles,
+                                               uint32_t dwFontStyles,
                                                const FX_WCHAR* pszFontFamily) {
   return NULL == m_pDelegate ? NULL : m_pDelegate->GetDefFontByCodePage(
                                           this, wCodePage, dwFontStyles,
                                           pszFontFamily);
 }
 IFX_Font* CFX_FontMgrImp::GetDefFontByCharset(uint8_t nCharset,
-                                              FX_DWORD dwFontStyles,
+                                              uint32_t dwFontStyles,
                                               const FX_WCHAR* pszFontFamily) {
   return NULL == m_pDelegate ? NULL
                              : m_pDelegate->GetDefFontByCharset(
                                    this, nCharset, dwFontStyles, pszFontFamily);
 }
 IFX_Font* CFX_FontMgrImp::GetDefFontByUnicode(FX_WCHAR wUnicode,
-                                              FX_DWORD dwFontStyles,
+                                              uint32_t dwFontStyles,
                                               const FX_WCHAR* pszFontFamily) {
   return NULL == m_pDelegate ? NULL
                              : m_pDelegate->GetDefFontByUnicode(
                                    this, wUnicode, dwFontStyles, pszFontFamily);
 }
 IFX_Font* CFX_FontMgrImp::GetDefFontByLanguage(uint16_t wLanguage,
-                                               FX_DWORD dwFontStyles,
+                                               uint32_t dwFontStyles,
                                                const FX_WCHAR* pszFontFamily) {
   return NULL == m_pDelegate ? NULL : m_pDelegate->GetDefFontByLanguage(
                                           this, wLanguage, dwFontStyles,
                                           pszFontFamily);
 }
 IFX_Font* CFX_FontMgrImp::GetFontByCodePage(uint16_t wCodePage,
-                                            FX_DWORD dwFontStyles,
+                                            uint32_t dwFontStyles,
                                             const FX_WCHAR* pszFontFamily) {
   CFX_ByteString bsHash;
   bsHash.Format("%d, %d", wCodePage, dwFontStyles);
   bsHash += CFX_WideString(pszFontFamily).UTF8Encode();
-  FX_DWORD dwHash = FX_HashCode_String_GetA(bsHash, bsHash.GetLength());
+  uint32_t dwHash = FX_HashCode_String_GetA(bsHash, bsHash.GetLength());
   CFX_ArrayTemplate<IFX_Font*>* pFonts = NULL;
   IFX_Font* pFont = NULL;
   if (m_Hash2Fonts.Lookup(dwHash, pFonts)) {
     if (NULL == pFonts) {
       return NULL;
     }
     if (0 != pFonts->GetSize()) {
       return pFonts->GetAt(0)->Retain();
     }
   }
@@ skipping 15 matching lines @@
     pFont = LoadFont(pDesc->m_pFileAccess, pDesc->m_nFaceIndex, nullptr);
   else
     pFont = LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
   if (NULL != pFont) {
     pFont->SetLogicalFontStyle(dwFontStyles);
   }
   pFonts->Add(pFont);
   return pFont;
 }
 IFX_Font* CFX_FontMgrImp::GetFontByCharset(uint8_t nCharset,
-                                           FX_DWORD dwFontStyles,
+                                           uint32_t dwFontStyles,
                                            const FX_WCHAR* pszFontFamily) {
   return GetFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles,
                            pszFontFamily);
 }
 IFX_Font* CFX_FontMgrImp::GetFontByUnicode(FX_WCHAR wUnicode,
-                                           FX_DWORD dwFontStyles,
+                                           uint32_t dwFontStyles,
                                            const FX_WCHAR* pszFontFamily) {
   IFX_Font* pFont = nullptr;
   if (m_FailedUnicodes2NULL.Lookup(wUnicode, pFont))
     return nullptr;
   const FGAS_FONTUSB* x = FGAS_GetUnicodeBitField(wUnicode);
   uint16_t wCodePage = x ? x->wCodePage : 0xFFFF;
   uint16_t wBitField = x ? x->wBitField : 0x03E7;
   CFX_ByteString bsHash;
   if (wCodePage == 0xFFFF)
     bsHash.Format("%d, %d, %d", wCodePage, wBitField, dwFontStyles);
   else
     bsHash.Format("%d, %d", wCodePage, dwFontStyles);
   bsHash += CFX_WideString(pszFontFamily).UTF8Encode();
-  FX_DWORD dwHash = FX_HashCode_String_GetA(bsHash, bsHash.GetLength());
+  uint32_t dwHash = FX_HashCode_String_GetA(bsHash, bsHash.GetLength());
   CFX_ArrayTemplate<IFX_Font*>* pFonts = nullptr;
   if (m_Hash2Fonts.Lookup(dwHash, pFonts)) {
     if (!pFonts)
       return nullptr;
     for (int32_t i = 0; i < pFonts->GetSize(); ++i) {
       if (VerifyUnicode(pFonts->GetAt(i), wUnicode))
         return pFonts->GetAt(i)->Retain();
     }
   }
   if (!pFonts)
@@ skipping 53 matching lines @@
   if (0 != FXFT_Select_Charmap(pFace, FXFT_ENCODING_UNICODE)) {
     return FALSE;
   }
   if (0 == FXFT_Get_Char_Index(pFace, wcUnicode)) {
     FXFT_Set_Charmap(pFace, charmap);
     return FALSE;
   }
   return TRUE;
 }
 IFX_Font* CFX_FontMgrImp::GetFontByLanguage(uint16_t wLanguage,
-                                            FX_DWORD dwFontStyles,
+                                            uint32_t dwFontStyles,
                                             const FX_WCHAR* pszFontFamily) {
   return GetFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage), dwFontStyles,
                            pszFontFamily);
 }
 IFX_Font* CFX_FontMgrImp::LoadFont(const uint8_t* pBuffer,
                                    int32_t iLength,
                                    int32_t iFaceIndex,
                                    int32_t* pFaceCount) {
   void* Hash[2] = {(void*)(uintptr_t)pBuffer, (void*)(uintptr_t)iLength};
-  FX_DWORD dwHash =
+  uint32_t dwHash =
       FX_HashCode_String_GetA((const FX_CHAR*)Hash, 2 * sizeof(void*));
   IFX_FileAccess* pFontAccess = NULL;
   if (!m_Hash2FileAccess.Lookup(dwHash, pFontAccess)) {
   }
   if (NULL != pFontAccess) {
     return LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE);
   } else {
     return NULL;
   }
 }
 IFX_Font* CFX_FontMgrImp::LoadFont(const FX_WCHAR* pszFileName,
                                    int32_t iFaceIndex,
                                    int32_t* pFaceCount) {
   CFX_ByteString bsHash;
   bsHash += CFX_WideString(pszFileName).UTF8Encode();
-  FX_DWORD dwHash =
+  uint32_t dwHash =
       FX_HashCode_String_GetA((const FX_CHAR*)bsHash, bsHash.GetLength());
   IFX_FileAccess* pFontAccess = NULL;
   if (!m_Hash2FileAccess.Lookup(dwHash, pFontAccess)) {
     pFontAccess = FX_CreateDefaultFileAccess(pszFileName);
     m_Hash2FileAccess.SetAt(dwHash, pFontAccess);
   }
   if (NULL != pFontAccess) {
     return LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE);
   } else {
     return NULL;
   }
 }
 IFX_Font* CFX_FontMgrImp::LoadFont(IFX_Stream* pFontStream,
                                    int32_t iFaceIndex,
                                    int32_t* pFaceCount,
                                    FX_BOOL bSaveStream) {
   void* Hash[1] = {(void*)(uintptr_t)pFontStream};
-  FX_DWORD dwHash =
+  uint32_t dwHash =
       FX_HashCode_String_GetA((const FX_CHAR*)Hash, 1 * sizeof(void*));
   IFX_FileAccess* pFontAccess = NULL;
   if (!m_Hash2FileAccess.Lookup(dwHash, pFontAccess)) {
   }
   if (NULL != pFontAccess) {
     return LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE);
   } else {
     return NULL;
   }
 }
 IFX_Font* CFX_FontMgrImp::LoadFont(IFX_FileAccess* pFontAccess,
                                    int32_t iFaceIndex,
                                    int32_t* pFaceCount,
                                    FX_BOOL bWantCache) {
-  FX_DWORD dwHash = 0;
+  uint32_t dwHash = 0;
   IFX_Font* pFont = NULL;
   if (bWantCache) {
     CFX_ByteString bsHash;
     bsHash.Format("%d, %d", (uintptr_t)pFontAccess, iFaceIndex);
     dwHash = FX_HashCode_String_GetA(bsHash, bsHash.GetLength());
     if (m_FileAccess2IFXFont.Lookup(dwHash, pFont)) {
       if (NULL != pFont) {
         if (NULL != pFaceCount) {
           *pFaceCount = ((CFX_Font*)pFont->GetDevFont())->GetFace()->num_faces;
         }
@@ skipping 109 matching lines @@
     return nullptr;
   }
 
   FXFT_Set_Pixel_Sizes(pFace, 0, 64);
   return pFace;
 }
 
 IFX_FileRead* CFX_FontMgrImp::CreateFontStream(
     CFX_FontMapper* pFontMapper,
     IFX_SystemFontInfo* pSystemFontInfo,
-    FX_DWORD index) {
+    uint32_t index) {
   int iExact = 0;
   void* hFont = pSystemFontInfo->MapFont(
       0, 0, FXFONT_DEFAULT_CHARSET, 0, pFontMapper->GetFaceName(index), iExact);
   if (!hFont)
     return nullptr;
-  FX_DWORD dwFileSize = pSystemFontInfo->GetFontData(hFont, 0, nullptr, 0);
+  uint32_t dwFileSize = pSystemFontInfo->GetFontData(hFont, 0, nullptr, 0);
   if (dwFileSize == 0)
     return nullptr;
   uint8_t* pBuffer = FX_Alloc(uint8_t, dwFileSize + 1);
   dwFileSize = pSystemFontInfo->GetFontData(hFont, 0, pBuffer, dwFileSize);
   return FX_CreateMemoryStream(pBuffer, dwFileSize, TRUE);
 }
 
 IFX_FileRead* CFX_FontMgrImp::CreateFontStream(
     const CFX_ByteString& bsFaceName) {
   CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
   CFX_FontMapper* pFontMapper = pFontMgr->GetBuiltinMapper();
   if (!pFontMapper)
     return nullptr;
   IFX_SystemFontInfo* pSystemFontInfo = pFontMapper->GetSystemFontInfo();
   if (!pSystemFontInfo)
     return nullptr;
   pSystemFontInfo->EnumFontList(pFontMapper);
   for (int32_t i = 0; i < pFontMapper->GetFaceSize(); ++i) {
     if (pFontMapper->GetFaceName(i) == bsFaceName)
       return CreateFontStream(pFontMapper, pSystemFontInfo, i);
   }
   return nullptr;
 }
 int32_t CFX_FontMgrImp::MatchFonts(CFX_FontDescriptorInfos& MatchedFonts,
                                    uint16_t wCodePage,
-                                   FX_DWORD dwFontStyles,
+                                   uint32_t dwFontStyles,
                                    const CFX_WideString& FontName,
                                    FX_WCHAR wcUnicode) {
   MatchedFonts.RemoveAll();
   CFX_WideString wsNormalizedFontName = FontName;
   static const int32_t nMax = 0xffff;
   CFX_FontDescriptor* pFont = NULL;
   int32_t nCount = m_InstalledFonts.GetSize();
   for (int32_t i = 0; i < nCount; i++) {
     pFont = m_InstalledFonts[i];
     int32_t nPenalty = CalcPenalty(pFont, wCodePage, dwFontStyles,
@@ skipping 42 matching lines @@
   return (uint16_t)-1;
 }
 
 uint16_t FX_GetUnicodeBit(FX_WCHAR wcUnicode) {
   const FGAS_FONTUSB* x = FGAS_GetUnicodeBitField(wcUnicode);
   return x ? x->wBitField : 999;
 }
 
 int32_t CFX_FontMgrImp::CalcPenalty(CFX_FontDescriptor* pInstalled,
                                     uint16_t wCodePage,
-                                    FX_DWORD dwFontStyles,
+                                    uint32_t dwFontStyles,
                                     const CFX_WideString& FontName,
                                     FX_WCHAR wcUnicode) {
   int32_t nPenalty = 30000;
   if (0 != FontName.GetLength()) {
     if (FontName != pInstalled->m_wsFaceName) {
       int32_t i;
       for (i = 0; i < pInstalled->m_wsFamilyNames.GetSize(); i++) {
         if (pInstalled->m_wsFamilyNames[i] == FontName) {
           break;
         }
@@ skipping 16 matching lines @@
       }
       if (i == pInstalled->m_wsFamilyNames.GetSize()) {
         nPenalty += 0xFFFF;
       } else {
         nPenalty -= 26000;
       }
     } else {
       nPenalty -= 27000;
     }
   }
-  FX_DWORD dwStyleMask = pInstalled->m_dwFontStyles ^ dwFontStyles;
+  uint32_t dwStyleMask = pInstalled->m_dwFontStyles ^ dwFontStyles;
   if (dwStyleMask & FX_FONTSTYLE_Bold) {
     nPenalty += 4500;
   }
   if (dwStyleMask & FX_FONTSTYLE_FixedPitch) {
     nPenalty += 10000;
   }
   if (dwStyleMask & FX_FONTSTYLE_Italic) {
     nPenalty += 10000;
   }
   if (dwStyleMask & FX_FONTSTYLE_Serif) {
@@ skipping 25 matching lines @@
       nPenalty += 0xFFFF;
     } else {
       nPenalty -= 60000;
     }
   }
   return nPenalty;
 }
 void CFX_FontMgrImp::ClearFontCache() {
   FX_POSITION pos = m_Hash2CandidateList.GetStartPosition();
   while (pos) {
-    FX_DWORD dwHash;
+    uint32_t dwHash;
     CFX_FontDescriptorInfos* pDescs;
     m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs);
     if (NULL != pDescs) {
       delete pDescs;
     }
   }
   pos = m_FileAccess2IFXFont.GetStartPosition();
   while (pos) {
-    FX_DWORD dwHash;
+    uint32_t dwHash;
     IFX_Font* pFont;
     m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pFont);
     if (NULL != pFont) {
       pFont->Release();
     }
   }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     IFX_Font* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
 }
 void CFX_FontMgrImp::RemoveFont(IFX_Font* pEFont) {
   if (NULL == pEFont) {
     return;
   }
   IFX_FileRead* pFileRead;
   if (m_IFXFont2FileRead.Lookup(pEFont, pFileRead)) {
     pFileRead->Release();
     m_IFXFont2FileRead.RemoveKey(pEFont);
   }
   FX_POSITION pos;
   pos = m_FileAccess2IFXFont.GetStartPosition();
   while (pos) {
-    FX_DWORD dwHash;
+    uint32_t dwHash;
     IFX_Font* pCFont;
     m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pCFont);
     if (pCFont == pEFont) {
       m_FileAccess2IFXFont.RemoveKey(dwHash);
       break;
     }
   }
   pos = m_Hash2Fonts.GetStartPosition();
   while (pos) {
-    FX_DWORD dwHash;
+    uint32_t dwHash;
     CFX_ArrayTemplate<IFX_Font*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
     if (NULL != pFonts) {
       for (int32_t i = 0; i < pFonts->GetSize(); i++) {
         if (pFonts->GetAt(i) == pEFont) {
           pFonts->SetAt(i, NULL);
         }
       }
     } else {
       m_Hash2Fonts.RemoveKey(dwHash);
@@ skipping 55 matching lines @@
       continue;
     // All faces keep number of faces. It can be retrieved from any one face.
     if (!num_faces)
       num_faces = pFace->num_faces;
     RegisterFace(pFace, m_InstalledFonts, pFaceName, nullptr);
     if (FXFT_Get_Face_External_Stream(pFace))
       FXFT_Clear_Face_External_Stream(pFace);
     FXFT_Done_Face(pFace);
   } while (index < num_faces);
 }
-FX_DWORD CFX_FontMgrImp::GetFlags(FXFT_Face pFace) {
-  FX_DWORD flag = 0;
+uint32_t CFX_FontMgrImp::GetFlags(FXFT_Face pFace) {
+  uint32_t flag = 0;
   if (FT_IS_FIXED_WIDTH(pFace)) {
     flag |= FX_FONTSTYLE_FixedPitch;
   }
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
   if (!pOS2) {
     return flag;
   }
   if (pOS2->ulCodePageRange1 & (1 << 31)) {
     flag |= FX_FONTSTYLE_Symbolic;
   }
@@ skipping 125 matching lines @@
     CODEPAGERANGE_IMPLEMENT(2);
     a3 = pOS2->ulCodePageRange2 & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(3);
     a4 = (pOS2->ulCodePageRange2 >> 16) & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(4);
   } else {
     Charsets.Add(FX_CHARSET_Default);
   }
 }
 #undef CODEPAGERANGE_IMPLEMENT
-void CFX_FontMgrImp::GetUSBCSB(FXFT_Face pFace, FX_DWORD* USB, FX_DWORD* CSB) {
+void CFX_FontMgrImp::GetUSBCSB(FXFT_Face pFace, uint32_t* USB, uint32_t* CSB) {
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
   if (NULL != pOS2) {
     USB[0] = pOS2->ulUnicodeRange1;
     USB[1] = pOS2->ulUnicodeRange2;
     USB[2] = pOS2->ulUnicodeRange3;
     USB[3] = pOS2->ulUnicodeRange4;
     CSB[0] = pOS2->ulCodePageRange1;
     CSB[1] = pOS2->ulCodePageRange2;
   } else {
     USB[0] = 0;
     USB[1] = 0;
     USB[2] = 0;
     USB[3] = 0;
     CSB[0] = 0;
     CSB[1] = 0;
   }
 }
 int32_t CFX_FontMgrImp::IsPartName(const CFX_WideString& Name1,
                                    const CFX_WideString& Name2) {
   if (Name1.Find((const FX_WCHAR*)Name2) != -1) {
     return 1;
   }
   return 0;
 }
 #endif