Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_render/render_int.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_FPDFAPI_FPDF_RENDER_RENDER_INT_H_
 #define CORE_FPDFAPI_FPDF_RENDER_RENDER_INT_H_
 
 #include <map>
@@ skipping 38 matching lines @@
 
 class CPDF_Type3Glyphs {
  public:
   CPDF_Type3Glyphs() : m_TopBlueCount(0), m_BottomBlueCount(0) {}
   ~CPDF_Type3Glyphs();
   void AdjustBlue(FX_FLOAT top,
                   FX_FLOAT bottom,
                   int& top_line,
                   int& bottom_line);
 
-  std::map<FX_DWORD, CFX_GlyphBitmap*> m_GlyphMap;
+  std::map<uint32_t, CFX_GlyphBitmap*> m_GlyphMap;
   int m_TopBlue[TYPE3_MAX_BLUES];
   int m_BottomBlue[TYPE3_MAX_BLUES];
   int m_TopBlueCount;
   int m_BottomBlueCount;
 };
 class CPDF_Type3Cache {
  public:
   explicit CPDF_Type3Cache(CPDF_Type3Font* pFont) : m_pFont(pFont) {}
   ~CPDF_Type3Cache();
 
-  CFX_GlyphBitmap* LoadGlyph(FX_DWORD charcode,
+  CFX_GlyphBitmap* LoadGlyph(uint32_t charcode,
                              const CFX_Matrix* pMatrix,
                              FX_FLOAT retinaScaleX = 1.0f,
                              FX_FLOAT retinaScaleY = 1.0f);
 
  protected:
   CFX_GlyphBitmap* RenderGlyph(CPDF_Type3Glyphs* pSize,
-                               FX_DWORD charcode,
+                               uint32_t charcode,
                                const CFX_Matrix* pMatrix,
                                FX_FLOAT retinaScaleX = 1.0f,
                                FX_FLOAT retinaScaleY = 1.0f);
   CPDF_Type3Font* const m_pFont;
   std::map<CFX_ByteString, CPDF_Type3Glyphs*> m_SizeMap;
 };
 
 class CPDF_TransferFunc {
  public:
   explicit CPDF_TransferFunc(CPDF_Document* pDoc);
@@ skipping 53 matching lines @@
                      const CPDF_PageObject* pStopObj,
                      const CPDF_RenderStatus* pParentStatus,
                      const CPDF_GraphicStates* pInitialStates,
                      const CPDF_RenderOptions* pOptions,
                      int transparency,
                      FX_BOOL bDropObjects,
                      CPDF_Dictionary* pFormResource = NULL,
                      FX_BOOL bStdCS = FALSE,
                      CPDF_Type3Char* pType3Char = NULL,
                      FX_ARGB fill_color = 0,
-                     FX_DWORD GroupFamily = 0,
+                     uint32_t GroupFamily = 0,
                      FX_BOOL bLoadMask = FALSE);
   void RenderObjectList(const CPDF_PageObjectHolder* pObjectHolder,
                         const CFX_Matrix* pObj2Device);
   void RenderSingleObject(const CPDF_PageObject* pObj,
                           const CFX_Matrix* pObj2Device);
   FX_BOOL ContinueSingleObject(const CPDF_PageObject* pObj,
                                const CFX_Matrix* pObj2Device,
                                IFX_Pause* pPause);
   CPDF_RenderContext* GetContext() { return m_pContext; }
 
@@ skipping 40 matching lines @@
                        const CFX_Matrix* pObj2Device);
   FX_BOOL OutputBitmapAlpha(CPDF_ImageObject* pImageObj,
                             const CFX_Matrix* pImage2Device);
   FX_BOOL OutputImage(CPDF_ImageObject* pImageObj,
                       const CFX_Matrix* pImage2Device);
   FX_BOOL OutputDIBSource(const CFX_DIBSource* pOutputBitmap,
                           FX_ARGB fill_argb,
                           int bitmap_alpha,
                           const CFX_Matrix* pImage2Device,
                           CPDF_ImageCacheEntry* pImageCache,
-                          FX_DWORD flags);
+                          uint32_t flags);
   void CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
                          int left,
                          int top,
                          FX_ARGB mask_argb,
                          int bitmap_alpha,
                          int blend_mode,
                          int bIsolated);
   FX_BOOL ProcessShading(const CPDF_ShadingObject* pShadingObj,
                          const CFX_Matrix* pObj2Device);
   void DrawShading(CPDF_ShadingPattern* pPattern,
@@ skipping 51 matching lines @@
   const CPDF_PageObject* m_pCurObj;
   const CPDF_PageObject* m_pStopObj;
   CPDF_GraphicStates m_InitialStates;
   int m_HalftoneLimit;
   std::unique_ptr<IPDF_ObjectRenderer> m_pObjectRenderer;
   FX_BOOL m_bPrint;
   int m_Transparency;
   int m_DitherBits;
   FX_BOOL m_bDropObjects;
   FX_BOOL m_bStdCS;
-  FX_DWORD m_GroupFamily;
+  uint32_t m_GroupFamily;
   FX_BOOL m_bLoadMask;
   CPDF_Type3Char* m_pType3Char;
   FX_ARGB m_T3FillColor;
   int m_curBlend;
 };
 class CPDF_ImageLoader {
  public:
   CPDF_ImageLoader()
       : m_pBitmap(nullptr),
         m_pMask(nullptr),
         m_MatteColor(0),
         m_bCached(FALSE),
         m_nDownsampleWidth(0),
         m_nDownsampleHeight(0) {}
   ~CPDF_ImageLoader();
 
   FX_BOOL Start(const CPDF_ImageObject* pImage,
                 CPDF_PageRenderCache* pCache,
                 CPDF_ImageLoaderHandle*& LoadHandle,
                 FX_BOOL bStdCS = FALSE,
-                FX_DWORD GroupFamily = 0,
+                uint32_t GroupFamily = 0,
                 FX_BOOL bLoadMask = FALSE,
                 CPDF_RenderStatus* pRenderStatus = NULL,
                 int32_t nDownsampleWidth = 0,
                 int32_t nDownsampleHeight = 0);
   FX_BOOL Continue(CPDF_ImageLoaderHandle* LoadHandle, IFX_Pause* pPause);
 
   CFX_DIBSource* m_pBitmap;
   CFX_DIBSource* m_pMask;
-  FX_DWORD m_MatteColor;
+  uint32_t m_MatteColor;
   FX_BOOL m_bCached;
 
  protected:
   int32_t m_nDownsampleWidth;
   int32_t m_nDownsampleHeight;
 };
 class CPDF_ImageLoaderHandle {
  public:
   CPDF_ImageLoaderHandle();
   ~CPDF_ImageLoaderHandle();
 
   FX_BOOL Start(CPDF_ImageLoader* pImageLoader,
                 const CPDF_ImageObject* pImage,
                 CPDF_PageRenderCache* pCache,
                 FX_BOOL bStdCS = FALSE,
-                FX_DWORD GroupFamily = 0,
+                uint32_t GroupFamily = 0,
                 FX_BOOL bLoadMask = FALSE,
                 CPDF_RenderStatus* pRenderStatus = NULL,
                 int32_t nDownsampleWidth = 0,
                 int32_t nDownsampleHeight = 0);
   FX_BOOL Continue(IFX_Pause* pPause);
 
  protected:
   CPDF_ImageLoader* m_pImageLoader;
   CPDF_PageRenderCache* m_pCache;
   CPDF_ImageObject* m_pImage;
@@ skipping 12 matching lines @@
                 const CFX_Matrix* pObj2Device,
                 FX_BOOL bStdCS,
                 int blendType = FXDIB_BLEND_NORMAL) override;
   FX_BOOL Continue(IFX_Pause* pPause) override;
 
   FX_BOOL Start(CPDF_RenderStatus* pStatus,
                 const CFX_DIBSource* pDIBSource,
                 FX_ARGB bitmap_argb,
                 int bitmap_alpha,
                 const CFX_Matrix* pImage2Device,
-                FX_DWORD flags,
+                uint32_t flags,
                 FX_BOOL bStdCS,
                 int blendType = FXDIB_BLEND_NORMAL);
 
  protected:
   CPDF_RenderStatus* m_pRenderStatus;
   const CPDF_ImageObject* m_pImageObject;
   int m_Status;
   const CFX_Matrix* m_pObj2Device;
   CFX_Matrix m_ImageMatrix;
   CPDF_ImageLoader m_Loader;
   const CFX_DIBSource* m_pDIBSource;
   CFX_DIBitmap* m_pClone;
   int m_BitmapAlpha;
   FX_BOOL m_bPatternColor;
   CPDF_Pattern* m_pPattern;
   FX_ARGB m_FillArgb;
