Remove FX_DWORD from core/ and delete definition

core/fxge/win32/fx_win32_device.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/include/fxge/fx_ge.h"
 
 #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_DESKTOP_
 #include <crtdbg.h>
@@ skipping 25 matching lines @@
   // IFX_SystemFontInfo
   void Release() override;
   FX_BOOL EnumFontList(CFX_FontMapper* pMapper) override;
   void* MapFont(int weight,
                 FX_BOOL bItalic,
                 int charset,
                 int pitch_family,
                 const FX_CHAR* face,
                 int& iExact) override;
   void* GetFont(const FX_CHAR* face) override { return NULL; }
-  FX_DWORD GetFontData(void* hFont,
-                       FX_DWORD table,
+  uint32_t GetFontData(void* hFont,
+                       uint32_t table,
                        uint8_t* buffer,
-                       FX_DWORD size) override;
+                       uint32_t size) override;
   FX_BOOL GetFaceName(void* hFont, CFX_ByteString& name) override;
   FX_BOOL GetFontCharset(void* hFont, int& charset) override;
   void DeleteFont(void* hFont) override;
 
   FX_BOOL IsOpenTypeFromDiv(const LOGFONTA* plf);
   FX_BOOL IsSupportFontFormDiv(const LOGFONTA* plf);
-  void AddInstalledFont(const LOGFONTA* plf, FX_DWORD FontType);
+  void AddInstalledFont(const LOGFONTA* plf, uint32_t FontType);
   void GetGBPreference(CFX_ByteString& face, int weight, int picth_family);
   void GetJapanesePreference(CFX_ByteString& face,
                              int weight,
                              int picth_family);
   CFX_ByteString FindFont(const CFX_ByteString& name);
   HDC m_hDC;
   CFX_FontMapper* m_pMapper;
   CFX_ByteString m_LastFamily;
   CFX_ByteString m_KaiTi, m_FangSong;
 };
 
 CFX_Win32FontInfo::CFX_Win32FontInfo() {
   m_hDC = CreateCompatibleDC(NULL);
 }
 CFX_Win32FontInfo::~CFX_Win32FontInfo() {
   m_pMapper = NULL;
 }
 void CFX_Win32FontInfo::Release() {
   DeleteDC(m_hDC);
   delete this;
 }
 #define TT_MAKE_TAG(x1, x2, x3, x4)                                    \
