Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_render/fpdf_render_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/fpdfapi/fpdf_render/render_int.h"
 
 #include "core/fpdfapi/fpdf_font/cpdf_cidfont.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type3char.h"
@@ skipping 11 matching lines @@
 #include "core/fpdfapi/fpdf_render/include/cpdf_renderoptions.h"
 #include "core/fpdfapi/fpdf_render/include/cpdf_textrenderer.h"
 #include "core/include/fxge/fx_ge.h"
 
 CPDF_Type3Cache::~CPDF_Type3Cache() {
   for (const auto& pair : m_SizeMap) {
     delete pair.second;
   }
   m_SizeMap.clear();
 }
-CFX_GlyphBitmap* CPDF_Type3Cache::LoadGlyph(FX_DWORD charcode,
+CFX_GlyphBitmap* CPDF_Type3Cache::LoadGlyph(uint32_t charcode,
                                             const CFX_Matrix* pMatrix,
                                             FX_FLOAT retinaScaleX,
                                             FX_FLOAT retinaScaleY) {
   _CPDF_UniqueKeyGen keygen;
   keygen.Generate(
       4, FXSYS_round(pMatrix->a * 10000), FXSYS_round(pMatrix->b * 10000),
       FXSYS_round(pMatrix->c * 10000), FXSYS_round(pMatrix->d * 10000));
   CFX_ByteStringC FaceGlyphsKey(keygen.m_Key, keygen.m_KeyLen);
   CPDF_Type3Glyphs* pSizeCache;
   auto it = m_SizeMap.find(FaceGlyphsKey);
@@ skipping 80 matching lines @@
     } else {
       if (_IsScanLine8bpp(pBuf + line * pitch, width)) {
         return line;
       }
     }
     line += line_step;
   }
   return -1;
 }
 CFX_GlyphBitmap* CPDF_Type3Cache::RenderGlyph(CPDF_Type3Glyphs* pSize,
-                                              FX_DWORD charcode,
+                                              uint32_t charcode,
                                               const CFX_Matrix* pMatrix,
                                               FX_FLOAT retinaScaleX,
                                               FX_FLOAT retinaScaleY) {
   const CPDF_Type3Char* pChar = m_pFont->LoadChar(charcode);
   if (!pChar || !pChar->m_pBitmap)
     return nullptr;
 
   CFX_DIBitmap* pBitmap = pChar->m_pBitmap;
   CFX_Matrix image_matrix, text_matrix;
   image_matrix = pChar->m_ImageMatrix;
@@ skipping 41 matching lines @@
   pGlyph->m_Top = -top;
   pGlyph->m_Bitmap.TakeOver(pResBitmap);
   delete pResBitmap;
   return pGlyph;
 }
 void _CPDF_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);
 }
 FX_BOOL CPDF_RenderStatus::ProcessText(const CPDF_TextObject* textobj,
                                        const CFX_Matrix* pObj2Device,
                                        CFX_PathData* pClippingPath) {
   if (textobj->m_nChars == 0) {
     return TRUE;
   }
   int text_render_mode = textobj->m_TextState.GetObject()->m_TextMode;
   if (text_render_mode == 3) {
     return TRUE;
@@ skipping 118 matching lines @@
  public:
   CPDF_RefType3Cache(CPDF_Type3Font* pType3Font) {
     m_dwCount = 0;
     m_pType3Font = pType3Font;
   }
   ~CPDF_RefType3Cache() {
     while (m_dwCount--) {
       ReleaseCachedType3(m_pType3Font);
     }
   }
-  FX_DWORD m_dwCount;
+  uint32_t m_dwCount;
   CPDF_Type3Font* m_pType3Font;
 };
 FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj,
                                             const CFX_Matrix* pObj2Device) {
   CPDF_Type3Font* pType3Font = textobj->m_TextState.GetFont()->AsType3Font();
   for (int j = 0; j < m_Type3FontCache.GetSize(); j++) {
     if (m_Type3FontCache.GetAt(j) == pType3Font)
       return TRUE;
   }
   CFX_Matrix dCTM = m_pDevice->GetCTM();
   FX_FLOAT sa = FXSYS_fabs(dCTM.a);
   FX_FLOAT sd = FXSYS_fabs(dCTM.d);
   CFX_Matrix text_matrix;
   textobj->GetTextMatrix(&text_matrix);
   CFX_Matrix char_matrix = pType3Font->GetFontMatrix();
   FX_FLOAT font_size = textobj->m_TextState.GetFontSize();
   char_matrix.Scale(font_size, font_size);
   FX_ARGB fill_argb = GetFillArgb(textobj, TRUE);
   int fill_alpha = FXARGB_A(fill_argb);
   int device_class = m_pDevice->GetDeviceClass();
   FXTEXT_GLYPHPOS* pGlyphAndPos = NULL;
   if (device_class == FXDC_DISPLAY) {
     pGlyphAndPos = FX_Alloc(FXTEXT_GLYPHPOS, textobj->m_nChars);
   } else if (fill_alpha < 255) {
     return FALSE;
   }
   CPDF_RefType3Cache refTypeCache(pType3Font);
-  FX_DWORD* pChars = textobj->m_pCharCodes;
+  uint32_t* pChars = textobj->m_pCharCodes;
   if (textobj->m_nChars == 1) {
-    pChars = (FX_DWORD*)(&textobj->m_pCharCodes);
+    pChars = (uint32_t*)(&textobj->m_pCharCodes);
   }
   for (int iChar = 0; iChar < textobj->m_nChars; iChar++) {
-    FX_DWORD charcode = pChars[iChar];
-    if (charcode == (FX_DWORD)-1) {
+    uint32_t charcode = pChars[iChar];
+    if (charcode == (uint32_t)-1) {
       continue;
     }
     CPDF_Type3Char* pType3Char = pType3Font->LoadChar(charcode);
     if (!pType3Char) {
       continue;
     }
     CFX_Matrix matrix = char_matrix;
     matrix.e += iChar ? textobj->m_pCharPos[iChar - 1] : 0;
     matrix.Concat(text_matrix);
     matrix.Concat(*pObj2Device);
@@ skipping 112 matching lines @@
     m_pDevice->SetBitMask(&bitmap, rect.left, rect.top, fill_argb);
     FX_Free(pGlyphAndPos);
   }
   return TRUE;
 }
 class CPDF_CharPosList {
  public:
   CPDF_CharPosList();
   ~CPDF_CharPosList();
   void Load(int nChars,
-            FX_DWORD* pCharCodes,
+            uint32_t* pCharCodes,
             FX_FLOAT* pCharPos,
             CPDF_Font* pFont,
             FX_FLOAT font_size);
   FXTEXT_CHARPOS* m_pCharPos;
-  FX_DWORD m_nChars;
+  uint32_t m_nChars;
 };
 
 CPDF_CharPosList::CPDF_CharPosList() {
   m_pCharPos = NULL;
 }
 CPDF_CharPosList::~CPDF_CharPosList() {
   FX_Free(m_pCharPos);
 }
 void CPDF_CharPosList::Load(int nChars,
-                            FX_DWORD* pCharCodes,
+                            uint32_t* pCharCodes,
                             FX_FLOAT* pCharPos,
                             CPDF_Font* pFont,
                             FX_FLOAT FontSize) {
   m_pCharPos = FX_Alloc(FXTEXT_CHARPOS, nChars);
   m_nChars = 0;
   CPDF_CIDFont* pCIDFont = pFont->AsCIDFont();
   FX_BOOL bVertWriting = pCIDFont && pCIDFont->IsVertWriting();
   for (int iChar = 0; iChar < nChars; iChar++) {
-    FX_DWORD CharCode =
-        nChars == 1 ? (FX_DWORD)(uintptr_t)pCharCodes : pCharCodes[iChar];
-    if (CharCode == (FX_DWORD)-1) {
+    uint32_t CharCode =
+        nChars == 1 ? (uint32_t)(uintptr_t)pCharCodes : pCharCodes[iChar];
+    if (CharCode == (uint32_t)-1) {
       continue;
     }
     FX_BOOL bVert = FALSE;
     FXTEXT_CHARPOS& charpos = m_pCharPos[m_nChars++];
     if (pCIDFont) {
       charpos.m_bFontStyle = pCIDFont->IsFontStyleFromCharCode(CharCode);
     }
     charpos.m_GlyphIndex = pFont->GlyphFromCharCode(CharCode, &bVert);
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
     charpos.m_ExtGID = pFont->GlyphFromCharCodeExt(CharCode);
@@ skipping 27 matching lines @@
       charpos.m_OriginX +=
           pCIDFont->CIDTransformToFloat(pTransform[4]) * FontSize;
       charpos.m_OriginY +=
           pCIDFont->CIDTransformToFloat(pTransform[5]) * FontSize;
       charpos.m_bGlyphAdjust = TRUE;
     }
   }
 }
 FX_BOOL CPDF_TextRenderer::DrawTextPath(CFX_RenderDevice* pDevice,
                                         int nChars,
-                                        FX_DWORD* pCharCodes,
+                                        uint32_t* pCharCodes,
                                         FX_FLOAT* pCharPos,
                                         CPDF_Font* pFont,
                                         FX_FLOAT font_size,
                                         const CFX_Matrix* pText2User,
                                         const CFX_Matrix* pUser2Device,
                                         const CFX_GraphStateData* pGraphState,
                                         FX_ARGB fill_argb,
                                         FX_ARGB stroke_argb,
                                         CFX_PathData* pClippingPath,
                                         int nFlag) {
@@ skipping 33 matching lines @@
                                        const CFX_Matrix* pMatrix,
                                        const CFX_ByteString& str,
                                        FX_ARGB fill_argb,
                                        FX_ARGB stroke_argb,
                                        const CFX_GraphStateData* pGraphState,
                                        const CPDF_RenderOptions* pOptions) {
   int nChars = pFont->CountChar(str, str.GetLength());
   if (nChars == 0) {
     return;
   }
-  FX_DWORD charcode;
+  uint32_t charcode;
   int offset = 0;
-  FX_DWORD* pCharCodes;
+  uint32_t* pCharCodes;
   FX_FLOAT* pCharPos;
   if (nChars == 1) {
     charcode = pFont->GetNextChar(str, str.GetLength(), offset);
-    pCharCodes = (FX_DWORD*)(uintptr_t)charcode;
+    pCharCodes = (uint32_t*)(uintptr_t)charcode;
     pCharPos = NULL;
   } else {
-    pCharCodes = FX_Alloc(FX_DWORD, nChars);
+    pCharCodes = FX_Alloc(uint32_t, nChars);
     pCharPos = FX_Alloc(FX_FLOAT, nChars - 1);
     FX_FLOAT cur_pos = 0;
     for (int i = 0; i < nChars; i++) {
       pCharCodes[i] = pFont->GetNextChar(str, str.GetLength(), offset);
       if (i) {
         pCharPos[i - 1] = cur_pos;
       }
       cur_pos += pFont->GetCharWidthF(pCharCodes[i]) * font_size / 1000;
     }
   }
@@ skipping 14 matching lines @@
     }
   }
 
   if (nChars > 1) {
     FX_Free(pCharCodes);
     FX_Free(pCharPos);
   }
 }
 FX_BOOL CPDF_TextRenderer::DrawNormalText(CFX_RenderDevice* pDevice,
                                           int nChars,
-                                          FX_DWORD* pCharCodes,
+                                          uint32_t* pCharCodes,
                                           FX_FLOAT* pCharPos,
                                           CPDF_Font* pFont,
                                           FX_FLOAT font_size,
                                           const CFX_Matrix* pText2Device,
                                           FX_ARGB fill_argb,
                                           const CPDF_RenderOptions* pOptions) {
   CFX_FontCache* pCache =
       pFont->m_pDocument ? pFont->m_pDocument->GetRenderData()->GetFontCache()
                          : NULL;
   CPDF_CharPosList CharPosList;
   CharPosList.Load(nChars, pCharCodes, pCharPos, pFont, font_size);
   int FXGE_flags = 0;
   if (pOptions) {
-    FX_DWORD dwFlags = pOptions->m_Flags;
+    uint32_t dwFlags = pOptions->m_Flags;
     if (dwFlags & RENDER_CLEARTYPE) {
       FXGE_flags |= FXTEXT_CLEARTYPE;
       if (dwFlags & RENDER_BGR_STRIPE) {
         FXGE_flags |= FXTEXT_BGR_STRIPE;
       }
     }
     if (dwFlags & RENDER_NOTEXTSMOOTH) {
       FXGE_flags |= FXTEXT_NOSMOOTH;
     }
     if (dwFlags & RENDER_PRINTGRAPHICTEXT) {
@@ skipping 42 matching lines @@
   if (pFont->m_pDocument) {
     pCache = pFont->m_pDocument->GetRenderData()->GetFontCache();
   } else {
     pCache = CFX_GEModule::Get()->GetFontCache();
   }
   CFX_FaceCache* pFaceCache = pCache->GetCachedFace(&pFont->m_Font);
   FX_FONTCACHE_DEFINE(pCache, &pFont->m_Font);
   CPDF_CharPosList CharPosList;
   CharPosList.Load(textobj->m_nChars, textobj->m_pCharCodes,
                    textobj->m_pCharPos, pFont, font_size);
-  for (FX_DWORD i = 0; i < CharPosList.m_nChars; i++) {
+  for (uint32_t i = 0; i < CharPosList.m_nChars; i++) {
     FXTEXT_CHARPOS& charpos = CharPosList.m_pCharPos[i];
     const CFX_PathData* pPath = pFaceCache->LoadGlyphPath(
         &pFont->m_Font, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
     if (!pPath) {
       continue;
     }
     CPDF_PathObject path;
     path.m_GraphState = textobj->m_GraphState;
     path.m_ColorState = textobj->m_ColorState;
     CFX_Matrix matrix;
     if (charpos.m_bGlyphAdjust)
       matrix.Set(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
                  charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
     matrix.Concat(font_size, 0, 0, font_size, charpos.m_OriginX,
                   charpos.m_OriginY);
     path.m_Path.New()->Append(pPath, &matrix);
     path.m_Matrix = *pTextMatrix;
     path.m_bStroke = bStroke;
     path.m_FillType = bFill ? FXFILL_WINDING : 0;
     path.CalcBoundingBox();
     ProcessPath(&path, pObj2Device);
   }
 }