-  FX_DWORD m_Flags;
+  uint32_t m_Flags;
   CFX_ImageTransformer* m_pTransformer;
   void* m_DeviceHandle;
   CPDF_ImageLoaderHandle* m_LoadHandle;
   FX_BOOL m_bStdCS;
   int m_BlendType;
   FX_BOOL StartBitmapAlpha();
   FX_BOOL StartDIBSource();
   FX_BOOL StartRenderDIBSource();
   FX_BOOL StartLoadDIBSource();
   FX_BOOL DrawMaskedImage();
@@ skipping 49 matching lines @@
 };
 
 class CPDF_ImageCacheEntry {
  public:
   CPDF_ImageCacheEntry(CPDF_Document* pDoc, CPDF_Stream* pStream);
   ~CPDF_ImageCacheEntry();
   void ClearImageData();
   void Reset(const CFX_DIBitmap* pBitmap);
   FX_BOOL GetCachedBitmap(CFX_DIBSource*& pBitmap,
                           CFX_DIBSource*& pMask,
-                          FX_DWORD& MatteColor,
+                          uint32_t& MatteColor,
                           CPDF_Dictionary* pPageResources,
                           FX_BOOL bStdCS = FALSE,
-                          FX_DWORD GroupFamily = 0,
+                          uint32_t GroupFamily = 0,
                           FX_BOOL bLoadMask = FALSE,
                           CPDF_RenderStatus* pRenderStatus = NULL,
                           int32_t downsampleWidth = 0,
                           int32_t downsampleHeight = 0);
-  FX_DWORD EstimateSize() const { return m_dwCacheSize; }
-  FX_DWORD GetTimeCount() const { return m_dwTimeCount; }
+  uint32_t EstimateSize() const { return m_dwCacheSize; }
+  uint32_t GetTimeCount() const { return m_dwTimeCount; }
   CPDF_Stream* GetStream() const { return m_pStream; }
-  void SetTimeCount(FX_DWORD dwTimeCount) { m_dwTimeCount = dwTimeCount; }
+  void SetTimeCount(uint32_t dwTimeCount) { m_dwTimeCount = dwTimeCount; }
   int m_dwTimeCount;
 
  public:
   int StartGetCachedBitmap(CPDF_Dictionary* pFormResources,
                            CPDF_Dictionary* pPageResources,
                            FX_BOOL bStdCS = FALSE,
-                           FX_DWORD GroupFamily = 0,
+                           uint32_t GroupFamily = 0,
                            FX_BOOL bLoadMask = FALSE,
                            CPDF_RenderStatus* pRenderStatus = NULL,
                            int32_t downsampleWidth = 0,
                            int32_t downsampleHeight = 0);
   int Continue(IFX_Pause* pPause);
   CFX_DIBSource* DetachBitmap();
   CFX_DIBSource* DetachMask();
   CFX_DIBSource* m_pCurBitmap;
   CFX_DIBSource* m_pCurMask;
-  FX_DWORD m_MatteColor;
+  uint32_t m_MatteColor;
   CPDF_RenderStatus* m_pRenderStatus;
 
  protected:
   void ContinueGetCachedBitmap();
 
   CPDF_Document* m_pDocument;
   CPDF_Stream* m_pStream;
   CFX_DIBSource* m_pCachedBitmap;
   CFX_DIBSource* m_pCachedMask;
-  FX_DWORD m_dwCacheSize;
+  uint32_t m_dwCacheSize;
   void CalcSize();
 };
 typedef struct {
   FX_FLOAT m_DecodeMin;
   FX_FLOAT m_DecodeStep;
   int m_ColorKeyMin;
   int m_ColorKeyMax;
 } DIB_COMP_DATA;
 
 class CPDF_DIBSource : public CFX_DIBSource {
  public:
   CPDF_DIBSource();
   ~CPDF_DIBSource() override;
 
   FX_BOOL Load(CPDF_Document* pDoc,
                const CPDF_Stream* pStream,
                CPDF_DIBSource** ppMask,
-               FX_DWORD* pMatteColor,
+               uint32_t* pMatteColor,
                CPDF_Dictionary* pFormResources,
                CPDF_Dictionary* pPageResources,
                FX_BOOL bStdCS = FALSE,
-               FX_DWORD GroupFamily = 0,
+               uint32_t GroupFamily = 0,
                FX_BOOL bLoadMask = FALSE);
 
   // CFX_DIBSource
   FX_BOOL SkipToScanline(int line, IFX_Pause* pPause) const override;
   uint8_t* GetBuffer() const override;
   const uint8_t* GetScanline(int line) const override;
   void DownSampleScanline(int line,
                           uint8_t* dest_scan,
                           int dest_bpp,
                           int dest_width,
                           FX_BOOL bFlipX,
                           int clip_left,
                           int clip_width) const override;
   void SetDownSampleSize(int dest_width, int dest_height) override;
 
   CFX_DIBitmap* GetBitmap() const;
   void ReleaseBitmap(CFX_DIBitmap* pBitmap) const;
   void ClearImageData();
-  FX_DWORD GetMatteColor() const { return m_MatteColor; }
+  uint32_t GetMatteColor() const { return m_MatteColor; }
 
   int StartLoadDIBSource(CPDF_Document* pDoc,
                          const CPDF_Stream* pStream,
                          FX_BOOL bHasMask,
                          CPDF_Dictionary* pFormResources,
                          CPDF_Dictionary* pPageResources,
                          FX_BOOL bStdCS = FALSE,
-                         FX_DWORD GroupFamily = 0,
+                         uint32_t GroupFamily = 0,
                          FX_BOOL bLoadMask = FALSE);
   int ContinueLoadDIBSource(IFX_Pause* pPause);
   int StratLoadMask();
   int StartLoadMaskDIB();
   int ContinueLoadMaskDIB(IFX_Pause* pPause);
   int ContinueToLoadMask();
   CPDF_DIBSource* DetachMask();
 
  private:
   bool LoadColorInfo(const CPDF_Dictionary* pFormResources,
                      const CPDF_Dictionary* pPageResources);
   DIB_COMP_DATA* GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode,
                                        FX_BOOL& bColorKey);