-  (((FX_DWORD)x1 << 24) | ((FX_DWORD)x2 << 16) | ((FX_DWORD)x3 << 8) | \
-   (FX_DWORD)x4)
+  (((uint32_t)x1 << 24) | ((uint32_t)x2 << 16) | ((uint32_t)x3 << 8) | \
+   (uint32_t)x4)
 FX_BOOL CFX_Win32FontInfo::IsOpenTypeFromDiv(const LOGFONTA* plf) {
   HFONT hFont = CreateFontIndirectA(plf);
   FX_BOOL ret = FALSE;
-  FX_DWORD font_size = GetFontData(hFont, 0, NULL, 0);
-  if (font_size != GDI_ERROR && font_size >= sizeof(FX_DWORD)) {
-    FX_DWORD lVersion = 0;
-    GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(FX_DWORD));
-    lVersion = (((FX_DWORD)(uint8_t)(lVersion)) << 24) |
-               ((FX_DWORD)((uint8_t)(lVersion >> 8))) << 16 |
-               ((FX_DWORD)((uint8_t)(lVersion >> 16))) << 8 |
+  uint32_t font_size = GetFontData(hFont, 0, NULL, 0);
+  if (font_size != GDI_ERROR && font_size >= sizeof(uint32_t)) {
+    uint32_t lVersion = 0;
+    GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(uint32_t));
+    lVersion = (((uint32_t)(uint8_t)(lVersion)) << 24) |
+               ((uint32_t)((uint8_t)(lVersion >> 8))) << 16 |
+               ((uint32_t)((uint8_t)(lVersion >> 16))) << 8 |
                ((uint8_t)(lVersion >> 24));
     if (lVersion == TT_MAKE_TAG('O', 'T', 'T', 'O') || lVersion == 0x00010000 ||
         lVersion == TT_MAKE_TAG('t', 't', 'c', 'f') ||
         lVersion == TT_MAKE_TAG('t', 'r', 'u', 'e') || lVersion == 0x00020000) {
       ret = TRUE;
     }
   }
   DeleteFont(hFont);
   return ret;
 }
 FX_BOOL CFX_Win32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf) {
   HFONT hFont = CreateFontIndirectA(plf);
   FX_BOOL ret = FALSE;
-  FX_DWORD font_size = GetFontData(hFont, 0, NULL, 0);
-  if (font_size != GDI_ERROR && font_size >= sizeof(FX_DWORD)) {
-    FX_DWORD lVersion = 0;
-    GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(FX_DWORD));
-    lVersion = (((FX_DWORD)(uint8_t)(lVersion)) << 24) |
-               ((FX_DWORD)((uint8_t)(lVersion >> 8))) << 16 |
-               ((FX_DWORD)((uint8_t)(lVersion >> 16))) << 8 |
+  uint32_t font_size = GetFontData(hFont, 0, NULL, 0);
+  if (font_size != GDI_ERROR && font_size >= sizeof(uint32_t)) {
+    uint32_t lVersion = 0;
+    GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(uint32_t));
+    lVersion = (((uint32_t)(uint8_t)(lVersion)) << 24) |
+               ((uint32_t)((uint8_t)(lVersion >> 8))) << 16 |
+               ((uint32_t)((uint8_t)(lVersion >> 16))) << 8 |
                ((uint8_t)(lVersion >> 24));
     if (lVersion == TT_MAKE_TAG('O', 'T', 'T', 'O') || lVersion == 0x00010000 ||
         lVersion == TT_MAKE_TAG('t', 't', 'c', 'f') ||
         lVersion == TT_MAKE_TAG('t', 'r', 'u', 'e') || lVersion == 0x00020000) {
       ret = TRUE;
     } else if ((lVersion & 0xFFFF0000) == TT_MAKE_TAG(0x80, 0x01, 0x00, 0x00) ||
                (lVersion & 0xFFFF0000) == TT_MAKE_TAG('%', '!', 0, 0)) {
       ret = TRUE;
     }
   }
   DeleteFont(hFont);
   return ret;
 }
 void CFX_Win32FontInfo::AddInstalledFont(const LOGFONTA* plf,
-                                         FX_DWORD FontType) {
+                                         uint32_t FontType) {
   CFX_ByteString name(plf->lfFaceName);
   if (name[0] == '@') {
     return;
   }
   if (name == m_LastFamily) {
     m_pMapper->AddInstalledFont(name, plf->lfCharSet);
     return;
   }
   if (!(FontType & TRUETYPE_FONTTYPE) && !(FontType & DEVICE_FONTTYPE)) {
     return;
   }
   if (!(FontType & TRUETYPE_FONTTYPE)) {
     if (!IsSupportFontFormDiv(plf)) {
       return;
     }
   }
   m_pMapper->AddInstalledFont(name, plf->lfCharSet);
   m_LastFamily = name;
 }
 static int CALLBACK FontEnumProc(const LOGFONTA* plf,
                                  const TEXTMETRICA* lpntme,
-                                 FX_DWORD FontType,
+                                 uint32_t FontType,
                                  LPARAM lParam) {
   CFX_Win32FontInfo* pFontInfo = (CFX_Win32FontInfo*)lParam;
   if (pFontInfo->m_pMapper->GetFontEnumerator()) {
     pFontInfo->m_pMapper->GetFontEnumerator()->HitFont();
   }
   pFontInfo->AddInstalledFont(plf, FontType);
   return 1;
 }
 FX_BOOL CFX_Win32FontInfo::EnumFontList(CFX_FontMapper* pMapper) {
   m_pMapper = pMapper;
@@ skipping 241 matching lines @@
       }
       break;
   }
   hFont = ::CreateFontA(-10, 0, 0, 0, weight, bItalic, 0, 0, charset,
                         OUT_TT_ONLY_PRECIS, 0, 0, subst_pitch_family, face);
   return hFont;
 }
 void CFX_Win32FontInfo::DeleteFont(void* hFont) {
   ::DeleteObject(hFont);
 }
