Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_page/cpdf_image.cpp

 // Copyright 2016 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_page/include/cpdf_image.h"
 
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/include/cpdf_modulemgr.h"
@@ skipping 56 matching lines @@
   }
   m_pOC = pDict->GetDictBy("OC");
   m_bIsMask =
       !pDict->KeyExist("ColorSpace") || pDict->GetIntegerBy("ImageMask");
   m_bInterpolate = pDict->GetIntegerBy("Interpolate");
   m_Height = pDict->GetIntegerBy("Height");
   m_Width = pDict->GetIntegerBy("Width");
   return TRUE;
 }
 
-CPDF_Dictionary* CPDF_Image::InitJPEG(uint8_t* pData, FX_DWORD size) {
+CPDF_Dictionary* CPDF_Image::InitJPEG(uint8_t* pData, uint32_t size) {
   int32_t width;
   int32_t height;
   int32_t num_comps;
   int32_t bits;
   FX_BOOL color_trans;
   if (!CPDF_ModuleMgr::Get()->GetJpegModule()->LoadInfo(
           pData, size, width, height, num_comps, bits, color_trans)) {
     return NULL;
   }
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
@@ skipping 25 matching lines @@
   }
   m_bIsMask = FALSE;
   m_Width = width;
   m_Height = height;
   if (!m_pStream) {
     m_pStream = new CPDF_Stream(NULL, 0, NULL);
   }
   return pDict;
 }
 
-void CPDF_Image::SetJpegImage(uint8_t* pData, FX_DWORD size) {
+void CPDF_Image::SetJpegImage(uint8_t* pData, uint32_t size) {
   CPDF_Dictionary* pDict = InitJPEG(pData, size);
   if (!pDict) {
     return;
   }
   m_pStream->InitStream(pData, size, pDict);
 }
 
 void CPDF_Image::SetJpegImage(IFX_FileRead* pFile) {
-  FX_DWORD size = (FX_DWORD)pFile->GetSize();
+  uint32_t size = (uint32_t)pFile->GetSize();
   if (!size) {
     return;
   }
-  FX_DWORD dwEstimateSize = size;
+  uint32_t dwEstimateSize = size;
   if (dwEstimateSize > 8192) {
     dwEstimateSize = 8192;
   }
   uint8_t* pData = FX_Alloc(uint8_t, dwEstimateSize);
   pFile->ReadBlock(pData, 0, dwEstimateSize);
   CPDF_Dictionary* pDict = InitJPEG(pData, dwEstimateSize);
   FX_Free(pData);
   if (!pDict && size > dwEstimateSize) {
     pData = FX_Alloc(uint8_t, size);
     pFile->ReadBlock(pData, 0, size);
@@ skipping 67 matching lines @@
     int32_t iPalette = pBitmap->GetPaletteSize();
     if (iPalette > 0) {
       CPDF_Array* pCS = new CPDF_Array;
       m_pDocument->AddIndirectObject(pCS);
       pCS->AddName("Indexed");
       pCS->AddName("DeviceRGB");
       pCS->AddInteger(iPalette - 1);
       uint8_t* pColorTable = FX_Alloc2D(uint8_t, iPalette, 3);
       uint8_t* ptr = pColorTable;
       for (int32_t i = 0; i < iPalette; i++) {
-        FX_DWORD argb = pBitmap->GetPaletteArgb(i);
+        uint32_t argb = pBitmap->GetPaletteArgb(i);
         ptr[0] = (uint8_t)(argb >> 16);
         ptr[1] = (uint8_t)(argb >> 8);
         ptr[2] = (uint8_t)argb;
         ptr += 3;
       }
       CPDF_Stream* pCTS =
           new CPDF_Stream(pColorTable, iPalette * 3, new CPDF_Dictionary);
       m_pDocument->AddIndirectObject(pCTS);
       pCS->AddReference(m_pDocument, pCTS);
       pDict->SetAtReference("ColorSpace", m_pDocument, pCS);
@@ skipping 115 matching lines @@
   m_Width = BitmapWidth;
   m_Height = BitmapHeight;
   FX_Free(dest_buf);
 }
 
 void CPDF_Image::ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pBitmap) {
   pPage->GetRenderCache()->ResetBitmap(m_pStream, pBitmap);
 }
 
 CFX_DIBSource* CPDF_Image::LoadDIBSource(CFX_DIBSource** ppMask,
-                                         FX_DWORD* pMatteColor,
+                                         uint32_t* pMatteColor,
                                          FX_BOOL bStdCS,
-                                         FX_DWORD GroupFamily,
+                                         uint32_t GroupFamily,
                                          FX_BOOL bLoadMask) const {
   std::unique_ptr<CPDF_DIBSource> source(new CPDF_DIBSource);
   if (source->Load(m_pDocument, m_pStream,
                    reinterpret_cast<CPDF_DIBSource**>(ppMask), pMatteColor,
                    nullptr, nullptr, bStdCS, GroupFamily, bLoadMask)) {
     return source.release();
   }
   return nullptr;
 }
 
 CFX_DIBSource* CPDF_Image::DetachBitmap() {
   CFX_DIBSource* pBitmap = m_pDIBSource;
   m_pDIBSource = nullptr;
   return pBitmap;
 }
 
 CFX_DIBSource* CPDF_Image::DetachMask() {
   CFX_DIBSource* pBitmap = m_pMask;
   m_pMask = nullptr;
   return pBitmap;
 }
 
 FX_BOOL CPDF_Image::StartLoadDIBSource(CPDF_Dictionary* pFormResource,
                                        CPDF_Dictionary* pPageResource,
                                        FX_BOOL bStdCS,
-                                       FX_DWORD GroupFamily,
+                                       uint32_t GroupFamily,
                                        FX_BOOL bLoadMask) {
   std::unique_ptr<CPDF_DIBSource> source(new CPDF_DIBSource);
   int ret =
       source->StartLoadDIBSource(m_pDocument, m_pStream, TRUE, pFormResource,
                                  pPageResource, bStdCS, GroupFamily, bLoadMask);
   if (ret == 2) {
     m_pDIBSource = source.release();
     return TRUE;
   }
   if (!ret) {
@@ skipping 14 matching lines @@
   }
   if (!ret) {
     delete m_pDIBSource;
     m_pDIBSource = nullptr;
     return FALSE;
   }
   m_pMask = pSource->DetachMask();
   m_MatteColor = pSource->GetMatteColor();
   return FALSE;
 }