Remove FX_DWORD from core/ and delete definition

core/fxge/dib/fx_dib_main.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_dib.h"
 
 #include <limits.h>
 
 #include "core/fxge/dib/dib_int.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_ge.h"
 
 FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
                       uint8_t* dest_buf,
                       int dest_pitch,
                       int width,
                       int height,
                       const CFX_DIBSource* pSrcBitmap,
                       int src_left,
                       int src_top,
-                      FX_DWORD*& pal,
+                      uint32_t*& pal,
                       void* pIccTransform);
-void CmykDecode(FX_DWORD cmyk, int& c, int& m, int& y, int& k) {
+void CmykDecode(uint32_t cmyk, int& c, int& m, int& y, int& k) {
   c = FXSYS_GetCValue(cmyk);
   m = FXSYS_GetMValue(cmyk);
   y = FXSYS_GetYValue(cmyk);
   k = FXSYS_GetKValue(cmyk);
 }
-void ArgbDecode(FX_DWORD argb, int& a, int& r, int& g, int& b) {
+void ArgbDecode(uint32_t argb, int& a, int& r, int& g, int& b) {
   a = FXARGB_A(argb);
   r = FXARGB_R(argb);
   g = FXARGB_G(argb);
   b = FXARGB_B(argb);
 }
-void ArgbDecode(FX_DWORD argb, int& a, FX_COLORREF& rgb) {
+void ArgbDecode(uint32_t argb, int& a, FX_COLORREF& rgb) {
   a = FXARGB_A(argb);
   rgb = FXSYS_RGB(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
 }
-FX_DWORD ArgbEncode(int a, FX_COLORREF rgb) {
+uint32_t ArgbEncode(int a, FX_COLORREF rgb) {
   return FXARGB_MAKE(a, FXSYS_GetRValue(rgb), FXSYS_GetGValue(rgb),
                      FXSYS_GetBValue(rgb));
 }
 
 CFX_DIBSource::CFX_DIBSource() {
   m_bpp = 0;
   m_AlphaFlag = 0;
   m_Width = m_Height = 0;
   m_Pitch = 0;
   m_pPalette = NULL;
@@ skipping 137 matching lines @@
     delete pNewBitmap;
     return NULL;
   }
   pNewBitmap->CopyPalette(m_pPalette);
   pNewBitmap->CopyAlphaMask(m_pAlphaMask, pClip);
   if (GetBPP() == 1 && rect.left % 8 != 0) {
     int left_shift = rect.left % 32;
     int right_shift = 32 - left_shift;
     int dword_count = pNewBitmap->m_Pitch / 4;
     for (int row = rect.top; row < rect.bottom; row++) {
-      FX_DWORD* src_scan = (FX_DWORD*)GetScanline(row) + rect.left / 32;
-      FX_DWORD* dest_scan = (FX_DWORD*)pNewBitmap->GetScanline(row - rect.top);
+      uint32_t* src_scan = (uint32_t*)GetScanline(row) + rect.left / 32;
+      uint32_t* dest_scan = (uint32_t*)pNewBitmap->GetScanline(row - rect.top);
       for (int i = 0; i < dword_count; i++) {
         dest_scan[i] =
             (src_scan[i] << left_shift) | (src_scan[i + 1] >> right_shift);
       }
     }
   } else {
     int copy_len = (pNewBitmap->GetWidth() * pNewBitmap->GetBPP() + 7) / 8;
-    if (m_Pitch < (FX_DWORD)copy_len) {
+    if (m_Pitch < (uint32_t)copy_len) {
       copy_len = m_Pitch;
     }
     for (int row = rect.top; row < rect.bottom; row++) {
       const uint8_t* src_scan = GetScanline(row) + rect.left * m_bpp / 8;
       uint8_t* dest_scan = (uint8_t*)pNewBitmap->GetScanline(row - rect.top);
       FXSYS_memcpy(dest_scan, src_scan, copy_len);
     }
   }
   return pNewBitmap;
 }
 void CFX_DIBSource::BuildPalette() {
   if (m_pPalette) {
     return;
   }
   if (GetBPP() == 1) {
-    m_pPalette = FX_Alloc(FX_DWORD, 2);
+    m_pPalette = FX_Alloc(uint32_t, 2);
     if (IsCmykImage()) {
       m_pPalette[0] = 0xff;
       m_pPalette[1] = 0;
     } else {
       m_pPalette[0] = 0xff000000;
       m_pPalette[1] = 0xffffffff;
     }
   } else if (GetBPP() == 8) {
-    m_pPalette = FX_Alloc(FX_DWORD, 256);
+    m_pPalette = FX_Alloc(uint32_t, 256);
     if (IsCmykImage()) {
       for (int i = 0; i < 256; i++) {
         m_pPalette[i] = 0xff - i;
       }
     } else {
       for (int i = 0; i < 256; i++) {
         m_pPalette[i] = 0xff000000 | (i * 0x10101);
       }
     }
   }
 }
 FX_BOOL CFX_DIBSource::BuildAlphaMask() {
   if (m_pAlphaMask) {
     return TRUE;
   }
   m_pAlphaMask = new CFX_DIBitmap;
   if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
     delete m_pAlphaMask;
     m_pAlphaMask = NULL;
     return FALSE;
   }
   FXSYS_memset(m_pAlphaMask->GetBuffer(), 0xff,
                m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
   return TRUE;
 }
-FX_DWORD CFX_DIBSource::GetPaletteEntry(int index) const {
+uint32_t CFX_DIBSource::GetPaletteEntry(int index) const {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   if (m_pPalette) {
     return m_pPalette[index];
   }
   if (IsCmykImage()) {
     if (GetBPP() == 1) {
       return index ? 0 : 0xff;
     }
     return 0xff - index;
   }
   if (GetBPP() == 1) {
     return index ? 0xffffffff : 0xff000000;
   }
   return index * 0x10101 | 0xff000000;
 }
-void CFX_DIBSource::SetPaletteEntry(int index, FX_DWORD color) {
+void CFX_DIBSource::SetPaletteEntry(int index, uint32_t color) {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   if (!m_pPalette) {
     BuildPalette();
   }
   m_pPalette[index] = color;
 }
-int CFX_DIBSource::FindPalette(FX_DWORD color) const {
+int CFX_DIBSource::FindPalette(uint32_t color) const {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   if (!m_pPalette) {
     if (IsCmykImage()) {
       if (GetBPP() == 1) {
         return ((uint8_t)color == 0xff) ? 0 : 1;
       }
       return 0xff - (uint8_t)color;
     }
     if (GetBPP() == 1) {
       return ((uint8_t)color == 0xff) ? 1 : 0;
     }
     return (uint8_t)color;
   }
   int palsize = (1 << GetBPP());
   for (int i = 0; i < palsize; i++)
     if (m_pPalette[i] == color) {
       return i;
     }
   return -1;
 }
-void CFX_DIBitmap::Clear(FX_DWORD color) {
+void CFX_DIBitmap::Clear(uint32_t color) {
   if (!m_pBuffer) {
     return;
   }
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       FXSYS_memset(m_pBuffer, (color & 0xff000000) ? 0xff : 0,
                    m_Pitch * m_Height);
       break;
     case FXDIB_1bppRgb: {
       int index = FindPalette(color);
@@ skipping 24 matching lines @@
         for (int row = 1; row < m_Height; row++) {
           FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
         }
       }
       break;
     }
     case FXDIB_Rgb32:
     case FXDIB_Argb: {
       color = IsCmykImage() ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
       for (int i = 0; i < m_Width; i++) {
-        ((FX_DWORD*)m_pBuffer)[i] = color;
+        ((uint32_t*)m_pBuffer)[i] = color;
       }
       for (int row = 1; row < m_Height; row++) {
         FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
       }
       break;
     }
     default:
       break;
   }
 }
@@ skipping 80 matching lines @@
     }
   } else {
     if (m_pPalette) {
       return FALSE;
     }
     if (m_bpp == 8) {
       dest_format = FXDIB_8bppMask;
     }
     uint8_t* dest_buf =
         m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
-    FX_DWORD* d_plt = NULL;
+    uint32_t* d_plt = NULL;
     if (!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height,
                        pSrcBitmap, src_left, src_top, d_plt, pIccTransform)) {
       return FALSE;
     }
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::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,
                                    void* pIccTransform) {
   if (!m_pBuffer) {
     return FALSE;
   }
   ASSERT(HasAlpha() && (m_bpp >= 24));
   ASSERT(pMask->IsAlphaMask());
   if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
     return FALSE;
   }
   GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(),
                  pMask->GetHeight(), src_left, src_top, NULL);
   if (width == 0 || height == 0) {
     return TRUE;
   }
   int src_bpp = pMask->GetBPP();
   int alpha;
-  FX_DWORD dst_color;
+  uint32_t dst_color;
   if (alpha_flag >> 8) {
     alpha = alpha_flag & 0xff;
     dst_color = FXCMYK_TODIB(color);
   } else {
     alpha = FXARGB_A(color);
     dst_color = FXARGB_TODIB(color);
   }
   uint8_t* color_p = (uint8_t*)&dst_color;
   if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
   } else {
     if (alpha_flag >> 8 && !IsCmykImage()) {
       AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
                          FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                          color_p[2], color_p[1], color_p[0]);
     } else if (!(alpha_flag >> 8) && IsCmykImage()) {
       return FALSE;
     }
   }
   if (!IsCmykImage()) {
     color_p[3] = (uint8_t)alpha;
   }
   if (GetFormat() == FXDIB_Argb) {
     for (int row = 0; row < height; row++) {
-      FX_DWORD* dest_pos =
-          (FX_DWORD*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
+      uint32_t* dest_pos =
+          (uint32_t*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
       const uint8_t* src_scan = pMask->GetScanline(src_top + row);
       if (src_bpp == 1) {
         for (int col = 0; col < width; col++) {
           int src_bitpos = src_left + col;
           if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
             *dest_pos = dst_color;
           } else {
             *dest_pos = 0;
           }
           dest_pos++;
@@ skipping 34 matching lines @@
         for (int col = 0; col < width; col++) {
           FXSYS_memcpy(dest_color_pos, color_p, comps);
           dest_color_pos += comps;
           *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
         }
       }
     }
   }
   return TRUE;
 }
-void CFX_DIBSource::CopyPalette(const FX_DWORD* pSrc, FX_DWORD size) {
+void CFX_DIBSource::CopyPalette(const uint32_t* pSrc, uint32_t size) {
   if (!pSrc || GetBPP() > 8) {
     FX_Free(m_pPalette);
     m_pPalette = NULL;
   } else {
-    FX_DWORD pal_size = 1 << GetBPP();
+    uint32_t pal_size = 1 << GetBPP();
     if (!m_pPalette) {
-      m_pPalette = FX_Alloc(FX_DWORD, pal_size);
+      m_pPalette = FX_Alloc(uint32_t, pal_size);
     }
     if (pal_size > size) {
       pal_size = size;
     }
-    FXSYS_memcpy(m_pPalette, pSrc, pal_size * sizeof(FX_DWORD));
+    FXSYS_memcpy(m_pPalette, pSrc, pal_size * sizeof(uint32_t));
   }
 }
-void CFX_DIBSource::GetPalette(FX_DWORD* pal, int alpha) const {
+void CFX_DIBSource::GetPalette(uint32_t* pal, int alpha) const {
   ASSERT(GetBPP() <= 8 && !IsCmykImage());
   if (GetBPP() == 1) {
     pal[0] =
         ((m_pPalette ? m_pPalette[0] : 0xff000000) & 0xffffff) | (alpha << 24);
     pal[1] =
         ((m_pPalette ? m_pPalette[1] : 0xffffffff) & 0xffffff) | (alpha << 24);
     return;
   }
   if (m_pPalette) {
     for (int i = 0; i < 256; i++) {
@@ skipping 469 matching lines @@
       } else {
         if (!ConvertFormat(FXDIB_Argb)) {
           return FALSE;
         }
         MultiplyAlpha(alpha);
       }
       break;
   }
   return TRUE;
 }
-FX_DWORD CFX_DIBitmap::GetPixel(int x, int y) const {
+uint32_t CFX_DIBitmap::GetPixel(int x, int y) const {
   if (!m_pBuffer) {
     return 0;
   }
   uint8_t* pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
     case FXDIB_1bppMask: {
       if ((*pos) & (1 << (7 - x % 8))) {
         return 0xff000000;
       }
       return 0;
@@ skipping 12 matching lines @@
     case FXDIB_Rgba:
     case FXDIB_Rgb32:
       return FXARGB_GETDIB(pos) | 0xff000000;
     case FXDIB_Argb:
       return FXARGB_GETDIB(pos);
     default:
       break;
   }
   return 0;
 }
-void CFX_DIBitmap::SetPixel(int x, int y, FX_DWORD color) {
+void CFX_DIBitmap::SetPixel(int x, int y, uint32_t color) {
   if (!m_pBuffer) {
     return;
   }
   if (x < 0 || x >= m_Width || y < 0 || y >= m_Height) {
     return;
   }
   uint8_t* pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       if (color >> 24) {
@@ skipping 62 matching lines @@
                                       FX_BOOL bFlipX,
                                       int clip_left,
                                       int clip_width) const {
   if (!m_pBuffer) {
     return;
   }
   int src_Bpp = m_bpp / 8;
   uint8_t* scanline = m_pBuffer + line * m_Pitch;
   if (src_Bpp == 0) {
     for (int i = 0; i < clip_width; i++) {
-      FX_DWORD dest_x = clip_left + i;
-      FX_DWORD src_x = dest_x * m_Width / dest_width;
+      uint32_t dest_x = clip_left + i;
+      uint32_t src_x = dest_x * m_Width / dest_width;
       if (bFlipX) {
         src_x = m_Width - src_x - 1;
       }
       src_x %= m_Width;
       dest_scan[i] = (scanline[src_x / 8] & (1 << (7 - src_x % 8))) ? 255 : 0;
     }
   } else if (src_Bpp == 1) {
     for (int i = 0; i < clip_width; i++) {
-      FX_DWORD dest_x = clip_left + i;
-      FX_DWORD src_x = dest_x * m_Width / dest_width;
+      uint32_t dest_x = clip_left + i;
+      uint32_t src_x = dest_x * m_Width / dest_width;
       if (bFlipX) {
         src_x = m_Width - src_x - 1;
       }
       src_x %= m_Width;
       int dest_pos = i;
       if (m_pPalette) {
         if (!IsCmykImage()) {
           dest_pos *= 3;
           FX_ARGB argb = m_pPalette[scanline[src_x]];
           dest_scan[dest_pos] = FXARGB_B(argb);
           dest_scan[dest_pos + 1] = FXARGB_G(argb);
           dest_scan[dest_pos + 2] = FXARGB_R(argb);
         } else {
           dest_pos *= 4;
           FX_CMYK cmyk = m_pPalette[scanline[src_x]];
           dest_scan[dest_pos] = FXSYS_GetCValue(cmyk);
           dest_scan[dest_pos + 1] = FXSYS_GetMValue(cmyk);
           dest_scan[dest_pos + 2] = FXSYS_GetYValue(cmyk);
           dest_scan[dest_pos + 3] = FXSYS_GetKValue(cmyk);
         }
       } else {
         dest_scan[dest_pos] = scanline[src_x];
       }
     }
   } else {
     for (int i = 0; i < clip_width; i++) {
-      FX_DWORD dest_x = clip_left + i;
-      FX_DWORD src_x =
+      uint32_t dest_x = clip_left + i;
+      uint32_t src_x =
           bFlipX ? (m_Width - dest_x * m_Width / dest_width - 1) * src_Bpp
                  : (dest_x * m_Width / dest_width) * src_Bpp;
       src_x %= m_Width * src_Bpp;
       int dest_pos = i * src_Bpp;
       for (int b = 0; b < src_Bpp; b++) {
         dest_scan[dest_pos + b] = scanline[src_x + b];
       }
     }
   }
 }
 
 // TODO(weili): Split this function into two for handling CMYK and RGB
 // colors separately.
-FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor,
-                                        FX_DWORD backcolor) {
+FX_BOOL CFX_DIBitmap::ConvertColorScale(uint32_t forecolor,
+                                        uint32_t backcolor) {
   ASSERT(!IsAlphaMask());
   if (!m_pBuffer || IsAlphaMask()) {
     return FALSE;
   }
   // Values used for CMYK colors.
   int fc = 0;
   int fm = 0;
   int fy = 0;
   int fk = 0;
   int bc = 0;
@@ skipping 112 matching lines @@
         int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
         *scanline++ = bb + (fb - bb) * gray / 255;
         *scanline++ = bg + (fg - bg) * gray / 255;
         *scanline = br + (fr - br) * gray / 255;
         scanline += gap;
       }
     }
   }
   return TRUE;
 }
-FX_BOOL CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette,
+FX_BOOL CFX_DIBitmap::DitherFS(const uint32_t* pPalette,
                                int pal_size,
                                const FX_RECT* pRect) {
   if (!m_pBuffer) {
     return FALSE;
   }
   if (m_bpp != 8 && m_pPalette && m_AlphaFlag != 0) {
     return FALSE;
   }
   if (m_Width < 4 && m_Height < 4) {
     return FALSE;
@@ skipping 106 matching lines @@
         for (int col = 0; col < m_Width; col++) {
           dest_scan[0] = src_scan[0];
           dest_scan[1] = src_scan[1];
           dest_scan[2] = src_scan[2];
           dest_scan -= 3;
           src_scan += 3;
         }
       } else {
         ASSERT(Bpp == 4);
         for (int col = 0; col < m_Width; col++) {
-          *(FX_DWORD*)dest_scan = *(FX_DWORD*)src_scan;
+          *(uint32_t*)dest_scan = *(uint32_t*)src_scan;
           dest_scan -= 4;
           src_scan += 4;
         }
       }
     }
   }
   if (m_pAlphaMask) {
     pDestBuffer = pFlipped->m_pAlphaMask->GetBuffer();
-    FX_DWORD dest_pitch = pFlipped->m_pAlphaMask->GetPitch();
+    uint32_t dest_pitch = pFlipped->m_pAlphaMask->GetPitch();
     for (int row = 0; row < m_Height; row++) {
       const uint8_t* src_scan = m_pAlphaMask->GetScanline(row);
       uint8_t* dest_scan =
           pDestBuffer + dest_pitch * (bYFlip ? (m_Height - row - 1) : row);
       if (!bXFlip) {
         FXSYS_memcpy(dest_scan, src_scan, dest_pitch);
         continue;
       }
       dest_scan += (m_Width - 1);
       for (int col = 0; col < m_Width; col++) {
@@ skipping 67 matching lines @@
   m_bRgbByteOrder = FALSE;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_ImageRenderer::~CFX_ImageRenderer() {
   delete m_pTransformer;
 }
 FX_BOOL CFX_ImageRenderer::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,
                                  int alpha_flag,
                                  void* pIccTransform,
                                  int blend_type) {
   m_Matrix = *pMatrix;
   CFX_FloatRect image_rect_f = m_Matrix.GetUnitRect();
   FX_RECT image_rect = image_rect_f.GetOutterRect();
   m_ClipBox = pClipRgn ? pClipRgn->GetBox() : FX_RECT(0, 0, pDevice->GetWidth(),
                                                       pDevice->GetHeight());
   m_ClipBox.Intersect(image_rect);
@@ skipping 130 matching lines @@
     FXSYS_memcpy(dest_buf, scanline, m_pBitmap->GetPitch());
   }
   if (dest_alpha_buf) {
     FXSYS_memcpy(dest_alpha_buf, scan_extra_alpha,
                  m_pBitmap->m_pAlphaMask->GetPitch());
   }
 }
 FX_BOOL CFX_BitmapStorer::SetInfo(int width,
                                   int height,
                                   FXDIB_Format src_format,
-                                  FX_DWORD* pSrcPalette) {
+                                  uint32_t* pSrcPalette) {
   m_pBitmap = new CFX_DIBitmap;
   if (!m_pBitmap->Create(width, height, src_format)) {
     delete m_pBitmap;
     m_pBitmap = NULL;
     return FALSE;
   }
   if (pSrcPalette) {
     m_pBitmap->CopyPalette(pSrcPalette);
   }
   return TRUE;
 }