Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_font/cpdf_cidfont.cpp

 // Copyright 2016 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/fpdfapi/fpdf_font/cpdf_cidfont.h"
 
 #include "core/fpdfapi/fpdf_cmaps/cmap_int.h"
 #include "core/fpdfapi/fpdf_font/font_int.h"
@@ skipping 106 matching lines @@
     case CIDSET_KOREA1:
       return true;
 
     default:
       return false;
   }
 }
 
 FX_WCHAR EmbeddedUnicodeFromCharcode(const FXCMAP_CMap* pEmbedMap,
                                      CIDSet charset,
-                                     FX_DWORD charcode) {
+                                     uint32_t charcode) {
   if (!IsValidEmbeddedCharcodeFromUnicodeCharset(charset))
     return 0;
 
   uint16_t cid = FPDFAPI_CIDFromCharCode(pEmbedMap, charcode);
   if (cid == 0)
     return 0;
 
   CPDF_FontGlobals* pFontGlobals =
       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
   const uint16_t* pCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_pMap;
   if (!pCodes)
     return 0;
 
   if (cid < pFontGlobals->m_EmbeddedToUnicodes[charset].m_Count)
     return pCodes[cid];
   return 0;
 }
 
-FX_DWORD EmbeddedCharcodeFromUnicode(const FXCMAP_CMap* pEmbedMap,
+uint32_t EmbeddedCharcodeFromUnicode(const FXCMAP_CMap* pEmbedMap,
                                      CIDSet charset,
                                      FX_WCHAR unicode) {
   if (!IsValidEmbeddedCharcodeFromUnicodeCharset(charset))
     return 0;
 
   CPDF_FontGlobals* pFontGlobals =
       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
   const uint16_t* pCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_pMap;
   if (!pCodes)
     return 0;
 
   int nCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_Count;
   for (int i = 0; i < nCodes; ++i) {
     if (pCodes[i] == unicode) {
-      FX_DWORD CharCode = FPDFAPI_CharCodeFromCID(pEmbedMap, i);
+      uint32_t CharCode = FPDFAPI_CharCodeFromCID(pEmbedMap, i);
       if (CharCode != 0) {
         return CharCode;
       }
     }
   }
   return 0;
 }
 
 #endif  // _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
 
@@ skipping 55 matching lines @@
 }
 
 const CPDF_CIDFont* CPDF_CIDFont::AsCIDFont() const {
   return this;
 }
 
 CPDF_CIDFont* CPDF_CIDFont::AsCIDFont() {
   return this;
 }
 
