Remove FX_DWORD from core/ and delete definition

core/include/fxge/fx_dib.h

 // 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
 
 #ifndef CORE_INCLUDE_FXGE_FX_DIB_H_
 #define CORE_INCLUDE_FXGE_FX_DIB_H_
 
 #include "core/fxcrt/include/fx_basic.h"
@@ skipping 42 matching lines @@
 #define FXDIB_BLEND_HARDLIGHT 8
 #define FXDIB_BLEND_SOFTLIGHT 9
 #define FXDIB_BLEND_DIFFERENCE 10
 #define FXDIB_BLEND_EXCLUSION 11
 #define FXDIB_BLEND_NONSEPARABLE 21
 #define FXDIB_BLEND_HUE 21
 #define FXDIB_BLEND_SATURATION 22
 #define FXDIB_BLEND_COLOR 23
 #define FXDIB_BLEND_LUMINOSITY 24
 #define FXDIB_BLEND_UNSUPPORTED -1
-typedef FX_DWORD FX_ARGB;
-typedef FX_DWORD FX_COLORREF;
-typedef FX_DWORD FX_CMYK;
+typedef uint32_t FX_ARGB;
+typedef uint32_t FX_COLORREF;
+typedef uint32_t FX_CMYK;
 class CFX_ClipRgn;
 class CFX_DIBSource;
 class CFX_DIBitmap;
 class CStretchEngine;
 
 #define FXSYS_RGB(r, g, b) ((r) | ((g) << 8) | ((b) << 16))
 #define FXSYS_GetRValue(rgb) ((rgb)&0xff)
 #define FXSYS_GetGValue(rgb) (((rgb) >> 8) & 0xff)
 #define FXSYS_GetBValue(rgb) (((rgb) >> 16) & 0xff)
 #define FX_CCOLOR(val) (255 - (val))
@@ skipping 10 matching lines @@
 void ArgbDecode(FX_ARGB argb, int& a, FX_COLORREF& rgb);
 inline FX_ARGB ArgbEncode(int a, int r, int g, int b) {
   return (a << 24) | (r << 16) | (g << 8) | b;
 }
 FX_ARGB ArgbEncode(int a, FX_COLORREF rgb);
 #define FXARGB_A(argb) ((uint8_t)((argb) >> 24))
 #define FXARGB_R(argb) ((uint8_t)((argb) >> 16))
 #define FXARGB_G(argb) ((uint8_t)((argb) >> 8))
 #define FXARGB_B(argb) ((uint8_t)(argb))
 #define FXARGB_MAKE(a, r, g, b) \
