Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_render/fpdf_render_image.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/fpdfapi/fpdf_render/render_int.h"
 
 #include <utility>
 #include <vector>
@@ skipping 39 matching lines @@
   FX_BOOL bGroup = Transparency & PDFTRANS_GROUP;
   if (blend_mode == FXDIB_BLEND_NORMAL) {
     if (!pDIBitmap->IsAlphaMask()) {
       if (bitmap_alpha < 255) {
         pDIBitmap->MultiplyAlpha(bitmap_alpha);
       }
       if (m_pDevice->SetDIBits(pDIBitmap, left, top)) {
         return;
       }
     } else {
-      FX_DWORD fill_argb = m_Options.TranslateColor(mask_argb);
+      uint32_t fill_argb = m_Options.TranslateColor(mask_argb);
       if (bitmap_alpha < 255) {
         ((uint8_t*)&fill_argb)[3] =
             ((uint8_t*)&fill_argb)[3] * bitmap_alpha / 255;
       }
       if (m_pDevice->SetBitMask(pDIBitmap, left, top, fill_argb)) {
         return;
       }
     }
   }
   FX_BOOL bBackAlphaRequired = blend_mode && bIsolated && !m_bDropObjects;
@@ skipping 59 matching lines @@
                                pDIBitmap, 0, 0, blend_mode);
   } else {
     pBackdrop->CompositeMask(left - back_left, top - back_top,
                              pDIBitmap->GetWidth(), pDIBitmap->GetHeight(),
                              pDIBitmap, mask_argb, 0, 0, blend_mode);
   }
 
   std::unique_ptr<CFX_DIBitmap> pBackdrop1(new CFX_DIBitmap);
   pBackdrop1->Create(pBackdrop->GetWidth(), pBackdrop->GetHeight(),
                      FXDIB_Rgb32);