-uint16_t CPDF_CIDFont::CIDFromCharCode(FX_DWORD charcode) const {
+uint16_t CPDF_CIDFont::CIDFromCharCode(uint32_t charcode) const {
   if (!m_pCMap) {
     return (uint16_t)charcode;
   }
   return m_pCMap->CIDFromCharCode(charcode);
 }
 
 FX_BOOL CPDF_CIDFont::IsVertWriting() const {
   return m_pCMap ? m_pCMap->IsVertWriting() : FALSE;
 }
 
-CFX_WideString CPDF_CIDFont::UnicodeFromCharCode(FX_DWORD charcode) const {
+CFX_WideString CPDF_CIDFont::UnicodeFromCharCode(uint32_t charcode) const {
   CFX_WideString str = CPDF_Font::UnicodeFromCharCode(charcode);
   if (!str.IsEmpty())
     return str;
   FX_WCHAR ret = GetUnicodeFromCharCode(charcode);
   if (ret == 0)
     return CFX_WideString();
   return ret;
 }
 
-FX_WCHAR CPDF_CIDFont::GetUnicodeFromCharCode(FX_DWORD charcode) const {
+FX_WCHAR CPDF_CIDFont::GetUnicodeFromCharCode(uint32_t charcode) const {
   switch (m_pCMap->m_Coding) {
     case CIDCODING_UCS2:
     case CIDCODING_UTF16:
       return (FX_WCHAR)charcode;
     case CIDCODING_CID:
       if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded()) {
         return 0;
       }
       return m_pCID2UnicodeMap->UnicodeFromCID((uint16_t)charcode);
   }
@@ skipping 17 matching lines @@
     if (m_pCMap->m_pEmbedMap) {
       return EmbeddedUnicodeFromCharcode(m_pCMap->m_pEmbedMap,
                                          m_pCMap->m_Charset, charcode);
     }
     return 0;
 #endif
   }
   return m_pCID2UnicodeMap->UnicodeFromCID(CIDFromCharCode(charcode));
 }
 
-FX_DWORD CPDF_CIDFont::CharCodeFromUnicode(FX_WCHAR unicode) const {
-  FX_DWORD charcode = CPDF_Font::CharCodeFromUnicode(unicode);
+uint32_t CPDF_CIDFont::CharCodeFromUnicode(FX_WCHAR unicode) const {
+  uint32_t charcode = CPDF_Font::CharCodeFromUnicode(unicode);
   if (charcode)
     return charcode;
   switch (m_pCMap->m_Coding) {
     case CIDCODING_UNKNOWN:
       return 0;
     case CIDCODING_UCS2:
     case CIDCODING_UTF16:
       return unicode;
     case CIDCODING_CID: {
       if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded()) {
         return 0;
       }
-      FX_DWORD CID = 0;
+      uint32_t CID = 0;
       while (CID < 65536) {
         FX_WCHAR this_unicode =
             m_pCID2UnicodeMap->UnicodeFromCID((uint16_t)CID);
         if (this_unicode == unicode) {
           return CID;
         }
         CID++;
       }
       break;
     }
   }
 
   if (unicode < 0x80) {
-    return static_cast<FX_DWORD>(unicode);
+    return static_cast<uint32_t>(unicode);
   }
   if (m_pCMap->m_Coding == CIDCODING_CID) {
     return 0;
   }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   uint8_t buffer[32];
   int ret =
       FXSYS_WideCharToMultiByte(g_CharsetCPs[m_pCMap->m_Coding], 0, &unicode, 1,
                                 (char*)buffer, 4, NULL, NULL);
   if (ret == 1) {
@@ skipping 124 matching lines @@
       m_DefaultVY = pDefaultArray->GetIntegerAt(0);
       m_DefaultW1 = pDefaultArray->GetIntegerAt(1);
     } else {
       m_DefaultVY = 880;
       m_DefaultW1 = -1000;
     }
   }
   return TRUE;
 }
 
