Remove FX_DWORD from core/ and delete definition

core/fxge/ge/fx_ge_text.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/fxge/ge/fx_text_int.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_freetype.h"
 #include "core/include/fxge/fx_ge.h"
@@ skipping 120 matching lines @@
     186, 187, 188, 189, 190, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
     200, 201, 202, 203, 204, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
     214, 215, 216, 217, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
     228, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 239, 240,
     241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 250, 251, 252, 253, 254,
     255,
 };
 #define ADJUST_ALPHA(background, foreground, src_alpha, text_flags, a) \
   src_alpha = g_TextGammaAdjust[(uint8_t)src_alpha];
 void _Color2Argb(FX_ARGB& argb,
-                 FX_DWORD color,
+                 uint32_t color,
                  int alpha_flag,
                  void* pIccTransform) {
   if (!pIccTransform && !FXGETFLAG_COLORTYPE(alpha_flag)) {
     argb = color;
     return;
   }
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
     pIccTransform = NULL;
   }
@@ skipping 18 matching lines @@
   bgra[3] = (alpha_flag >> 24) ? FXGETFLAG_ALPHA_FILL(alpha_flag)
                                : FXGETFLAG_ALPHA_STROKE(alpha_flag);
   argb = FXARGB_MAKE(bgra[3], bgra[2], bgra[1], bgra[0]);
 }
 FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars,
                                          const FXTEXT_CHARPOS* pCharPos,
                                          CFX_Font* pFont,
                                          CFX_FontCache* pCache,
                                          FX_FLOAT font_size,
                                          const CFX_Matrix* pText2Device,