-  (((FX_DWORD)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
+  (((uint32_t)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
 #define FXARGB_MUL_ALPHA(argb, alpha) \
   (((((argb) >> 24) * (alpha) / 255) << 24) | ((argb)&0xffffff))
 #define FXRGB2GRAY(r, g, b) (((b)*11 + (g)*59 + (r)*30) / 100)
 #define FXCMYK2GRAY(c, m, y, k)                                       \
   (((255 - (c)) * (255 - (k)) * 30 + (255 - (m)) * (255 - (k)) * 59 + \
     (255 - (y)) * (255 - (k)) * 11) /                                 \
    25500)
 #define FXDIB_ALPHA_MERGE(backdrop, source, source_alpha) \
   (((backdrop) * (255 - (source_alpha)) + (source) * (source_alpha)) / 255)
 #define FXDIB_ALPHA_UNION(dest, src) ((dest) + (src) - (dest) * (src) / 255)
@@ skipping 54 matching lines @@
 class CFX_DIBSource {
  public:
   virtual ~CFX_DIBSource();
 
   int GetWidth() const { return m_Width; }
   int GetHeight() const { return m_Height; }
 
   FXDIB_Format GetFormat() const {
     return (FXDIB_Format)(m_AlphaFlag * 0x100 + m_bpp);
   }
-  FX_DWORD GetPitch() const { return m_Pitch; }
-  FX_DWORD* GetPalette() const { return m_pPalette; }
+  uint32_t GetPitch() const { return m_Pitch; }
+  uint32_t* GetPalette() const { return m_pPalette; }
 
   virtual uint8_t* GetBuffer() const;
   virtual const uint8_t* GetScanline(int line) const = 0;
   virtual FX_BOOL SkipToScanline(int line, IFX_Pause* pPause) const;
   virtual void DownSampleScanline(int line,
                                   uint8_t* dest_scan,
                                   int dest_bpp,
                                   int dest_width,
                                   FX_BOOL bFlipX,
                                   int clip_left,
                                   int clip_width) const = 0;
   virtual void SetDownSampleSize(int width, int height) {}
 
   int GetBPP() const { return m_bpp; }
 
   // TODO(thestig): Investigate this. Given the possible values of FXDIB_Format,
   // it feels as though this should be implemented as !!(m_AlphaFlag & 1) and
   // IsOpaqueImage() below should never be able to return TRUE.
   bool IsAlphaMask() const { return m_AlphaFlag == 1; }
   bool HasAlpha() const { return !!(m_AlphaFlag & 2); }
   bool IsOpaqueImage() const { return !(m_AlphaFlag & 3); }
   bool IsCmykImage() const { return !!(m_AlphaFlag & 4); }
 
   int GetPaletteSize() const {
     return IsAlphaMask() ? 0 : (m_bpp == 1 ? 2 : (m_bpp == 8 ? 256 : 0));
   }
 
-  FX_DWORD GetPaletteEntry(int index) const;
+  uint32_t GetPaletteEntry(int index) const;
 
-  void SetPaletteEntry(int index, FX_DWORD color);
-  FX_DWORD GetPaletteArgb(int index) const { return GetPaletteEntry(index); }
-  void SetPaletteArgb(int index, FX_DWORD color) {
+  void SetPaletteEntry(int index, uint32_t color);
+  uint32_t GetPaletteArgb(int index) const { return GetPaletteEntry(index); }
+  void SetPaletteArgb(int index, uint32_t color) {
     SetPaletteEntry(index, color);
   }
 
-  void CopyPalette(const FX_DWORD* pSrcPal, FX_DWORD size = 256);
+  void CopyPalette(const uint32_t* pSrcPal, uint32_t size = 256);
 
   CFX_DIBitmap* Clone(const FX_RECT* pClip = NULL) const;
   CFX_DIBitmap* CloneConvert(FXDIB_Format format,
                              const FX_RECT* pClip = NULL,
                              void* pIccTransform = NULL) const;
 
   CFX_DIBitmap* StretchTo(int dest_width,
                           int dest_height,
-                          FX_DWORD flags = 0,
+                          uint32_t flags = 0,
                           const FX_RECT* pClip = NULL) const;
   CFX_DIBitmap* TransformTo(const CFX_Matrix* pMatrix,
                             int& left,
                             int& top,
-                            FX_DWORD flags = 0,
+                            uint32_t flags = 0,
                             const FX_RECT* pClip = NULL) const;
 
   CFX_DIBitmap* GetAlphaMask(const FX_RECT* pClip = NULL) const;
   FX_BOOL CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
                         const FX_RECT* pClip = NULL);
 
   CFX_DIBitmap* SwapXY(FX_BOOL bXFlip,
                        FX_BOOL bYFlip,
                        const FX_RECT* pClip = NULL) const;
 
@@ skipping 10 matching lines @@
                       const CFX_ClipRgn* pClipRgn);
 
   CFX_DIBitmap* m_pAlphaMask;
 
  protected:
   CFX_DIBSource();
 
   int m_Width;
   int m_Height;
   int m_bpp;
-  FX_DWORD m_AlphaFlag;
-  FX_DWORD m_Pitch;
-  FX_DWORD* m_pPalette;
+  uint32_t m_AlphaFlag;
+  uint32_t m_Pitch;
+  uint32_t* m_pPalette;
 
   void BuildPalette();
   FX_BOOL BuildAlphaMask();
-  int FindPalette(FX_DWORD color) const;
-  void GetPalette(FX_DWORD* pal, int alpha) const;
+  int FindPalette(uint32_t color) const;
+  void GetPalette(uint32_t* pal, int alpha) const;
 };
 class CFX_DIBitmap : public CFX_DIBSource {
  public:
   CFX_DIBitmap();
   explicit CFX_DIBitmap(const CFX_DIBitmap& src);
   ~CFX_DIBitmap() override;
 
   FX_BOOL Create(int width,
                  int height,
                  FXDIB_Format format,
@@ skipping 10 matching lines @@
                           int dest_bpp,
                           int dest_width,
                           FX_BOOL bFlipX,
                           int clip_left,
                           int clip_width) const override;
 
   void TakeOver(CFX_DIBitmap* pSrcBitmap);
 
   FX_BOOL ConvertFormat(FXDIB_Format format, void* pIccTransform = NULL);
 
-  void Clear(FX_DWORD color);
+  void Clear(uint32_t color);
 
-  FX_DWORD GetPixel(int x, int y) const;
+  uint32_t GetPixel(int x, int y) const;
 
-  void SetPixel(int x, int y, FX_DWORD color);
+  void SetPixel(int x, int y, uint32_t color);
 
   FX_BOOL LoadChannel(FXDIB_Channel destChannel,
                       const CFX_DIBSource* pSrcBitmap,
                       FXDIB_Channel srcChannel);
 
   FX_BOOL LoadChannel(FXDIB_Channel destChannel, int value);
 
   FX_BOOL MultiplyAlpha(int alpha);
 
   FX_BOOL MultiplyAlpha(const CFX_DIBSource* pAlphaMask);
@@ skipping 17 matching lines @@
                           int blend_type = FXDIB_BLEND_NORMAL,
                           const CFX_ClipRgn* pClipRgn = NULL,
                           FX_BOOL bRgbByteOrder = FALSE,
                           void* pIccTransform = NULL);
 
   FX_BOOL TransferMask(int dest_left,
                        int dest_top,
                        int width,
                        int height,
                        const CFX_DIBSource* pMask,
-                       FX_DWORD color,
+                       uint32_t color,
                        int src_left,
                        int src_top,
                        int alpha_flag = 0,
                        void* pIccTransform = NULL);
 
   FX_BOOL CompositeMask(int dest_left,
                         int dest_top,
                         int width,
                         int height,
                         const CFX_DIBSource* pMask,
-                        FX_DWORD color,
+                        uint32_t color,
                         int src_left,
                         int src_top,
                         int blend_type = FXDIB_BLEND_NORMAL,
                         const CFX_ClipRgn* pClipRgn = NULL,
                         FX_BOOL bRgbByteOrder = FALSE,
                         int alpha_flag = 0,
                         void* pIccTransform = NULL);
 
   FX_BOOL CompositeRect(int dest_left,
                         int dest_top,
                         int width,
                         int height,
-                        FX_DWORD color,
+                        uint32_t color,
                         int alpha_flag = 0,
                         void* pIccTransform = NULL);
 
-  FX_BOOL ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor);
+  FX_BOOL ConvertColorScale(uint32_t forecolor, uint32_t backcolor);
 
-  FX_BOOL DitherFS(const FX_DWORD* pPalette,
+  FX_BOOL DitherFS(const uint32_t* pPalette,
                    int pal_size,
                    const FX_RECT* pRect = NULL);
 
  protected:
   uint8_t* m_pBuffer;
 
   FX_BOOL m_bExtBuf;
 
   FX_BOOL GetGrayData(void* pIccTransform = NULL);
 };
@@ skipping 12 matching lines @@
 typedef CFX_CountRef<CFX_DIBitmap> CFX_DIBitmapRef;
 class CFX_FilteredDIB : public CFX_DIBSource {
  public:
   CFX_FilteredDIB();
   ~CFX_FilteredDIB() override;
 
   void LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc = FALSE);
 
   virtual FXDIB_Format GetDestFormat() = 0;
 
-  virtual FX_DWORD* GetDestPalette() = 0;
+  virtual uint32_t* GetDestPalette() = 0;
 
   virtual void TranslateScanline(uint8_t* dest_buf,
                                  const uint8_t* src_buf) const = 0;
 
   virtual void TranslateDownSamples(uint8_t* dest_buf,
                                     const uint8_t* src_buf,
                                     int pixels,
                                     int Bpp) const = 0;
 
  protected:
@@ skipping 18 matching lines @@
  public:
   virtual ~IFX_ScanlineComposer() {}
 
   virtual void ComposeScanline(int line,
                                const uint8_t* scanline,
                                const uint8_t* scan_extra_alpha = NULL) = 0;
 
   virtual FX_BOOL SetInfo(int width,
                           int height,
                           FXDIB_Format src_format,
-                          FX_DWORD* pSrcPalette) = 0;
+                          uint32_t* pSrcPalette) = 0;
 };
 class CFX_ScanlineCompositor {
  public:
   CFX_ScanlineCompositor();
 
   ~CFX_ScanlineCompositor();
 
   FX_BOOL Init(FXDIB_Format dest_format,
                FXDIB_Format src_format,
                int32_t width,
-               FX_DWORD* pSrcPalette,
-               FX_DWORD mask_color,
+               uint32_t* pSrcPalette,
+               uint32_t mask_color,
                int blend_type,
                FX_BOOL bClip,
                FX_BOOL bRgbByteOrder = FALSE,
                int alpha_flag = 0,
                void* pIccTransform = NULL);
 
   void CompositeRgbBitmapLine(uint8_t* dest_scan,
                               const uint8_t* src_scan,
                               int width,
                               const uint8_t* clip_scan,
@@ skipping 17 matching lines @@
   void CompositeBitMaskLine(uint8_t* dest_scan,
                             const uint8_t* src_scan,
                             int src_left,
                             int width,
                             const uint8_t* clip_scan,
                             uint8_t* dst_extra_alpha = NULL);
 
  protected:
   int m_Transparency;
   FXDIB_Format m_SrcFormat, m_DestFormat;
-  FX_DWORD* m_pSrcPalette;
+  uint32_t* m_pSrcPalette;
 
   int m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, m_MaskBlack;
   int m_BlendType;
   void* m_pIccTransform;
   uint8_t* m_pCacheScanline;
   int m_CacheSize;
   FX_BOOL m_bRgbByteOrder;
 };
 
 class CFX_BitmapComposer : public IFX_ScanlineComposer {
  public:
   CFX_BitmapComposer();
   ~CFX_BitmapComposer() override;
 
   void Compose(CFX_DIBitmap* pDest,
                const CFX_ClipRgn* pClipRgn,
                int bitmap_alpha,
-               FX_DWORD mask_color,
+               uint32_t mask_color,
                FX_RECT& dest_rect,
                FX_BOOL bVertical,
                FX_BOOL bFlipX,
                FX_BOOL bFlipY,
                FX_BOOL bRgbByteOrder = FALSE,
                int alpha_flag = 0,
                void* pIccTransform = NULL,
                int blend_type = FXDIB_BLEND_NORMAL);
 
   // IFX_ScanlineComposer
   FX_BOOL SetInfo(int width,
                   int height,
                   FXDIB_Format src_format,
-                  FX_DWORD* pSrcPalette) override;
+                  uint32_t* pSrcPalette) override;
 
   void ComposeScanline(int line,
                        const uint8_t* scanline,
                        const uint8_t* scan_extra_alpha) override;
 
  protected:
   void DoCompose(uint8_t* dest_scan,
                  const uint8_t* src_scan,
                  int dest_width,
                  const uint8_t* clip_scan,
                  const uint8_t* src_extra_alpha = NULL,
                  uint8_t* dst_extra_alpha = NULL);
   CFX_DIBitmap* m_pBitmap;
   const CFX_ClipRgn* m_pClipRgn;
   FXDIB_Format m_SrcFormat;
   int m_DestLeft, m_DestTop, m_DestWidth, m_DestHeight, m_BitmapAlpha;
-  FX_DWORD m_MaskColor;
+  uint32_t m_MaskColor;
   const CFX_DIBitmap* m_pClipMask;
   CFX_ScanlineCompositor m_Compositor;
   FX_BOOL m_bVertical, m_bFlipX, m_bFlipY;
   int m_AlphaFlag;
   void* m_pIccTransform;
   FX_BOOL m_bRgbByteOrder;
   int m_BlendType;
   void ComposeScanlineV(int line,
                         const uint8_t* scanline,
                         const uint8_t* scan_extra_alpha = NULL);
   uint8_t* m_pScanlineV;
   uint8_t* m_pClipScanV;
   uint8_t* m_pAddClipScan;
   uint8_t* m_pScanlineAlphaV;
 };
 
 class CFX_BitmapStorer : public IFX_ScanlineComposer {
  public:
   CFX_BitmapStorer();
   ~CFX_BitmapStorer() override;
 
   // IFX_ScanlineComposer
   void ComposeScanline(int line,
                        const uint8_t* scanline,
                        const uint8_t* scan_extra_alpha) override;
 
   FX_BOOL SetInfo(int width,
                   int height,
                   FXDIB_Format src_format,
-                  FX_DWORD* pSrcPalette) override;
+                  uint32_t* pSrcPalette) override;
 
   CFX_DIBitmap* GetBitmap() { return m_pBitmap; }
 
   CFX_DIBitmap* Detach();
 
   void Replace(CFX_DIBitmap* pBitmap);
 
  private:
   CFX_DIBitmap* m_pBitmap;
 };
 
 class CFX_ImageStretcher {
  public:
   CFX_ImageStretcher();
   ~CFX_ImageStretcher();
 
   FX_BOOL Start(IFX_ScanlineComposer* pDest,
                 const CFX_DIBSource* pBitmap,
                 int dest_width,
                 int dest_height,
                 const FX_RECT& bitmap_rect,
-                FX_DWORD flags);
+                uint32_t flags);
 
   FX_BOOL Continue(IFX_Pause* pPause);
   FX_BOOL StartQuickStretch();
   FX_BOOL StartStretch();
   FX_BOOL ContinueQuickStretch(IFX_Pause* pPause);
   FX_BOOL ContinueStretch(IFX_Pause* pPause);
 
   IFX_ScanlineComposer* m_pDest;
   const CFX_DIBSource* m_pSource;
   CStretchEngine* m_pStretchEngine;