-FX_RECT CPDF_CIDFont::GetCharBBox(FX_DWORD charcode, int level) {
+FX_RECT CPDF_CIDFont::GetCharBBox(uint32_t charcode, int level) {
   if (charcode < 256 && m_CharBBox[charcode].right != FX_SMALL_RECT::kInvalid)
     return FX_RECT(m_CharBBox[charcode]);
 
   FX_RECT rect;
   FX_BOOL bVert = FALSE;
   int glyph_index = GlyphFromCharCode(charcode, &bVert);
   FXFT_Face face = m_Font.GetFace();
   if (face) {
     if (FXFT_Is_Face_Tricky(face)) {
       int err = FXFT_Load_Glyph(face, glyph_index,
@@ skipping 51 matching lines @@
       CFX_FloatRect rect_f(rect);
       rect_f.Transform(&matrix);
       rect = rect_f.GetOutterRect();
     }
   }
   if (charcode < 256)
     m_CharBBox[charcode] = rect.ToSmallRect();
 
   return rect;
 }
-int CPDF_CIDFont::GetCharWidthF(FX_DWORD charcode, int level) {
+int CPDF_CIDFont::GetCharWidthF(uint32_t charcode, int level) {
   if (m_pAnsiWidths && charcode < 0x80) {
     return m_pAnsiWidths[charcode];
   }
   uint16_t cid = CIDFromCharCode(charcode);
   int size = m_WidthList.GetSize();
-  FX_DWORD* list = m_WidthList.GetData();
+  uint32_t* list = m_WidthList.GetData();
   for (int i = 0; i < size; i += 3) {
     if (cid >= list[i] && cid <= list[i + 1]) {
       return (int)list[i + 2];
     }
   }
   return m_DefaultWidth;
 }
 short CPDF_CIDFont::GetVertWidth(uint16_t CID) const {
-  FX_DWORD vertsize = m_VertMetrics.GetSize() / 5;
+  uint32_t vertsize = m_VertMetrics.GetSize() / 5;
   if (vertsize == 0) {
     return m_DefaultW1;
   }
-  const FX_DWORD* pTable = m_VertMetrics.GetData();
-  for (FX_DWORD i = 0; i < vertsize; i++)
+  const uint32_t* pTable = m_VertMetrics.GetData();
+  for (uint32_t i = 0; i < vertsize; i++)
     if (pTable[i * 5] <= CID && pTable[i * 5 + 1] >= CID) {
       return (short)(int)pTable[i * 5 + 2];
     }
   return m_DefaultW1;
 }
 void CPDF_CIDFont::GetVertOrigin(uint16_t CID, short& vx, short& vy) const {
-  FX_DWORD vertsize = m_VertMetrics.GetSize() / 5;
+  uint32_t vertsize = m_VertMetrics.GetSize() / 5;
   if (vertsize) {
-    const FX_DWORD* pTable = m_VertMetrics.GetData();
-    for (FX_DWORD i = 0; i < vertsize; i++)
+    const uint32_t* pTable = m_VertMetrics.GetData();
+    for (uint32_t i = 0; i < vertsize; i++)
       if (pTable[i * 5] <= CID && pTable[i * 5 + 1] >= CID) {
         vx = (short)(int)pTable[i * 5 + 3];
         vy = (short)(int)pTable[i * 5 + 4];
         return;
       }
   }
-  FX_DWORD dwWidth = m_DefaultWidth;
+  uint32_t dwWidth = m_DefaultWidth;
   int size = m_WidthList.GetSize();
-  const FX_DWORD* list = m_WidthList.GetData();
+  const uint32_t* list = m_WidthList.GetData();
   for (int i = 0; i < size; i += 3) {
     if (CID >= list[i] && CID <= list[i + 1]) {
       dwWidth = (uint16_t)list[i + 2];
       break;
     }
   }
   vx = (short)dwWidth / 2;
   vy = (short)m_DefaultVY;
 }
-int CPDF_CIDFont::GetGlyphIndex(FX_DWORD unicode, FX_BOOL* pVertGlyph) {
+int CPDF_CIDFont::GetGlyphIndex(uint32_t unicode, FX_BOOL* pVertGlyph) {
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
   FXFT_Face face = m_Font.GetFace();
   int index = FXFT_Get_Char_Index(face, unicode);
   if (unicode == 0x2502) {
     return index;
   }
   if (index && IsVertWriting()) {
     if (m_pTTGSUBTable) {
@@ skipping 29 matching lines @@
         }
       }
     }
     return index;
   }
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
   return index;
 }
-int CPDF_CIDFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph) {
+int CPDF_CIDFont::GlyphFromCharCode(uint32_t charcode, FX_BOOL* pVertGlyph) {
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
   if (!m_pFontFile && !m_pCIDToGIDMap) {
     uint16_t cid = CIDFromCharCode(charcode);
     FX_WCHAR unicode = 0;
     if (m_bCIDIsGID) {
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
       return cid;
 #else
@@ skipping 37 matching lines @@
       }
       const FX_CHAR* name = GetAdobeCharName(iBaseEncoding, NULL, charcode);
       if (!name) {
         return charcode == 0 ? -1 : (int)charcode;
       }
       uint16_t unicode = PDF_UnicodeFromAdobeName(name);
       if (unicode) {
         if (bMSUnicode) {
           index = FXFT_Get_Char_Index(face, unicode);
         } else if (bMacRoman) {
-          FX_DWORD maccode =
+          uint32_t maccode =
               FT_CharCodeFromUnicode(FXFT_ENCODING_APPLE_ROMAN, unicode);
           index = !maccode ? FXFT_Get_Name_Index(face, (char*)name)
                            : FXFT_Get_Char_Index(face, maccode);
         } else {
           return FXFT_Get_Char_Index(face, unicode);
         }
       } else {
         return charcode == 0 ? -1 : (int)charcode;
       }
       if (index == 0 || index == 0xffff) {
@@ skipping 10 matching lines @@
 #endif
       }
     }
     if (!face)
       return unicode;
 
     int err = FXFT_Select_Charmap(face, FXFT_ENCODING_UNICODE);
     if (err != 0) {
       int i;
       for (i = 0; i < FXFT_Get_Face_CharmapCount(face); i++) {
-        FX_DWORD ret = FT_CharCodeFromUnicode(
+        uint32_t ret = FT_CharCodeFromUnicode(
             FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[i]),
             (FX_WCHAR)charcode);
         if (ret == 0) {
           continue;
         }
         FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[i]);
         unicode = (FX_WCHAR)ret;
         break;
       }
       if (i == FXFT_Get_Face_CharmapCount(face) && i) {
@@ skipping 29 matching lines @@
           FXFT_ENCODING_UNICODE) {
         CFX_WideString unicode_str = UnicodeFromCharCode(charcode);
         if (unicode_str.IsEmpty()) {
           return -1;
         }
         charcode = unicode_str.GetAt(0);
       }
       return GetGlyphIndex(charcode, pVertGlyph);
     }
   }
-  FX_DWORD byte_pos = cid * 2;
+  uint32_t byte_pos = cid * 2;
   if (byte_pos + 2 > m_pCIDToGIDMap->GetSize())
     return -1;
 
   const uint8_t* pdata = m_pCIDToGIDMap->GetData() + byte_pos;
   return pdata[0] * 256 + pdata[1];
 }