-FX_DWORD CFX_Win32FontInfo::GetFontData(void* hFont,
-                                        FX_DWORD table,
+uint32_t CFX_Win32FontInfo::GetFontData(void* hFont,
+                                        uint32_t table,
                                         uint8_t* buffer,
-                                        FX_DWORD size) {
+                                        uint32_t size) {
   HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
   table = FXDWORD_GET_MSBFIRST(reinterpret_cast<uint8_t*>(&table));
   size = ::GetFontData(m_hDC, table, 0, buffer, size);
   ::SelectObject(m_hDC, hOldFont);
   if (size == GDI_ERROR) {
     return 0;
   }
   return size;
 }
 FX_BOOL CFX_Win32FontInfo::GetFaceName(void* hFont, CFX_ByteString& name) {
@@ skipping 151 matching lines @@
       delete pBitmap;
     }
   }
   return TRUE;
 }
 FX_BOOL CGdiDeviceDriver::GDI_StretchDIBits(const CFX_DIBitmap* pBitmap1,
                                             int dest_left,
                                             int dest_top,
                                             int dest_width,
                                             int dest_height,
-                                            FX_DWORD flags,
+                                            uint32_t flags,
                                             void* pIccTransform) {
   CFX_DIBitmap* pBitmap = (CFX_DIBitmap*)pBitmap1;
   if (!pBitmap || dest_width == 0 || dest_height == 0) {
     return FALSE;
   }
   if ((pBitmap->IsCmykImage() || pIccTransform) &&
       !pBitmap->ConvertFormat(FXDIB_Rgb, pIccTransform)) {
     return FALSE;
   }
   CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
@@ skipping 22 matching lines @@
   if (del) {
     delete pToStrechBitmap;
   }
   return TRUE;
 }
 FX_BOOL CGdiDeviceDriver::GDI_StretchBitMask(const CFX_DIBitmap* pBitmap1,
                                              int dest_left,
                                              int dest_top,
                                              int dest_width,
                                              int dest_height,
-                                             FX_DWORD bitmap_color,
-                                             FX_DWORD flags,
+                                             uint32_t bitmap_color,
+                                             uint32_t flags,
                                              int alpha_flag,
                                              void* pIccTransform) {
   CFX_DIBitmap* pBitmap = (CFX_DIBitmap*)pBitmap1;
   if (!pBitmap || dest_width == 0 || dest_height == 0) {
     return FALSE;
   }
   _Color2Argb(bitmap_color, bitmap_color, alpha_flag | (1 << 24),
               pIccTransform);
   int width = pBitmap->GetWidth(), height = pBitmap->GetHeight();
   struct {
     BITMAPINFOHEADER bmiHeader;
-    FX_DWORD bmiColors[2];
+    uint32_t bmiColors[2];
   } bmi;
   FXSYS_memset(&bmi.bmiHeader, 0, sizeof(BITMAPINFOHEADER));
   bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
   bmi.bmiHeader.biBitCount = 1;
   bmi.bmiHeader.biCompression = BI_RGB;
   bmi.bmiHeader.biHeight = -height;
   bmi.bmiHeader.biPlanes = 1;
   bmi.bmiHeader.biWidth = width;
   if (m_nBitsPerPixel != 1) {
     SetStretchBltMode(m_hDC, HALFTONE);
@@ skipping 33 matching lines @@
 }
 FX_BOOL CGdiDeviceDriver::GetClipBox(FX_RECT* pRect) {
   return ::GetClipBox(m_hDC, (RECT*)pRect);
 }
 FX_BOOL CGdiDeviceDriver::SetClipRgn(void* hRgn) {
   ::SelectClipRgn(m_hDC, (HRGN)hRgn);
   return TRUE;
 }
 static HPEN _CreatePen(const CFX_GraphStateData* pGraphState,
                        const CFX_Matrix* pMatrix,
-                       FX_DWORD argb) {
+                       uint32_t argb) {
   FX_FLOAT width;
   FX_FLOAT scale = 1.f;
   if (pMatrix)
     scale = FXSYS_fabs(pMatrix->a) > FXSYS_fabs(pMatrix->b)
                 ? FXSYS_fabs(pMatrix->a)
                 : FXSYS_fabs(pMatrix->b);
   if (pGraphState) {
     width = scale * pGraphState->m_LineWidth;
   } else {
     width = 1.0f;
   }
-  FX_DWORD PenStyle = PS_GEOMETRIC;
+  uint32_t PenStyle = PS_GEOMETRIC;
   if (width < 1) {
     width = 1;
   }
   if (pGraphState->m_DashCount) {
     PenStyle |= PS_USERSTYLE;
   } else {
     PenStyle |= PS_SOLID;
   }
   switch (pGraphState->m_LineCap) {
     case 0:
@@ skipping 17 matching lines @@
       PenStyle |= PS_JOIN_BEVEL;
       break;
   }
   int a;
   FX_COLORREF rgb;
   ArgbDecode(argb, a, rgb);
   LOGBRUSH lb;
   lb.lbColor = rgb;
   lb.lbStyle = BS_SOLID;
   lb.lbHatch = 0;
-  FX_DWORD* pDash = NULL;
+  uint32_t* pDash = NULL;
   if (pGraphState->m_DashCount) {
-    pDash = FX_Alloc(FX_DWORD, pGraphState->m_DashCount);
+    pDash = FX_Alloc(uint32_t, pGraphState->m_DashCount);
     for (int i = 0; i < pGraphState->m_DashCount; i++) {
       pDash[i] = FXSYS_round(
           pMatrix ? pMatrix->TransformDistance(pGraphState->m_DashArray[i])
                   : pGraphState->m_DashArray[i]);
       if (pDash[i] < 1) {
         pDash[i] = 1;
       }
     }
   }
   HPEN hPen = ExtCreatePen(PenStyle, (DWORD)FXSYS_ceil(width), &lb,
                            pGraphState->m_DashCount, (const DWORD*)pDash);
   FX_Free(pDash);
   return hPen;
 }
-static HBRUSH _CreateBrush(FX_DWORD argb) {
+static HBRUSH _CreateBrush(uint32_t argb) {
   int a;
   FX_COLORREF rgb;
   ArgbDecode(argb, a, rgb);
   return CreateSolidBrush(rgb);
 }
 static void _SetPathToDC(HDC hDC,
                          const CFX_PathData* pPathData,
                          const CFX_Matrix* pMatrix) {
   BeginPath(hDC);
   int nPoints = pPathData->GetPointCount();
@@ skipping 72 matching lines @@
   MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), NULL);
   LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
 }
 static FX_BOOL _MatrixNoScaled(const CFX_Matrix* pMatrix) {
   return pMatrix->GetA() == 1.0f && pMatrix->GetB() == 0 &&
          pMatrix->GetC() == 0 && pMatrix->GetD() == 1.0f;
 }
 FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                    const CFX_Matrix* pMatrix,
                                    const CFX_GraphStateData* pGraphState,
