Remove FX_DWORD from core/ and delete definition

core/fxge/agg/fx_agg_driver.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/agg/fx_agg_driver.h"
 
 #include <algorithm>
 
@@ skipping 215 matching lines @@
 void CFX_AggDeviceDriver::InitPlatform() {}
 
 void CFX_AggDeviceDriver::DestroyPlatform() {}
 
 FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int nChars,
                                             const FXTEXT_CHARPOS* pCharPos,
                                             CFX_Font* pFont,
                                             CFX_FontCache* pCache,
                                             const CFX_Matrix* pObject2Device,
                                             FX_FLOAT font_size,
-                                            FX_DWORD color,
+                                            uint32_t color,
                                             int alpha_flag,
                                             void* pIccTransform) {
   return FALSE;
 }  // _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
 #endif
 
 int CFX_AggDeviceDriver::GetDeviceCaps(int caps_id) {
   switch (caps_id) {
     case FXDC_DEVICE_CLASS:
       return FXDC_DISPLAY;
@@ skipping 130 matching lines @@
   RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device,
                   pGraphState);
   rasterizer.filling_rule(agg::fill_non_zero);
   SetClipMask(rasterizer);
   return TRUE;
 }
 
 class CFX_Renderer {
  private:
   int m_Alpha, m_Red, m_Green, m_Blue, m_Gray;
-  FX_DWORD m_Color;
+  uint32_t m_Color;
   FX_BOOL m_bFullCover;
   FX_BOOL m_bRgbByteOrder;
   CFX_DIBitmap* m_pOriDevice;
   FX_RECT m_ClipBox;
   const CFX_DIBitmap* m_pClipMask;
   CFX_DIBitmap* m_pDevice;
   const CFX_ClipRgn* m_pClipRgn;
   void (CFX_Renderer::*composite_span)(uint8_t*,
                                        int,
                                        int,
@@ skipping 341 matching lines @@
           }
         } else {
           if (clip_scan) {
             src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
           } else {
             src_alpha = m_Alpha * cover_scan[col] / 255;
           }
         }
         if (src_alpha) {
           if (src_alpha == 255) {
-            *(FX_DWORD*)dest_scan = m_Color;
+            *(uint32_t*)dest_scan = m_Color;
           } else {
             uint8_t dest_alpha =
                 dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
             dest_scan[3] = dest_alpha;
             int alpha_ratio = src_alpha * 255 / dest_alpha;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
             dest_scan++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
             dest_scan++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
@@ skipping 15 matching lines @@
         }
       } else {
         if (clip_scan) {
           src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
         } else {
           src_alpha = m_Alpha * cover_scan[col] / 255;
         }
       }
       if (src_alpha) {
         if (src_alpha == 255) {
-          *(FX_DWORD*)dest_scan = m_Color;
+          *(uint32_t*)dest_scan = m_Color;
         } else {
           if (dest_scan[3] == 0) {
             dest_scan[3] = src_alpha;
             *dest_scan++ = m_Blue;
             *dest_scan++ = m_Green;
             *dest_scan = m_Red;
             dest_scan += 2;
             continue;
           }
           uint8_t dest_alpha =
@@ skipping 31 matching lines @@
       for (int col = col_start; col < col_end; col++) {
         int src_alpha;
         if (clip_scan) {
           src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
         } else {
           src_alpha = m_Alpha * cover_scan[col] / 255;
         }
         if (src_alpha) {
           if (src_alpha == 255) {
             if (Bpp == 4) {
-              *(FX_DWORD*)dest_scan = m_Color;
+              *(uint32_t*)dest_scan = m_Color;
             } else if (Bpp == 3) {
               *dest_scan++ = m_Red;
               *dest_scan++ = m_Green;
               *dest_scan++ = m_Blue;
               continue;
             }
           } else {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
             dest_scan++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
@@ skipping 59 matching lines @@
         } else {
           if (clip_scan) {
             src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
           } else {
             src_alpha = m_Alpha * cover_scan[col] / 255;
           }
         }
         if (src_alpha) {
           if (src_alpha == 255) {
             if (Bpp == 4) {
-              *(FX_DWORD*)dest_scan = m_Color;
+              *(uint32_t*)dest_scan = m_Color;
             } else if (Bpp == 3) {
               *dest_scan++ = m_Blue;
               *dest_scan++ = m_Green;
               *dest_scan++ = m_Red;
               continue;
             }
           } else {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
             dest_scan++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
@@ skipping 146 matching lines @@
       if (--num_spans == 0) {
         break;
       }
       ++span;
     }
   }
 
   FX_BOOL Init(CFX_DIBitmap* pDevice,
                CFX_DIBitmap* pOriDevice,
                const CFX_ClipRgn* pClipRgn,
-               FX_DWORD color,
+               uint32_t color,
                FX_BOOL bFullCover,
                FX_BOOL bRgbByteOrder,
                int alpha_flag = 0,
                void* pIccTransform = NULL) {
     m_pDevice = pDevice;
     m_pClipRgn = pClipRgn;
     composite_span = NULL;
     m_bRgbByteOrder = bRgbByteOrder;
     m_pOriDevice = pOriDevice;
     if (m_pClipRgn) {
@@ skipping 109 matching lines @@
     }
     if (m_pDevice->GetBPP() == 1) {
       composite_span = &CFX_Renderer::CompositeSpan1bpp;
     }
     return TRUE;
   }
 };
 
 FX_BOOL CFX_AggDeviceDriver::RenderRasterizer(
     agg::rasterizer_scanline_aa& rasterizer,
-    FX_DWORD color,
+    uint32_t color,
     FX_BOOL bFullCover,
     FX_BOOL bGroupKnockout,
     int alpha_flag,
     void* pIccTransform) {
   CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : NULL;
   CFX_Renderer render;
   if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover,
                    m_bRgbByteOrder, alpha_flag, pIccTransform)) {
     return FALSE;
   }
   agg::scanline_u8 scanline;
   agg::render_scanlines(rasterizer, scanline, render,
                         (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                       const CFX_Matrix* pObject2Device,
                                       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;
   }
   if (!GetBuffer()) {
     return TRUE;
   }
@@ skipping 59 matching lines @@
                     FXGETFLAG_ALPHA_STROKE(alpha_flag);
     if (!RenderRasterizer(rasterizer, stroke_color,
                           fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout,
                           fill_flag, pIccTransform)) {
       return FALSE;
     }
   }
   return TRUE;
 }
 
-void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, FX_DWORD argb) {
+void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, uint32_t argb) {
   if (x < 0 || x >= pBitmap->GetWidth() || y < 0 || y >= pBitmap->GetHeight()) {
     return;
   }
   uint8_t* pos = (uint8_t*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() +
                  x * pBitmap->GetBPP() / 8;
   if (pBitmap->GetFormat() == FXDIB_Argb) {
     FXARGB_SETRGBORDERDIB(pos, ArgbGamma(argb));
   } else {
     int alpha = FXARGB_A(argb);
     pos[0] = (FXARGB_R(argb) * alpha + pos[0] * (255 - alpha)) / 255;
@@ skipping 18 matching lines @@
   int src_r = FXARGB_R(argb), src_g = FXARGB_G(argb), src_b = FXARGB_B(argb);
   int Bpp = pBitmap->GetBPP() / 8;
   FX_BOOL bAlpha = pBitmap->HasAlpha();
   int dib_argb = FXARGB_TOBGRORDERDIB(argb);
   uint8_t* pBuffer = pBitmap->GetBuffer();
   if (src_alpha == 255) {
     for (int row = rect.top; row < rect.bottom; row++) {
       uint8_t* dest_scan =
           pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp;
       if (Bpp == 4) {
-        FX_DWORD* scan = (FX_DWORD*)dest_scan;
+        uint32_t* scan = (uint32_t*)dest_scan;
         for (int col = 0; col < width; col++) {
           *scan++ = dib_argb;
         }
       } else {
         for (int col = 0; col < width; col++) {
           *dest_scan++ = src_r;
           *dest_scan++ = src_g;
           *dest_scan++ = src_b;
         }
       }
@@ skipping 151 matching lines @@
 FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, uint8_t alpha) {
   uint8_t r, g, b;
   AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
                      FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r, g, b);
   return ArgbEncode(alpha, r, g, b);
 }
 
 FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice,
                      int x,
                      int y,
-                     FX_DWORD color,
+                     uint32_t color,
                      int alpha_flag,
                      void* pIccTransform) {
   FX_BOOL bObjCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
   int alpha = bObjCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
   if (pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color,
                                   (uint8_t*)&color, 1);
@@ skipping 14 matching lines @@
   }
   pDevice->SetPixel(x, y, color);
   if (pDevice->m_pAlphaMask) {
     pDevice->m_pAlphaMask->SetPixel(x, y, alpha << 24);
   }
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::SetPixel(int x,
                                       int y,
-                                      FX_DWORD color,
+                                      uint32_t color,
                                       int alpha_flag,
                                       void* pIccTransform) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
     pIccTransform = NULL;
   }
   if (!m_pClipRgn) {
@@ skipping 25 matching lines @@
       } else {
         color = (color & 0xffffff) | (new_alpha << 24);
       }
       return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform);
     }
   }
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::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;
   }
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   FX_RECT clip_rect;
@@ skipping 79 matching lines @@
                                pBack, left, top);
   } else {
     bRet = pBitmap->TransferBitmap(0, 0, rect.Width(), rect.Height(), pBack,
                                    left, top, pIccTransform);
   }
   delete pBack;
   return bRet;
 }
 
 FX_BOOL CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