-                                         FX_DWORD fill_color,
-                                         FX_DWORD text_flags,
+                                         uint32_t fill_color,
+                                         uint32_t text_flags,
                                          int alpha_flag,
                                          void* pIccTransform) {
   int nativetext_flags = text_flags;
   if (m_DeviceClass != FXDC_DISPLAY) {
     if (!(text_flags & FXTEXT_PRINTGRAPHICTEXT)) {
       bool should_call_draw_device_text = true;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       if ((text_flags & FXFONT_CIDFONT) ||
           (pFont->GetPsName().Find(CFX_WideString::FromLocal("+ZJHL")) != -1) ||
           (pFont->GetPsName() == CFX_WideString::FromLocal("CNAAJI+cmex10"))) {
@@ skipping 915 matching lines @@
   return TRUE;
 }
 FX_BOOL CFX_RenderDevice::DrawTextPath(int nChars,
                                        const FXTEXT_CHARPOS* pCharPos,
                                        CFX_Font* pFont,
                                        CFX_FontCache* pCache,
                                        FX_FLOAT font_size,
                                        const CFX_Matrix* pText2User,
                                        const CFX_Matrix* pUser2Device,
                                        const CFX_GraphStateData* pGraphState,
-                                       FX_DWORD fill_color,
+                                       uint32_t fill_color,
                                        FX_ARGB stroke_color,
                                        CFX_PathData* pClippingPath,
                                        int nFlag,
                                        int alpha_flag,
                                        void* pIccTransform,
                                        int blend_type) {
   if (!pCache) {
     pCache = CFX_GEModule::Get()->GetFontCache();
   }
   CFX_FaceCache* pFaceCache = pCache->GetCachedFace(pFont);
@@ skipping 121 matching lines @@
   }
   m_PathMap.clear();
 }
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
 void CFX_FaceCache::InitPlatform() {}
 #endif
 CFX_GlyphBitmap* CFX_FaceCache::LookUpGlyphBitmap(
     CFX_Font* pFont,
     const CFX_Matrix* pMatrix,
     CFX_ByteStringC& FaceGlyphsKey,
-    FX_DWORD glyph_index,
+    uint32_t glyph_index,
     FX_BOOL bFontStyle,
     int dest_width,
     int anti_alias) {
   CFX_SizeGlyphCache* pSizeCache;
   auto it = m_SizeMap.find(FaceGlyphsKey);
   if (it == m_SizeMap.end()) {
     pSizeCache = new CFX_SizeGlyphCache;
     m_SizeMap[FaceGlyphsKey] = pSizeCache;
   } else {
     pSizeCache = it->second;
   }
   auto it2 = pSizeCache->m_GlyphMap.find(glyph_index);
   if (it2 != pSizeCache->m_GlyphMap.end())
     return it2->second;
 
   CFX_GlyphBitmap* pGlyphBitmap = RenderGlyph(pFont, glyph_index, bFontStyle,
                                               pMatrix, dest_width, anti_alias);
   if (!pGlyphBitmap)
     return nullptr;
 
   pSizeCache->m_GlyphMap[glyph_index] = pGlyphBitmap;
   return pGlyphBitmap;
 }
 const CFX_GlyphBitmap* CFX_FaceCache::LoadGlyphBitmap(CFX_Font* pFont,
-                                                      FX_DWORD glyph_index,
+                                                      uint32_t glyph_index,
                                                       FX_BOOL bFontStyle,
                                                       const CFX_Matrix* pMatrix,
                                                       int dest_width,
                                                       int anti_alias,
                                                       int& text_flags) {
-  if (glyph_index == (FX_DWORD)-1) {
+  if (glyph_index == (uint32_t)-1) {
     return NULL;
   }
   _CFX_UniqueKeyGen keygen;
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
   if (pFont->GetSubstFont())
     keygen.Generate(9, (int)(pMatrix->a * 10000), (int)(pMatrix->b * 10000),
                     (int)(pMatrix->c * 10000), (int)(pMatrix->d * 10000),
                     dest_width, anti_alias, pFont->GetSubstFont()->m_Weight,
                     pFont->GetSubstFont()->m_ItalicAngle, pFont->IsVertical());
   else
@@ skipping 204 matching lines @@
       if (temp > 255) {
         temp = 255;
       } else if (temp < 0) {
         temp = 0;
       }
       *pDstRow++ = (uint8_t)temp;
     }
   }
 }
 CFX_GlyphBitmap* CFX_FaceCache::RenderGlyph(CFX_Font* pFont,
-                                            FX_DWORD glyph_index,
+                                            uint32_t glyph_index,
                                             FX_BOOL bFontStyle,
                                             const CFX_Matrix* pMatrix,
                                             int dest_width,
                                             int anti_alias) {
   if (!m_Face) {
     return NULL;
   }
   FXFT_Matrix ft_matrix;
   ft_matrix.xx = (signed long)(pMatrix->GetA() / 64 * 65536);
   ft_matrix.xy = (signed long)(pMatrix->GetC() / 64 * 65536);
@@ skipping 114 matching lines @@
     } else {
       _ContrastAdjust(pSrcBuf, pDestBuf, bmwidth, bmheight, src_pitch,
                       dest_pitch);
       _GammaAdjust(pDestBuf, bmwidth, bmheight, dest_pitch,
                    CFX_GEModule::Get()->GetTextGammaTable());
     }
   }
   return pGlyphBitmap;
 }
 const CFX_PathData* CFX_FaceCache::LoadGlyphPath(CFX_Font* pFont,
-                                                 FX_DWORD glyph_index,
+                                                 uint32_t glyph_index,
                                                  int dest_width) {
-  if (!m_Face || glyph_index == (FX_DWORD)-1)
+  if (!m_Face || glyph_index == (uint32_t)-1)
     return nullptr;
 
-  FX_DWORD key = glyph_index;
+  uint32_t key = glyph_index;
   if (pFont->GetSubstFont()) {
     key += (((pFont->GetSubstFont()->m_Weight / 16) << 15) +
             ((pFont->GetSubstFont()->m_ItalicAngle / 2) << 21) +
             ((dest_width / 16) << 25) + (pFont->IsVertical() << 31));
   }
   auto it = m_PathMap.find(key);
   if (it != m_PathMap.end())
     return it->second;
 
   CFX_PathData* pGlyphPath = pFont->LoadGlyphPath(glyph_index, dest_width);
@@ skipping 119 matching lines @@
     param->m_pPoints[param->m_PointCount + 2].m_PointY =
         to->y / param->m_CoordUnit;
     param->m_pPoints[param->m_PointCount + 2].m_Flag = FXPT_BEZIERTO;
     param->m_CurX = to->x;
     param->m_CurY = to->y;
   }
   param->m_PointCount += 3;
   return 0;
 }
 };
-CFX_PathData* CFX_Font::LoadGlyphPath(FX_DWORD glyph_index, int dest_width) {
+CFX_PathData* CFX_Font::LoadGlyphPath(uint32_t glyph_index, int dest_width) {
   if (!m_Face) {
     return NULL;
   }
   FXFT_Set_Pixel_Sizes(m_Face, 0, 64);
   FXFT_Matrix ft_matrix = {65536, 0, 0, 65536};
   if (m_pSubstFont) {
     if (m_pSubstFont->m_ItalicAngle) {
       int skew = m_pSubstFont->m_ItalicAngle;
       skew = skew <= -ANGLESKEW_ARRAY_SIZE ? -58 : -g_AngleSkew[-skew];
       if (m_bVertical) {
@@ skipping 55 matching lines @@
   if (params.m_PointCount) {
     pPath->GetPoints()[params.m_PointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
   }
   return pPath;
 }
 void _CFX_UniqueKeyGen::Generate(int count, ...) {
   va_list argList;
   va_start(argList, count);
   for (int i = 0; i < count; i++) {
     int p = va_arg(argList, int);
-    ((FX_DWORD*)m_Key)[i] = p;
+    ((uint32_t*)m_Key)[i] = p;
   }
   va_end(argList);
-  m_KeyLen = count * sizeof(FX_DWORD);
+  m_KeyLen = count * sizeof(uint32_t);
 }