-                                   FX_DWORD fill_color,
-                                   FX_DWORD stroke_color,
+                                   uint32_t fill_color,
+                                   uint32_t stroke_color,
                                    int fill_mode,
                                    int alpha_flag,
                                    void* pIccTransform,
                                    int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
   _Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
   _Color2Argb(stroke_color, stroke_color, alpha_flag, pIccTransform);
   CWin32Platform* pPlatform =
@@ skipping 88 matching lines @@
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     DeleteObject(hPen);
   }
   if (hBrush) {
     hBrush = (HBRUSH)SelectObject(m_hDC, hBrush);
     DeleteObject(hBrush);
   }
   return TRUE;
 }
 FX_BOOL CGdiDeviceDriver::FillRect(const FX_RECT* pRect,
-                                   FX_DWORD fill_color,
+                                   uint32_t fill_color,
                                    int alpha_flag,
                                    void* pIccTransform,
                                    int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
   _Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
   int alpha;
   FX_COLORREF rgb;
   ArgbDecode(fill_color, alpha, rgb);
@@ skipping 35 matching lines @@
   SetPolyFillMode(m_hDC, WINDING);
   FX_BOOL ret = SelectClipPath(m_hDC, RGN_AND);
   hPen = (HPEN)SelectObject(m_hDC, hPen);
   DeleteObject(hPen);
   return ret;
 }
 FX_BOOL CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
                                            FX_FLOAT y1,
                                            FX_FLOAT x2,
                                            FX_FLOAT y2,
-                                           FX_DWORD color,
+                                           uint32_t color,
                                            int alpha_flag,
                                            void* pIccTransform,
                                            int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
   _Color2Argb(color, color, alpha_flag | (1 << 24), pIccTransform);
   int a;
   FX_COLORREF rgb;
   ArgbDecode(color, a, rgb);
@@ skipping 60 matching lines @@
     }
   }
   if (pBitmap->HasAlpha() && ret) {
     pBitmap->LoadChannel(FXDIB_Alpha, 0xff);
   }
   DeleteObject(hbmp);
   DeleteObject(hDCMemory);
   return ret;
 }
 FX_BOOL CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource,
-                                     FX_DWORD color,
+                                     uint32_t color,
                                      const FX_RECT* pSrcRect,
                                      int left,
                                      int top,
                                      int blend_type,
                                      int alpha_flag,
                                      void* pIccTransform) {
   ASSERT(blend_type == FXDIB_BLEND_NORMAL);
   if (pSource->IsAlphaMask()) {
     int width = pSource->GetWidth(), height = pSource->GetHeight();
     int alpha = FXGETFLAG_COLORTYPE(alpha_flag)
@@ skipping 33 matching lines @@
                      NULL);
   }
   CFX_DIBExtractor temp(pSource);
   CFX_DIBitmap* pBitmap = temp;
   if (pBitmap) {
     return GDI_SetDIBits(pBitmap, pSrcRect, left, top, pIccTransform);
   }
   return FALSE;
 }
 FX_BOOL CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource,
