Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_font/cpdf_font.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/include/cpdf_font.h"
 
 #include "core/fpdfapi/fpdf_font/cpdf_truetypefont.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type1font.h"
@@ skipping 103 matching lines @@
 }
 
 FX_BOOL CPDF_Font::IsUnicodeCompatible() const {
   return FALSE;
 }
 
 int CPDF_Font::CountChar(const FX_CHAR* pString, int size) const {
   return size;
 }
 
-int CPDF_Font::GetCharSize(FX_DWORD charcode) const {
+int CPDF_Font::GetCharSize(uint32_t charcode) const {
   return 1;
 }
 
-int CPDF_Font::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph) {
+int CPDF_Font::GlyphFromCharCode(uint32_t charcode, FX_BOOL* pVertGlyph) {
   ASSERT(false);
   return 0;
 }
 
-int CPDF_Font::GlyphFromCharCodeExt(FX_DWORD charcode) {
+int CPDF_Font::GlyphFromCharCodeExt(uint32_t charcode) {
   return GlyphFromCharCode(charcode);
 }
 
 FX_BOOL CPDF_Font::IsVertWriting() const {
   FX_BOOL bVertWriting = FALSE;
   const CPDF_CIDFont* pCIDFont = AsCIDFont();
   if (pCIDFont) {
     bVertWriting = pCIDFont->IsVertWriting();
   } else {
     bVertWriting = m_Font.IsVertical();
   }
   return bVertWriting;
 }
 
-int CPDF_Font::AppendChar(FX_CHAR* buf, FX_DWORD charcode) const {
+int CPDF_Font::AppendChar(FX_CHAR* buf, uint32_t charcode) const {
   *buf = (FX_CHAR)charcode;
   return 1;
 }
 
-void CPDF_Font::AppendChar(CFX_ByteString& str, FX_DWORD charcode) const {
+void CPDF_Font::AppendChar(CFX_ByteString& str, uint32_t charcode) const {
   char buf[4];
   int len = AppendChar(buf, charcode);
   if (len == 1) {
     str += buf[0];
   } else {
     str += CFX_ByteString(buf, len);
   }
 }
 
-CFX_WideString CPDF_Font::UnicodeFromCharCode(FX_DWORD charcode) const {
+CFX_WideString CPDF_Font::UnicodeFromCharCode(uint32_t charcode) const {
   if (!m_bToUnicodeLoaded)
     ((CPDF_Font*)this)->LoadUnicodeMap();
 
   if (m_pToUnicodeMap)
     return m_pToUnicodeMap->Lookup(charcode);
   return CFX_WideString();
 }
 
-FX_DWORD CPDF_Font::CharCodeFromUnicode(FX_WCHAR unicode) const {
+uint32_t CPDF_Font::CharCodeFromUnicode(FX_WCHAR unicode) const {
   if (!m_bToUnicodeLoaded)
     ((CPDF_Font*)this)->LoadUnicodeMap();
 
   if (m_pToUnicodeMap)
     return m_pToUnicodeMap->ReverseLookup(unicode);
   return 0;
 }
 
 void CPDF_Font::LoadFontDescriptor(CPDF_Dictionary* pFontDesc) {
   m_Flags = pFontDesc->GetIntegerBy("Flags", PDFFONT_NONSYMBOLIC);
@@ skipping 47 matching lines @@
   if (!pFontFile)
     pFontFile = pFontDesc->GetStreamBy("FontFile3");
   if (!pFontFile)
     return;
 
   m_pFontFile = m_pDocument->LoadFontFile(pFontFile);
   if (!m_pFontFile)
     return;
 
   const uint8_t* pFontData = m_pFontFile->GetData();
-  FX_DWORD dwFontSize = m_pFontFile->GetSize();
+  uint32_t dwFontSize = m_pFontFile->GetSize();
   if (!m_Font.LoadEmbedded(pFontData, dwFontSize)) {
     m_pDocument->GetPageData()->ReleaseFontFileStreamAcc(
         const_cast<CPDF_Stream*>(m_pFontFile->GetStream()->AsStream()));
     m_pFontFile = nullptr;
   }
 }
 
 void CPDF_Font::CheckFontMetrics() {
   if (m_FontBBox.top == 0 && m_FontBBox.bottom == 0 && m_FontBBox.left == 0 &&
       m_FontBBox.right == 0) {
@@ skipping 47 matching lines @@
     return;
   }
   m_pToUnicodeMap = new CPDF_ToUnicodeMap;
   m_pToUnicodeMap->Load(pStream);
 }
 
 int CPDF_Font::GetStringWidth(const FX_CHAR* pString, int size) {
   int offset = 0;
   int width = 0;
   while (offset < size) {
-    FX_DWORD charcode = GetNextChar(pString, size, offset);
+    uint32_t charcode = GetNextChar(pString, size, offset);
     width += GetCharWidthF(charcode);
   }
   return width;
 }
 
 CPDF_Font* CPDF_Font::GetStockFont(CPDF_Document* pDoc,
                                    const CFX_ByteStringC& name) {
   CFX_ByteString fontname(name);
   int font_id = PDF_GetStandardFontName(&fontname);
   if (font_id < 0) {
@@ skipping 61 matching lines @@
   pFont->m_pFontDict = pFontDict;
   pFont->m_pDocument = pDoc;
   pFont->m_BaseFont = pFontDict->GetStringBy("BaseFont");
   if (!pFont->Load()) {
     delete pFont;
     return NULL;
   }
   return pFont;
 }
 
-FX_DWORD CPDF_Font::GetNextChar(const FX_CHAR* pString,
+uint32_t CPDF_Font::GetNextChar(const FX_CHAR* pString,
                                 int nStrLen,
                                 int& offset) const {
   if (offset < 0 || nStrLen < 1) {
     return 0;
   }
   uint8_t ch = offset < nStrLen ? pString[offset++] : pString[nStrLen - 1];
-  return static_cast<FX_DWORD>(ch);
+  return static_cast<uint32_t>(ch);
 }
 
 void CPDF_Font::LoadPDFEncoding(CPDF_Object* pEncoding,
                                 int& iBaseEncoding,
                                 CFX_ByteString*& pCharNames,
                                 FX_BOOL bEmbedded,
                                 FX_BOOL bTrueType) {
   if (!pEncoding) {
     if (m_BaseFont == "Symbol") {
       iBaseEncoding = bTrueType ? PDFFONT_ENCODING_MS_SYMBOL
@@ skipping 35 matching lines @@
     GetPredefinedEncoding(iBaseEncoding, bsEncoding);
   }
   if ((!bEmbedded || bTrueType) && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
     iBaseEncoding = PDFFONT_ENCODING_STANDARD;
   }
   CPDF_Array* pDiffs = pDict->GetArrayBy("Differences");
   if (!pDiffs) {
     return;
   }
   pCharNames = new CFX_ByteString[256];
-  FX_DWORD cur_code = 0;
-  for (FX_DWORD i = 0; i < pDiffs->GetCount(); i++) {
+  uint32_t cur_code = 0;
+  for (uint32_t i = 0; i < pDiffs->GetCount(); i++) {
     CPDF_Object* pElement = pDiffs->GetElementValue(i);
     if (!pElement)
       continue;
 
     if (CPDF_Name* pName = pElement->AsName()) {
       if (cur_code < 256)
         pCharNames[cur_code] = pName->GetString();
       cur_code++;
     } else {
       cur_code = pElement->GetInteger();
@@ skipping 18 matching lines @@
   if (charcode < 0 || charcode >= 256)
     return nullptr;
 
   const FX_CHAR* name = nullptr;
   if (pCharNames)
     name = pCharNames[charcode];
   if ((!name || name[0] == 0) && iBaseEncoding)
     name = PDF_CharNameFromPredefinedCharSet(iBaseEncoding, charcode);
   return name && name[0] ? name : nullptr;
 }