-  FX_DWORD m_Flags;
+  uint32_t m_Flags;
   FX_BOOL m_bFlipX;
   FX_BOOL m_bFlipY;
   int m_DestWidth;
   int m_DestHeight;
   FX_RECT m_ClipRect;
   int m_LineIndex;
   int m_DestBPP;
   uint8_t* m_pScanline;
   uint8_t* m_pMaskScanline;
   FXDIB_Format m_DestFormat;
@@ skipping 12 matching lines @@
 
   CFX_Matrix* m_pMatrix;
   FX_RECT m_StretchClip;
   int m_ResultLeft;
   int m_ResultTop;
   int m_ResultWidth;
   int m_ResultHeight;
   CFX_Matrix m_dest2stretch;
   CFX_ImageStretcher m_Stretcher;
   CFX_BitmapStorer m_Storer;
-  FX_DWORD m_Flags;
+  uint32_t m_Flags;
   int m_Status;
 };
 class CFX_ImageRenderer {
  public:
   CFX_ImageRenderer();
   ~CFX_ImageRenderer();
 
   FX_BOOL Start(CFX_DIBitmap* pDevice,
                 const CFX_ClipRgn* pClipRgn,
                 const CFX_DIBSource* pSource,
                 int bitmap_alpha,
-                FX_DWORD mask_color,
+                uint32_t mask_color,
                 const CFX_Matrix* pMatrix,
-                FX_DWORD dib_flags,
+                uint32_t dib_flags,
                 FX_BOOL bRgbByteOrder = FALSE,
                 int alpha_flag = 0,
                 void* pIccTransform = NULL,
                 int blend_type = FXDIB_BLEND_NORMAL);
 
   FX_BOOL Continue(IFX_Pause* pPause);
 
  protected:
   CFX_DIBitmap* m_pDevice;
   const CFX_ClipRgn* m_pClipRgn;
   int m_BitmapAlpha;
-  FX_DWORD m_MaskColor;
+  uint32_t m_MaskColor;
   CFX_Matrix m_Matrix;
   CFX_ImageTransformer* m_pTransformer;
   CFX_ImageStretcher m_Stretcher;
   CFX_BitmapComposer m_Composer;
   int m_Status;
   FX_RECT m_ClipBox;
-  FX_DWORD m_Flags;
+  uint32_t m_Flags;
   int m_AlphaFlag;
   void* m_pIccTransform;
   FX_BOOL m_bRgbByteOrder;
   int m_BlendType;
 };
 
 #endif  // CORE_INCLUDE_FXGE_FX_DIB_H_