-  pBackdrop1->Clear((FX_DWORD)-1);
+  pBackdrop1->Clear((uint32_t)-1);
   pBackdrop1->CompositeBitmap(0, 0, pBackdrop->GetWidth(),
                               pBackdrop->GetHeight(), pBackdrop.get(), 0, 0);
   pBackdrop = std::move(pBackdrop1);
   m_pDevice->SetDIBits(pBackdrop.get(), back_left, back_top);
 }
 
 CPDF_TransferFunc::CPDF_TransferFunc(CPDF_Document* pDoc) : m_pPDFDoc(pDoc) {}
 
 FX_COLORREF CPDF_TransferFunc::TranslateColor(FX_COLORREF rgb) const {
   return FXSYS_RGB(m_Samples[FXSYS_GetRValue(rgb)],
@@ skipping 63 matching lines @@
     }
     case FXDIB_8bppRgb: {
       FX_ARGB* pPal = m_pSrc->GetPalette();
       for (i = 0; i < m_Width; i++) {
         if (pPal) {
           FX_ARGB src_argb = pPal[*src_buf];
           *dest_buf++ = m_RampB[FXARGB_R(src_argb)];
           *dest_buf++ = m_RampG[FXARGB_G(src_argb)];
           *dest_buf++ = m_RampR[FXARGB_B(src_argb)];
         } else {
-          FX_DWORD src_byte = *src_buf;
+          uint32_t src_byte = *src_buf;
           *dest_buf++ = m_RampB[src_byte];
           *dest_buf++ = m_RampG[src_byte];
           *dest_buf++ = m_RampR[src_byte];
         }
         src_buf++;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
         dest_buf++;
 #endif
       }
       break;
@@ skipping 175 matching lines @@
     CPDF_Object* pFilters =
         m_pImageObject->m_pImage->GetStream()->GetDict()->GetElementValue(
             "Filter");
     if (pFilters) {
       if (pFilters->IsName()) {
         CFX_ByteStringC bsDecodeType = pFilters->GetConstString();
         if (bsDecodeType == "DCTDecode" || bsDecodeType == "JPXDecode") {
           m_Flags |= FXRENDER_IMAGE_LOSSY;
         }
       } else if (CPDF_Array* pArray = pFilters->AsArray()) {
-        for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
+        for (uint32_t i = 0; i < pArray->GetCount(); i++) {
           CFX_ByteStringC bsDecodeType = pArray->GetConstStringAt(i);
           if (bsDecodeType == "DCTDecode" || bsDecodeType == "JPXDecode") {
             m_Flags |= FXRENDER_IMAGE_LOSSY;
             break;
           }
         }
       }
     }
   }
   if (m_pRenderStatus->m_Options.m_Flags & RENDER_NOIMAGESMOOTH) {
@@ skipping 56 matching lines @@
   if (StartLoadDIBSource()) {
     return TRUE;
   }
   return StartRenderDIBSource();
 }
 FX_BOOL CPDF_ImageRenderer::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) {
   m_pRenderStatus = pStatus;
   m_pDIBSource = pDIBSource;
   m_FillArgb = bitmap_argb;
   m_BitmapAlpha = bitmap_alpha;
   m_ImageMatrix = *pImage2Device;
   m_Flags = flags;
   m_bStdCS = bStdCS;
   m_BlendType = blendType;
@@ skipping 273 matching lines @@
                                        dest_rect.top, m_FillArgb, m_BitmapAlpha,
                                        m_BlendType, FALSE);
   }
   return FALSE;
 }
 FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha() {
   if (m_pDIBSource->IsOpaqueImage()) {
     CFX_PathData path;
     path.AppendRect(0, 0, 1, 1);
     path.Transform(&m_ImageMatrix);
-    FX_DWORD fill_color =
+    uint32_t fill_color =
         ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha);
     m_pRenderStatus->m_pDevice->DrawPath(&path, NULL, NULL, fill_color, 0,
                                          FXFILL_WINDING);
   } else {
     const CFX_DIBSource* pAlphaMask = m_pDIBSource->IsAlphaMask()
                                           ? m_pDIBSource
                                           : m_pDIBSource->GetAlphaMask();
     if (FXSYS_fabs(m_ImageMatrix.b) >= 0.5f ||
         FXSYS_fabs(m_ImageMatrix.c) >= 0.5f) {
       int left, top;
@@ skipping 59 matching lines @@
       return TRUE;
     }
     if (StartRenderDIBSource()) {
       return Continue(pPause);
     }
   }
   return FALSE;
 }
 ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     int nComps,
     int bpc,
     const CPDF_Dictionary* pParams);
 CFX_DIBitmap* CPDF_RenderStatus::LoadSMask(CPDF_Dictionary* pSMaskDict,
                                            FX_RECT* pClipRect,
                                            const CFX_Matrix* pMatrix) {
   if (!pSMaskDict) {
     return NULL;
@@ skipping 36 matching lines @@
     FX_ARGB back_color = 0xff000000;
     if (pBC) {
       CPDF_Dictionary* pDict = pGroup->GetDict();
       if (pDict && pDict->GetDictBy("Group"))
         pCSObj = pDict->GetDictBy("Group")->GetElementValue("CS");
       else
         pCSObj = NULL;
       pCS = m_pContext->GetDocument()->LoadColorSpace(pCSObj);
       if (pCS) {
         FX_FLOAT R, G, B;
-        FX_DWORD comps = 8;
+        uint32_t comps = 8;
         if (pCS->CountComponents() > comps) {
           comps = pCS->CountComponents();
         }
         CFX_FixedBufGrow<FX_FLOAT, 8> float_array(comps);
         FX_FLOAT* pFloats = float_array;
         FX_SAFE_DWORD num_floats = comps;
         num_floats *= sizeof(FX_FLOAT);
         if (!num_floats.IsValid()) {
           return NULL;
         }
@@ skipping 58 matching lines @@
   } else if (pFunc) {
     int size = dest_pitch * height;
     for (int i = 0; i < size; i++) {
       dest_buf[i] = transfers[src_buf[i]];
     }
   } else {
     FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height);
   }
   return pMask.release();
 }