Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_font/ttgsubtable.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/fpdfapi/fpdf_font/ttgsubtable.h"
 
 #include <memory>
 
 #include "core/include/fxge/fx_freetype.h"
 #include "core/include/fxge/fx_ge.h"
 #include "third_party/base/stl_util.h"
 
 CFX_GlyphMap::CFX_GlyphMap() {}
 CFX_GlyphMap::~CFX_GlyphMap() {}
 extern "C" {
 static int _CompareInt(const void* p1, const void* p2) {
-  return (*(FX_DWORD*)p1) - (*(FX_DWORD*)p2);
+  return (*(uint32_t*)p1) - (*(uint32_t*)p2);
 }
 };
 struct _IntPair {
   int32_t key;
   int32_t value;
 };
 void CFX_GlyphMap::SetAt(int key, int value) {
-  FX_DWORD count = m_Buffer.GetSize() / sizeof(_IntPair);
+  uint32_t count = m_Buffer.GetSize() / sizeof(_IntPair);
   _IntPair* buf = (_IntPair*)m_Buffer.GetBuffer();
   _IntPair pair = {key, value};
   if (count == 0 || key > buf[count - 1].key) {
     m_Buffer.AppendBlock(&pair, sizeof(_IntPair));
     return;
   }
   int low = 0, high = count - 1;
   while (low <= high) {
     int mid = (low + high) / 2;
     if (buf[mid].key < key) {
       low = mid + 1;
     } else if (buf[mid].key > key) {
       high = mid - 1;
     } else {
       buf[mid].value = value;
       return;
     }
   }
   m_Buffer.InsertBlock(low * sizeof(_IntPair), &pair, sizeof(_IntPair));
 }
 FX_BOOL CFX_GlyphMap::Lookup(int key, int& value) {
   void* pResult = FXSYS_bsearch(&key, m_Buffer.GetBuffer(),
                                 m_Buffer.GetSize() / sizeof(_IntPair),
                                 sizeof(_IntPair), _CompareInt);
   if (!pResult) {
     return FALSE;
   }
-  value = ((FX_DWORD*)pResult)[1];
+  value = ((uint32_t*)pResult)[1];
   return TRUE;
 }
 bool CFX_CTTGSUBTable::LoadGSUBTable(FT_Bytes gsub) {
   header.Version = gsub[0] << 24 | gsub[1] << 16 | gsub[2] << 8 | gsub[3];
   if (header.Version != 0x00010000) {
     return false;
   }
   header.ScriptList = gsub[4] << 8 | gsub[5];
   header.FeatureList = gsub[6] << 8 | gsub[7];
   header.LookupList = gsub[8] << 8 | gsub[9];
   return Parse(&gsub[header.ScriptList], &gsub[header.FeatureList],
                &gsub[header.LookupList]);
 }
 bool CFX_CTTGSUBTable::GetVerticalGlyph(uint32_t glyphnum,
                                         uint32_t* vglyphnum) {
   uint32_t tag[] = {
       (uint8_t)'v' << 24 | (uint8_t)'r' << 16 | (uint8_t)'t' << 8 |
           (uint8_t)'2',
       (uint8_t)'v' << 24 | (uint8_t)'e' << 16 | (uint8_t)'r' << 8 |
           (uint8_t)'t',
   };
   if (!m_bFeautureMapLoad) {
     for (int i = 0; i < ScriptList.ScriptCount; i++) {
       for (int j = 0; j < (ScriptList.ScriptRecord + i)->Script.LangSysCount;
            ++j) {
         for (int k = 0;
              k < ((ScriptList.ScriptRecord + i)->Script.LangSysRecord + j)
                      ->LangSys.FeatureCount;
              ++k) {
-          FX_DWORD index =
+          uint32_t index =
               *(((ScriptList.ScriptRecord + i)->Script.LangSysRecord + j)
                     ->LangSys.FeatureIndex +
                 k);
           if (FeatureList.FeatureRecord[index].FeatureTag == tag[0] ||
               FeatureList.FeatureRecord[index].FeatureTag == tag[1]) {
             if (!pdfium::ContainsKey(m_featureMap, index)) {
               m_featureMap[index] = index;
             }
           }
         }
@@ skipping 279 matching lines @@
   ParseCoverage(&raw[offset], &rec->Coverage);
   rec->GlyphCount = GetUInt16(sp);
   if (rec->GlyphCount <= 0) {
     return;
   }
   rec->Substitute = new uint16_t[rec->GlyphCount];
   for (i = 0; i < rec->GlyphCount; i++) {
     rec->Substitute[i] = GetUInt16(sp);
   }
 }
-FX_BOOL CFX_GSUBTable::GetVerticalGlyph(FX_DWORD glyphnum,
-                                        FX_DWORD* vglyphnum) {
+FX_BOOL CFX_GSUBTable::GetVerticalGlyph(uint32_t glyphnum,
+                                        uint32_t* vglyphnum) {
   return m_GsubImp.GetVerticalGlyph(glyphnum, vglyphnum);
 }
 // static
 IFX_GSUBTable* IFX_GSUBTable::Create(CFX_Font* pFont) {
   if (!pFont) {
     return NULL;
   }
   if (!pFont->GetSubData()) {
     unsigned long length = 0;
     int error = FXFT_Load_Sfnt_Table(
         pFont->GetFace(), FT_MAKE_TAG('G', 'S', 'U', 'B'), 0, NULL, &length);
     if (!error) {
       pFont->SetSubData(FX_Alloc(uint8_t, length));
     }
     if (!pFont->GetSubData()) {
       return NULL;
     }
   }
   int error =
       FXFT_Load_Sfnt_Table(pFont->GetFace(), FT_MAKE_TAG('G', 'S', 'U', 'B'), 0,
                            pFont->GetSubData(), NULL);
   if (!error && pFont->GetSubData()) {
     std::unique_ptr<CFX_GSUBTable> pGsubTable(new CFX_GSUBTable);
     if (pGsubTable->m_GsubImp.LoadGSUBTable((FT_Bytes)pFont->GetSubData())) {
       return pGsubTable.release();
     }
   }
   return NULL;
 }