Remove FX_DWORD from core/ and delete definition

core/fxge/android/fpf_skiafontmgr.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/fxcrt/include/fx_system.h"
 
 #if _FX_OS_ == _FX_ANDROID_
 
@@ skipping 24 matching lines @@
       return 0;
     }
   }
   return count;
 }
 static void FPF_SkiaStream_Close(FXFT_Stream stream) {}
 #ifdef __cplusplus
 };
 #endif
 struct FPF_SKIAFONTMAP {
-  FX_DWORD dwFamily;
-  FX_DWORD dwSubSt;
+  uint32_t dwFamily;
+  uint32_t dwSubSt;
 };
 static const FPF_SKIAFONTMAP g_SkiaFontmap[] = {
     {0x58c5083, 0xc8d2e345},  {0x5dfade2, 0xe1633081},
     {0x684317d, 0xe1633081},  {0x14ee2d13, 0xc8d2e345},
     {0x3918fe2d, 0xbbeeec72}, {0x3b98b31c, 0xe1633081},
     {0x3d49f40e, 0xe1633081}, {0x432c41c5, 0xe1633081},
     {0x491b6ad0, 0xe1633081}, {0x5612cab1, 0x59b9f8f1},
     {0x779ce19d, 0xc8d2e345}, {0x7cc9510b, 0x59b9f8f1},
     {0x83746053, 0xbbeeec72}, {0xaaa60c03, 0xbbeeec72},
     {0xbf85ff26, 0xe1633081}, {0xc04fe601, 0xbbeeec72},
     {0xca3812d5, 0x59b9f8f1}, {0xca383e15, 0x59b9f8f1},
     {0xcad5eaf6, 0x59b9f8f1}, {0xcb7a04c8, 0xc8d2e345},
     {0xfb4ce0de, 0xe1633081},
 };