-FX_DWORD CPDF_CIDFont::GetNextChar(const FX_CHAR* pString,
+uint32_t CPDF_CIDFont::GetNextChar(const FX_CHAR* pString,
                                    int nStrLen,
                                    int& offset) const {
   return m_pCMap->GetNextChar(pString, nStrLen, offset);
 }
-int CPDF_CIDFont::GetCharSize(FX_DWORD charcode) const {
+int CPDF_CIDFont::GetCharSize(uint32_t charcode) const {
   return m_pCMap->GetCharSize(charcode);
 }
 int CPDF_CIDFont::CountChar(const FX_CHAR* pString, int size) const {
   return m_pCMap->CountChar(pString, size);
 }
-int CPDF_CIDFont::AppendChar(FX_CHAR* str, FX_DWORD charcode) const {
+int CPDF_CIDFont::AppendChar(FX_CHAR* str, uint32_t charcode) const {
   return m_pCMap->AppendChar(str, charcode);
 }
 FX_BOOL CPDF_CIDFont::IsUnicodeCompatible() const {
   if (!m_pCMap->IsLoaded() || !m_pCID2UnicodeMap ||
       !m_pCID2UnicodeMap->IsLoaded()) {
     return m_pCMap->m_Coding != CIDCODING_UNKNOWN;
   }
   return TRUE;
 }
-FX_BOOL CPDF_CIDFont::IsFontStyleFromCharCode(FX_DWORD charcode) const {
+FX_BOOL CPDF_CIDFont::IsFontStyleFromCharCode(uint32_t charcode) const {
   return TRUE;
 }
 void CPDF_CIDFont::LoadSubstFont() {
   m_Font.LoadSubst(m_BaseFont, !m_bType1, m_Flags, m_StemV * 5, m_ItalicAngle,
                    g_CharsetCPs[m_Charset], IsVertWriting());
 }
 void CPDF_CIDFont::LoadMetricsArray(CPDF_Array* pArray,
-                                    CFX_ArrayTemplate<FX_DWORD>& result,
+                                    CFX_ArrayTemplate<uint32_t>& result,
                                     int nElements) {
   int width_status = 0;
   int iCurElement = 0;
   int first_code = 0;
   int last_code = 0;
-  FX_DWORD count = pArray->GetCount();
-  for (FX_DWORD i = 0; i < count; i++) {
+  uint32_t count = pArray->GetCount();
+  for (uint32_t i = 0; i < count; i++) {
     CPDF_Object* pObj = pArray->GetElementValue(i);
     if (!pObj)
       continue;
 
     if (CPDF_Array* pArray = pObj->AsArray()) {
       if (width_status != 1)
         return;
 
-      FX_DWORD count = pArray->GetCount();
-      for (FX_DWORD j = 0; j < count; j += nElements) {
+      uint32_t count = pArray->GetCount();
+      for (uint32_t j = 0; j < count; j += nElements) {
         result.Add(first_code);
         result.Add(first_code);
         for (int k = 0; k < nElements; k++) {
           result.Add(pArray->GetIntegerAt(j + k));
         }
         first_code++;
       }
       width_status = 0;
     } else {
       if (width_status == 0) {
@@ skipping 56 matching lines @@
 
 const uint8_t* CPDF_CIDFont::GetCIDTransform(uint16_t CID) const {
   if (m_Charset != CIDSET_JAPAN1 || m_pFontFile)
     return nullptr;
 
   const struct CIDTransform* found = (const struct CIDTransform*)FXSYS_bsearch(
       &CID, g_Japan1_VertCIDs, FX_ArraySize(g_Japan1_VertCIDs),
       sizeof(g_Japan1_VertCIDs[0]), CompareCIDTransform);
   return found ? &found->a : nullptr;
 }