-  CPDF_DIBSource* LoadMask(FX_DWORD& MatteColor);
+  CPDF_DIBSource* LoadMask(uint32_t& MatteColor);
   CPDF_DIBSource* LoadMaskDIB(CPDF_Stream* pMask);
   void LoadJpxBitmap();
   void LoadPalette();
   int CreateDecoder();
   void TranslateScanline24bpp(uint8_t* dest_scan,
                               const uint8_t* src_scan) const;
   void ValidateDictParam();
   void DownSampleScanline1Bit(int orig_Bpp,
                               int dest_Bpp,
-                              FX_DWORD src_width,
+                              uint32_t src_width,
                               const uint8_t* pSrcLine,
                               uint8_t* dest_scan,
                               int dest_width,
                               FX_BOOL bFlipX,
                               int clip_left,
                               int clip_width) const;
   void DownSampleScanline8Bit(int orig_Bpp,
                               int dest_Bpp,
-                              FX_DWORD src_width,
+                              uint32_t src_width,
                               const uint8_t* pSrcLine,
                               uint8_t* dest_scan,
                               int dest_width,
                               FX_BOOL bFlipX,
                               int clip_left,
                               int clip_width) const;
   void DownSampleScanline32Bit(int orig_Bpp,
                                int dest_Bpp,
-                               FX_DWORD src_width,
+                               uint32_t src_width,
                                const uint8_t* pSrcLine,
                                uint8_t* dest_scan,
                                int dest_width,
                                FX_BOOL bFlipX,
                                int clip_left,
                                int clip_width) const;
   FX_BOOL TransMask() const;
 
   CPDF_Document* m_pDocument;
   const CPDF_Stream* m_pStream;
   std::unique_ptr<CPDF_StreamAcc> m_pStreamAcc;
   const CPDF_Dictionary* m_pDict;
   CPDF_ColorSpace* m_pColorSpace;