-                                                 FX_DWORD color,
+                                                 uint32_t color,
                                                  int dest_left,
                                                  int dest_top,
                                                  int dest_width,
                                                  int dest_height,
                                                  const FX_RECT* pClipRect,
                                                  int render_flags,
                                                  int alpha_flag,
                                                  void* pIccTransform,
                                                  int blend_type) {
   FX_RECT bitmap_clip = *pClipRect;
@@ skipping 10 matching lines @@
     return TRUE;
   }
   FX_RECT src_rect(0, 0, pStretched->GetWidth(), pStretched->GetHeight());
   FX_BOOL ret =
       SetDIBits(pStretched, color, &src_rect, pClipRect->left, pClipRect->top,
                 FXDIB_BLEND_NORMAL, alpha_flag, pIccTransform);
   delete pStretched;
   return ret;
 }
 FX_BOOL CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource,
-                                         FX_DWORD color,
+                                         uint32_t color,
                                          int dest_left,
                                          int dest_top,
                                          int dest_width,
                                          int dest_height,
                                          const FX_RECT* pClipRect,
-                                         FX_DWORD flags,
+                                         uint32_t flags,
                                          int alpha_flag,
                                          void* pIccTransform,
                                          int blend_type) {
   ASSERT(pSource && pClipRect);
   if (flags || dest_width > 10000 || dest_width < -10000 ||
       dest_height > 10000 || dest_height < -10000) {
     return UseFoxitStretchEngine(pSource, color, dest_left, dest_top,
                                  dest_width, dest_height, pClipRect, flags,
                                  alpha_flag, pIccTransform, blend_type);
   }
@@ skipping 55 matching lines @@
   }
   return FALSE;
 }
 #define GET_PS_FEATURESETTING 4121
 #define FEATURESETTING_PSLEVEL 2
 int GetPSLevel(HDC hDC) {
   int device_type = ::GetDeviceCaps(hDC, TECHNOLOGY);
   if (device_type != DT_RASPRINTER) {
     return 0;
   }
-  FX_DWORD esc = GET_PS_FEATURESETTING;
+  uint32_t esc = GET_PS_FEATURESETTING;
   if (ExtEscape(hDC, QUERYESCSUPPORT, sizeof esc, (char*)&esc, 0, NULL)) {
     int param = FEATURESETTING_PSLEVEL;
     if (ExtEscape(hDC, GET_PS_FEATURESETTING, sizeof(int), (char*)&param,
                   sizeof(int), (char*)&param) > 0) {
       return param;
     }
   }
   esc = POSTSCRIPT_IDENTIFY;
   if (ExtEscape(hDC, QUERYESCSUPPORT, sizeof esc, (char*)&esc, 0, NULL) == 0) {
     esc = POSTSCRIPT_DATA;
     if (ExtEscape(hDC, QUERYESCSUPPORT, sizeof esc, (char*)&esc, 0, NULL)) {
       return 2;
     }
     return 0;
   }
   esc = PSIDENT_GDICENTRIC;
-  if (ExtEscape(hDC, POSTSCRIPT_IDENTIFY, sizeof(FX_DWORD), (char*)&esc, 0,
+  if (ExtEscape(hDC, POSTSCRIPT_IDENTIFY, sizeof(uint32_t), (char*)&esc, 0,
                 NULL) <= 0) {
     return 2;
   }
   esc = GET_PS_FEATURESETTING;
   if (ExtEscape(hDC, QUERYESCSUPPORT, sizeof esc, (char*)&esc, 0, NULL)) {
     int param = FEATURESETTING_PSLEVEL;
     if (ExtEscape(hDC, GET_PS_FEATURESETTING, sizeof(int), (char*)&param,
                   sizeof(int), (char*)&param) > 0) {
       return param;
     }
@@ skipping 67 matching lines @@
     SelectObject(m_hDC, m_hOldBitmap);
     DeleteDC(m_hDC);
   }
   if (m_hBitmap) {
     DeleteObject(m_hBitmap);
   }
   delete GetBitmap();
 }
 
 #endif  // _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_