-                                       FX_DWORD argb,
+                                       uint32_t argb,
                                        const FX_RECT* pSrcRect,
                                        int left,
                                        int top,
                                        int blend_type,
                                        int alpha_flag,
                                        void* pIccTransform) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (pBitmap->IsAlphaMask())
     return m_pBitmap->CompositeMask(
         left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
         pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder,
         alpha_flag, pIccTransform);
   return m_pBitmap->CompositeBitmap(
       left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, pSrcRect->left,
       pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, pIccTransform);
 }
 
 FX_BOOL CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
-                                           FX_DWORD argb,
+                                           uint32_t argb,
                                            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) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (dest_width == pSource->GetWidth() &&
       dest_height == pSource->GetHeight()) {
     FX_RECT rect(0, 0, dest_width, dest_height);
     return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type,
@@ skipping 12 matching lines @@
   CFX_ImageStretcher stretcher;
   if (stretcher.Start(&composer, pSource, dest_width, dest_height, dest_clip,
                       flags)) {
     stretcher.Continue(NULL);
   }
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
                                          int bitmap_alpha,
-                                         FX_DWORD argb,
+                                         uint32_t argb,
                                          const CFX_Matrix* pMatrix,
-                                         FX_DWORD render_flags,
+                                         uint32_t render_flags,
                                          void*& handle,
                                          int alpha_flag,
                                          void* pIccTransform,
                                          int blend_type) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer;
   pRenderer->Start(m_pBitmap, m_pClipRgn, pSource, bitmap_alpha, argb, pMatrix,
                    render_flags, m_bRgbByteOrder, alpha_flag, pIccTransform);
@@ skipping 50 matching lines @@
       new CFX_AggDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
   SetDeviceDriver(pDriver);
   return true;
 }
 
 CFX_FxgeDevice::~CFX_FxgeDevice() {
   if (m_bOwnedBitmap) {
     delete GetBitmap();
   }
 }