-  FX_DWORD m_Family;
-  FX_DWORD m_bpc;
-  FX_DWORD m_bpc_orig;
-  FX_DWORD m_nComponents;
-  FX_DWORD m_GroupFamily;
-  FX_DWORD m_MatteColor;
+  uint32_t m_Family;
+  uint32_t m_bpc;
+  uint32_t m_bpc_orig;
+  uint32_t m_nComponents;
+  uint32_t m_GroupFamily;
+  uint32_t m_MatteColor;
   FX_BOOL m_bLoadMask;
   FX_BOOL m_bDefaultDecode;
   FX_BOOL m_bImageMask;
   FX_BOOL m_bDoBpcCheck;
   FX_BOOL m_bColorKey;
   FX_BOOL m_bHasMask;
   FX_BOOL m_bStdCS;
   DIB_COMP_DATA* m_pCompData;
   uint8_t* m_pLineBuf;
   uint8_t* m_pMaskedLine;
@@ skipping 27 matching lines @@
   const uint8_t* m_RampB;
 };
 
 struct _CPDF_UniqueKeyGen {
   void Generate(int count, ...);
   FX_CHAR m_Key[128];
   int m_KeyLen;
 };
 
 #endif  // CORE_FPDFAPI_FPDF_RENDER_RENDER_INT_H_