-FX_DWORD FPF_SkiaGetSubstFont(FX_DWORD dwHash) {
+uint32_t FPF_SkiaGetSubstFont(uint32_t dwHash) {
   int32_t iStart = 0;
   int32_t iEnd = sizeof(g_SkiaFontmap) / sizeof(FPF_SKIAFONTMAP);
   while (iStart <= iEnd) {
     int32_t iMid = (iStart + iEnd) / 2;
     const FPF_SKIAFONTMAP* pItem = &g_SkiaFontmap[iMid];
     if (dwHash < pItem->dwFamily) {
       iEnd = iMid - 1;
     } else if (dwHash > pItem->dwFamily) {
       iStart = iMid + 1;
     } else {
       return pItem->dwSubSt;
     }
   }
   return 0;
 }
 static const FPF_SKIAFONTMAP g_SkiaSansFontMap[] = {
     {0x58c5083, 0xd5b8d10f},  {0x14ee2d13, 0xd5b8d10f},
     {0x779ce19d, 0xd5b8d10f}, {0xcb7a04c8, 0xd5b8d10f},
     {0xfb4ce0de, 0xd5b8d10f},
 };
-FX_DWORD FPF_SkiaGetSansFont(FX_DWORD dwHash) {
+uint32_t FPF_SkiaGetSansFont(uint32_t dwHash) {
   int32_t iStart = 0;
   int32_t iEnd = sizeof(g_SkiaSansFontMap) / sizeof(FPF_SKIAFONTMAP);
   while (iStart <= iEnd) {
     int32_t iMid = (iStart + iEnd) / 2;
     const FPF_SKIAFONTMAP* pItem = &g_SkiaSansFontMap[iMid];
     if (dwHash < pItem->dwFamily) {
       iEnd = iMid - 1;
     } else if (dwHash > pItem->dwFamily) {
       iStart = iMid + 1;
     } else {
@@ skipping 38 matching lines @@
   FPF_SKIACHARSET_Vietnamese = 1 << 10,
   FPF_SKIACHARSET_Hebrew = 1 << 11,
   FPF_SKIACHARSET_Arabic = 1 << 12,
   FPF_SKIACHARSET_Baltic = 1 << 13,
   FPF_SKIACHARSET_Cyrillic = 1 << 14,
   FPF_SKIACHARSET_Thai = 1 << 15,
   FPF_SKIACHARSET_EeasternEuropean = 1 << 16,
   FPF_SKIACHARSET_PC = 1 << 17,
   FPF_SKIACHARSET_OEM = 1 << 18,
 };
-static FX_DWORD FPF_SkiaGetCharset(uint8_t uCharset) {
+static uint32_t FPF_SkiaGetCharset(uint8_t uCharset) {
   switch (uCharset) {
     case FXFONT_ANSI_CHARSET:
       return FPF_SKIACHARSET_Ansi;
     case FXFONT_DEFAULT_CHARSET:
       return FPF_SKIACHARSET_Default;
     case FXFONT_SYMBOL_CHARSET:
       return FPF_SKIACHARSET_Symbol;
     case FXFONT_SHIFTJIS_CHARSET:
       return FPF_SKIACHARSET_ShiftJIS;
     case FXFONT_HANGEUL_CHARSET:
@@ skipping 14 matching lines @@
       return FPF_SKIACHARSET_Baltic;
     case FXFONT_RUSSIAN_CHARSET:
       return FPF_SKIACHARSET_Cyrillic;
     case FXFONT_THAI_CHARSET:
       return FPF_SKIACHARSET_Thai;
     case FXFONT_EASTEUROPE_CHARSET:
       return FPF_SKIACHARSET_EeasternEuropean;
   }
   return FPF_SKIACHARSET_Default;
 }
-static FX_DWORD FPF_SKIANormalizeFontName(const CFX_ByteStringC& bsfamily) {
-  FX_DWORD dwHash = 0;
+static uint32_t FPF_SKIANormalizeFontName(const CFX_ByteStringC& bsfamily) {
+  uint32_t dwHash = 0;
   int32_t iLength = bsfamily.GetLength();
   const FX_CHAR* pBuffer = bsfamily.GetCStr();
   for (int32_t i = 0; i < iLength; i++) {
     FX_CHAR ch = pBuffer[i];
     if (ch == ' ' || ch == '-' || ch == ',') {
       continue;
     }
     dwHash = 31 * dwHash + FXSYS_tolower(ch);
   }
   return dwHash;
 }
-static FX_DWORD FPF_SKIAGetFamilyHash(const CFX_ByteStringC& bsFamily,
-                                      FX_DWORD dwStyle,
+static uint32_t FPF_SKIAGetFamilyHash(const CFX_ByteStringC& bsFamily,
+                                      uint32_t dwStyle,
                                       uint8_t uCharset) {
   CFX_ByteString bsFont(bsFamily);
   if (dwStyle & FXFONT_BOLD) {
     bsFont += "Bold";
   }
   if (dwStyle & FXFONT_ITALIC) {
     bsFont += "Italic";
   }
   if (dwStyle & FXFONT_SERIF) {
     bsFont += "Serif";
@@ skipping 44 matching lines @@
   }
   ScanPath("/system/fonts");
   OutputSystemFonts();
   m_bLoaded = TRUE;
 }
 void CFPF_SkiaFontMgr::LoadPrivateFont(IFX_FileRead* pFontFile) {}
 void CFPF_SkiaFontMgr::LoadPrivateFont(const CFX_ByteStringC& bsFileName) {}
 void CFPF_SkiaFontMgr::LoadPrivateFont(void* pBuffer, size_t szBuffer) {}
 IFPF_Font* CFPF_SkiaFontMgr::CreateFont(const CFX_ByteStringC& bsFamilyname,
                                         uint8_t uCharset,
-                                        FX_DWORD dwStyle,
-                                        FX_DWORD dwMatch) {
-  FX_DWORD dwHash = FPF_SKIAGetFamilyHash(bsFamilyname, dwStyle, uCharset);
+                                        uint32_t dwStyle,
+                                        uint32_t dwMatch) {
+  uint32_t dwHash = FPF_SKIAGetFamilyHash(bsFamilyname, dwStyle, uCharset);
   auto it = m_FamilyFonts.find(dwHash);
   if (it != m_FamilyFonts.end() && it->second)
     return it->second->Retain();
 
-  FX_DWORD dwFaceName = FPF_SKIANormalizeFontName(bsFamilyname);
-  FX_DWORD dwSubst = FPF_SkiaGetSubstFont(dwFaceName);
-  FX_DWORD dwSubstSans = FPF_SkiaGetSansFont(dwFaceName);
+  uint32_t dwFaceName = FPF_SKIANormalizeFontName(bsFamilyname);
+  uint32_t dwSubst = FPF_SkiaGetSubstFont(dwFaceName);
+  uint32_t dwSubstSans = FPF_SkiaGetSansFont(dwFaceName);
   FX_BOOL bMaybeSymbol = FPF_SkiaMaybeSymbol(bsFamilyname);
   if (uCharset != FXFONT_ARABIC_CHARSET && FPF_SkiaMaybeArabic(bsFamilyname)) {
     uCharset = FXFONT_ARABIC_CHARSET;
   } else if (uCharset == FXFONT_ANSI_CHARSET &&
              (dwMatch & FPF_MATCHFONT_REPLACEANSI)) {
     uCharset = FXFONT_DEFAULT_CHARSET;
   }
   int32_t nExpectVal = FPF_SKIAMATCHWEIGHT_NAME1 + FPF_SKIAMATCHWEIGHT_1 * 3 +
                        FPF_SKIAMATCHWEIGHT_2 * 2;
   int32_t nItem = -1;
   int32_t nMax = -1;
   int32_t nGlyphNum = 0;
   for (auto it = m_FontFaces.rbegin(); it != m_FontFaces.rend(); ++it) {
     CFPF_SkiaPathFont* pFontDes = static_cast<CFPF_SkiaPathFont*>(*it);
     if (!(pFontDes->m_dwCharsets & FPF_SkiaGetCharset(uCharset))) {
       continue;
     }
     int32_t nFind = 0;
-    FX_DWORD dwSysFontName = FPF_SKIANormalizeFontName(pFontDes->m_pFamily);
+    uint32_t dwSysFontName = FPF_SKIANormalizeFontName(pFontDes->m_pFamily);
     if (dwFaceName == dwSysFontName) {
       nFind += FPF_SKIAMATCHWEIGHT_NAME1;
     }
     bool bMatchedName = (nFind == FPF_SKIAMATCHWEIGHT_NAME1);
     if ((dwStyle & FXFONT_BOLD) == (pFontDes->m_dwStyle & FXFONT_BOLD)) {
       nFind += FPF_SKIAMATCHWEIGHT_1;
     }
     if ((dwStyle & FXFONT_ITALIC) == (pFontDes->m_dwStyle & FXFONT_ITALIC)) {
       nFind += FPF_SKIAMATCHWEIGHT_1;
     }
@@ skipping 139 matching lines @@
 void CFPF_SkiaFontMgr::ScanFile(const CFX_ByteStringC& file) {
   FXFT_Face face = GetFontFace(file);
   if (face) {
     CFPF_SkiaPathFont* pFontDesc = new CFPF_SkiaPathFont;
     pFontDesc->SetPath(file.GetCStr());
     ReportFace(face, pFontDesc);
     m_FontFaces.push_back(pFontDesc);
     FXFT_Done_Face(face);
   }
 }
-static const FX_DWORD g_FPFSkiaFontCharsets[] = {
+static const uint32_t g_FPFSkiaFontCharsets[] = {
     FPF_SKIACHARSET_Ansi,
     FPF_SKIACHARSET_EeasternEuropean,
     FPF_SKIACHARSET_Cyrillic,
     FPF_SKIACHARSET_Greek,
     FPF_SKIACHARSET_Turkish,
     FPF_SKIACHARSET_Hebrew,
     FPF_SKIACHARSET_Arabic,
     FPF_SKIACHARSET_Baltic,
     0,
     0,
@@ skipping 13 matching lines @@
     0,
     0,
     0,
     0,
     0,
     0,
     0,
     FPF_SKIACHARSET_OEM,
     FPF_SKIACHARSET_Symbol,
 };
-static FX_DWORD FPF_SkiaGetFaceCharset(TT_OS2* pOS2) {
-  FX_DWORD dwCharset = 0;
+static uint32_t FPF_SkiaGetFaceCharset(TT_OS2* pOS2) {
+  uint32_t dwCharset = 0;
   if (pOS2) {
     for (int32_t i = 0; i < 32; i++) {
       if (pOS2->ulCodePageRange1 & (1 << i)) {
         dwCharset |= g_FPFSkiaFontCharsets[i];
       }
     }
   }
   dwCharset |= FPF_SKIACHARSET_Default;
   return dwCharset;
 }
@@ skipping 26 matching lines @@
   }
   if (pOS2 && (pOS2->ulCodePageRange1 & (1 << 31))) {
     pFontDesc->m_dwStyle |= FXFONT_SYMBOLIC;
   }
   pFontDesc->m_dwCharsets = FPF_SkiaGetFaceCharset(pOS2);
   pFontDesc->m_iFaceIndex = face->face_index;
   pFontDesc->m_iGlyphNum = face->num_glyphs;
 }
 void CFPF_SkiaFontMgr::OutputSystemFonts() {}
 #endif