Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_render/fpdf_render_loadimage.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 <algorithm>
 #include <memory>
@@ skipping 20 matching lines @@
   unsigned int byte = pData[bitpos / 8];
   if (nbits == 8) {
     return byte;
   } else if (nbits == 16) {
     return byte * 256 + pData[bitpos / 8 + 1];
   }
 
   return (byte >> (8 - nbits - (bitpos % 8))) & ((1 << nbits) - 1);
 }
 
-FX_SAFE_DWORD CalculatePitch8(FX_DWORD bpc, FX_DWORD components, int width) {
+FX_SAFE_DWORD CalculatePitch8(uint32_t bpc, uint32_t components, int width) {
   FX_SAFE_DWORD pitch = bpc;
   pitch *= components;
   pitch *= width;
   pitch += 7;
   pitch /= 8;
   return pitch;
 }
 
 FX_SAFE_DWORD CalculatePitch32(int bpp, int width) {
   FX_SAFE_DWORD pitch = bpp;
@@ skipping 88 matching lines @@
 
 void CPDF_DIBSource::ReleaseBitmap(CFX_DIBitmap* pBitmap) const {
   if (pBitmap && pBitmap != m_pCachedBitmap.get()) {
     delete pBitmap;
   }
 }
 
 FX_BOOL CPDF_DIBSource::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,
-                             FX_DWORD GroupFamily,
+                             uint32_t GroupFamily,
                              FX_BOOL bLoadMask) {
   if (!pStream) {
     return FALSE;
   }
   m_pDocument = pDoc;
   m_pDict = pStream->GetDict();
   if (!m_pDict) {
     return FALSE;
   }
   m_pStream = pStream;
@@ skipping 102 matching lines @@
   m_Pitch = pitch.ValueOrDie();
   return 1;
 }
 
 int CPDF_DIBSource::StartLoadDIBSource(CPDF_Document* pDoc,
                                        const CPDF_Stream* pStream,
                                        FX_BOOL bHasMask,
                                        CPDF_Dictionary* pFormResources,
                                        CPDF_Dictionary* pPageResources,
                                        FX_BOOL bStdCS,
-                                       FX_DWORD GroupFamily,
+                                       uint32_t GroupFamily,
                                        FX_BOOL bLoadMask) {
   if (!pStream) {
     return 0;
   }
   m_pDocument = pDoc;
   m_pDict = pStream->GetDict();
   m_pStream = pStream;
   m_bStdCS = bStdCS;
   m_bHasMask = bHasMask;
   m_Width = m_pDict->GetIntegerBy("Width");
@@ skipping 185 matching lines @@
 
 DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode,
                                                      FX_BOOL& bColorKey) {
   if (!m_pColorSpace) {
     return nullptr;
   }
   DIB_COMP_DATA* pCompData = FX_Alloc(DIB_COMP_DATA, m_nComponents);
   int max_data = (1 << m_bpc) - 1;
   CPDF_Array* pDecode = m_pDict->GetArrayBy("Decode");
   if (pDecode) {
-    for (FX_DWORD i = 0; i < m_nComponents; i++) {
+    for (uint32_t i = 0; i < m_nComponents; i++) {
       pCompData[i].m_DecodeMin = pDecode->GetNumberAt(i * 2);
       FX_FLOAT max = pDecode->GetNumberAt(i * 2 + 1);
       pCompData[i].m_DecodeStep = (max - pCompData[i].m_DecodeMin) / max_data;
       FX_FLOAT def_value;
       FX_FLOAT def_min;
       FX_FLOAT def_max;
       m_pColorSpace->GetDefaultValue(i, def_value, def_min, def_max);
       if (m_Family == PDFCS_INDEXED) {
         def_max = max_data;
       }
       if (def_min != pCompData[i].m_DecodeMin || def_max != max) {
         bDefaultDecode = FALSE;
       }
     }
   } else {
-    for (FX_DWORD i = 0; i < m_nComponents; i++) {
+    for (uint32_t i = 0; i < m_nComponents; i++) {
       FX_FLOAT def_value;
       m_pColorSpace->GetDefaultValue(i, def_value, pCompData[i].m_DecodeMin,
                                      pCompData[i].m_DecodeStep);
       if (m_Family == PDFCS_INDEXED) {
         pCompData[i].m_DecodeStep = max_data;
       }
       pCompData[i].m_DecodeStep =
           (pCompData[i].m_DecodeStep - pCompData[i].m_DecodeMin) / max_data;
     }
   }
   if (!m_pDict->KeyExist("SMask")) {
     CPDF_Object* pMask = m_pDict->GetElementValue("Mask");
     if (!pMask) {
       return pCompData;
     }
     if (CPDF_Array* pArray = pMask->AsArray()) {
       if (pArray->GetCount() >= m_nComponents * 2) {
-        for (FX_DWORD i = 0; i < m_nComponents; i++) {
+        for (uint32_t i = 0; i < m_nComponents; i++) {
           int min_num = pArray->GetIntegerAt(i * 2);
           int max_num = pArray->GetIntegerAt(i * 2 + 1);
           pCompData[i].m_ColorKeyMin = std::max(min_num, 0);
           pCompData[i].m_ColorKeyMax = std::min(max_num, max_data);
         }
       }
       bColorKey = TRUE;
     }
   }
   return pCompData;
 }
 
 ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     const CPDF_Dictionary* pParams);
 
 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);
 
 int CPDF_DIBSource::CreateDecoder() {
   const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
   if (decoder.IsEmpty()) {
     return 1;
   }
   if (m_bDoBpcCheck && m_bpc == 0) {
     return 0;
   }
   const uint8_t* src_data = m_pStreamAcc->GetData();
-  FX_DWORD src_size = m_pStreamAcc->GetSize();
+  uint32_t src_size = m_pStreamAcc->GetSize();
   const CPDF_Dictionary* pParams = m_pStreamAcc->GetImageParam();
   if (decoder == "CCITTFaxDecode") {
     m_pDecoder.reset(FPDFAPI_CreateFaxDecoder(src_data, src_size, m_Width,
                                               m_Height, pParams));
   } else if (decoder == "DCTDecode") {
     m_pDecoder.reset(CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
         src_data, src_size, m_Width, m_Height, m_nComponents,
         pParams ? pParams->GetIntegerBy("ColorTransform", 1) : 1));
     if (!m_pDecoder) {
       FX_BOOL bTransform = FALSE;
       int comps;
       int bpc;
       ICodec_JpegModule* pJpegModule = CPDF_ModuleMgr::Get()->GetJpegModule();
       if (pJpegModule->LoadInfo(src_data, src_size, m_Width, m_Height, comps,
                                 bpc, bTransform)) {
-        if (m_nComponents != static_cast<FX_DWORD>(comps)) {
+        if (m_nComponents != static_cast<uint32_t>(comps)) {
           FX_Free(m_pCompData);
-          m_nComponents = static_cast<FX_DWORD>(comps);
+          m_nComponents = static_cast<uint32_t>(comps);
           if (m_Family == PDFCS_LAB && m_nComponents != 3) {
             m_pCompData = nullptr;
             return 0;
           }
           m_pCompData = GetDecodeAndMaskArray(m_bDefaultDecode, m_bColorKey);
           if (!m_pCompData) {
             return 0;
           }
         }
         m_bpc = bpc;
@@ skipping 47 matching lines @@
   ICodec_JpxModule* pJpxModule = CPDF_ModuleMgr::Get()->GetJpxModule();
   if (!pJpxModule)
     return;
 
   std::unique_ptr<JpxBitMapContext> context(new JpxBitMapContext(pJpxModule));
   context->set_decoder(pJpxModule->CreateDecoder(
       m_pStreamAcc->GetData(), m_pStreamAcc->GetSize(), m_pColorSpace));
   if (!context->decoder())
     return;
 
-  FX_DWORD width = 0;
-  FX_DWORD height = 0;
-  FX_DWORD components = 0;
+  uint32_t width = 0;
+  uint32_t height = 0;
+  uint32_t components = 0;
   pJpxModule->GetImageInfo(context->decoder(), &width, &height, &components);
   if (static_cast<int>(width) < m_Width || static_cast<int>(height) < m_Height)
     return;
 
   FX_BOOL bSwapRGB = FALSE;
   if (m_pColorSpace) {
     if (components != m_pColorSpace->CountComponents())
       return;
 
     if (m_pColorSpace == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB)) {
@@ skipping 21 matching lines @@
     format = FXDIB_Rgb;
   }
 
   m_pCachedBitmap.reset(new CFX_DIBitmap);
   if (!m_pCachedBitmap->Create(width, height, format)) {
     m_pCachedBitmap.reset();
     return;
   }
   m_pCachedBitmap->Clear(0xFFFFFFFF);
   std::vector<uint8_t> output_offsets(components);
-  for (FX_DWORD i = 0; i < components; ++i)
+  for (uint32_t i = 0; i < components; ++i)
     output_offsets[i] = i;
   if (bSwapRGB) {
     output_offsets[0] = 2;
     output_offsets[2] = 0;
   }
   if (!pJpxModule->Decode(context->decoder(), m_pCachedBitmap->GetBuffer(),
                           m_pCachedBitmap->GetPitch(), output_offsets)) {
     m_pCachedBitmap.reset();
     return;
   }
   if (m_pColorSpace && m_pColorSpace->GetFamily() == PDFCS_INDEXED &&
       m_bpc < 8) {
     int scale = 8 - m_bpc;
-    for (FX_DWORD row = 0; row < height; ++row) {
+    for (uint32_t row = 0; row < height; ++row) {
       uint8_t* scanline =
           const_cast<uint8_t*>(m_pCachedBitmap->GetScanline(row));
-      for (FX_DWORD col = 0; col < width; ++col) {
+      for (uint32_t col = 0; col < width; ++col) {
         *scanline = (*scanline) >> scale;
         ++scanline;
       }
     }
   }
   m_bpc = 8;
 }
 
-CPDF_DIBSource* CPDF_DIBSource::LoadMask(FX_DWORD& MatteColor) {
+CPDF_DIBSource* CPDF_DIBSource::LoadMask(uint32_t& MatteColor) {
   MatteColor = 0xFFFFFFFF;
   CPDF_Stream* pSoftMask = m_pDict->GetStreamBy("SMask");
   if (pSoftMask) {
     CPDF_Array* pMatte = pSoftMask->GetDict()->GetArrayBy("Matte");
     if (pMatte && m_pColorSpace &&
         m_pColorSpace->CountComponents() <= m_nComponents) {
       std::vector<FX_FLOAT> colors(m_nComponents);
-      for (FX_DWORD i = 0; i < m_nComponents; i++) {
+      for (uint32_t i = 0; i < m_nComponents; i++) {
         colors[i] = pMatte->GetFloatAt(i);
       }
       FX_FLOAT R, G, B;
       m_pColorSpace->GetRGB(colors.data(), R, G, B);
       MatteColor = FXARGB_MAKE(0, FXSYS_round(R * 255), FXSYS_round(G * 255),
                                FXSYS_round(B * 255));
     }
     return LoadMaskDIB(pSoftMask);
   }
 
   if (CPDF_Stream* pStream = ToStream(m_pDict->GetElementValue("Mask")))
     return LoadMaskDIB(pStream);
 
   return nullptr;
 }
 
 int CPDF_DIBSource::StratLoadMask() {
   m_MatteColor = 0XFFFFFFFF;
   m_pMaskStream = m_pDict->GetStreamBy("SMask");
   if (m_pMaskStream) {
     CPDF_Array* pMatte = m_pMaskStream->GetDict()->GetArrayBy("Matte");
     if (pMatte && m_pColorSpace &&
         m_pColorSpace->CountComponents() <= m_nComponents) {
       FX_FLOAT R, G, B;
       std::vector<FX_FLOAT> colors(m_nComponents);
-      for (FX_DWORD i = 0; i < m_nComponents; i++) {
+      for (uint32_t i = 0; i < m_nComponents; i++) {
         colors[i] = pMatte->GetFloatAt(i);
       }
       m_pColorSpace->GetRGB(colors.data(), R, G, B);
       m_MatteColor = FXARGB_MAKE(0, FXSYS_round(R * 255), FXSYS_round(G * 255),
                                  FXSYS_round(B * 255));
     }
     return StartLoadMaskDIB();
   }
 
   m_pMaskStream = ToStream(m_pDict->GetElementValue("Mask"));
@@ skipping 90 matching lines @@
     return;
   }
   if (m_pColorSpace == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY) &&
       m_bpc == 8 && m_bDefaultDecode) {
   } else {
     int palette_count = 1 << (m_bpc * m_nComponents);
     CFX_FixedBufGrow<FX_FLOAT, 16> color_values(m_nComponents);
     FX_FLOAT* color_value = color_values;
     for (int i = 0; i < palette_count; i++) {
       int color_data = i;
-      for (FX_DWORD j = 0; j < m_nComponents; j++) {
+      for (uint32_t j = 0; j < m_nComponents; j++) {
         int encoded_component = color_data % (1 << m_bpc);
         color_data /= 1 << m_bpc;
         color_value[j] = m_pCompData[j].m_DecodeMin +
                          m_pCompData[j].m_DecodeStep * encoded_component;
       }
       FX_FLOAT R = 0, G = 0, B = 0;
       if (m_nComponents == 1 && m_Family == PDFCS_ICCBASED &&
           m_pColorSpace->CountComponents() > 1) {
         int nComponents = m_pColorSpace->CountComponents();
         std::vector<FX_FLOAT> temp_buf(nComponents);
@@ skipping 98 matching lines @@
       return;
     }
   }
   CFX_FixedBufGrow<FX_FLOAT, 16> color_values1(m_nComponents);
   FX_FLOAT* color_values = color_values1;
   FX_FLOAT R = 0.0f, G = 0.0f, B = 0.0f;
   if (m_bpc == 8) {
     uint64_t src_byte_pos = 0;
     size_t dest_byte_pos = 0;
     for (int column = 0; column < m_Width; column++) {
-      for (FX_DWORD color = 0; color < m_nComponents; color++) {
+      for (uint32_t color = 0; color < m_nComponents; color++) {
         uint8_t data = src_scan[src_byte_pos++];
         color_values[color] = m_pCompData[color].m_DecodeMin +
                               m_pCompData[color].m_DecodeStep * data;
       }
       if (TransMask()) {
         FX_FLOAT k = 1.0f - color_values[3];
         R = (1.0f - color_values[0]) * k;
         G = (1.0f - color_values[1]) * k;
         B = (1.0f - color_values[2]) * k;
       } else {
         m_pColorSpace->GetRGB(color_values, R, G, B);
       }
       R = ClampValue(R, 1.0f);
       G = ClampValue(G, 1.0f);
       B = ClampValue(B, 1.0f);
       dest_scan[dest_byte_pos] = static_cast<uint8_t>(B * 255);
       dest_scan[dest_byte_pos + 1] = static_cast<uint8_t>(G * 255);
       dest_scan[dest_byte_pos + 2] = static_cast<uint8_t>(R * 255);
       dest_byte_pos += 3;
     }
   } else {
     uint64_t src_bit_pos = 0;
     size_t dest_byte_pos = 0;
     for (int column = 0; column < m_Width; column++) {
-      for (FX_DWORD color = 0; color < m_nComponents; color++) {
+      for (uint32_t color = 0; color < m_nComponents; color++) {
         unsigned int data = GetBits8(src_scan, src_bit_pos, m_bpc);
         color_values[color] = m_pCompData[color].m_DecodeMin +
                               m_pCompData[color].m_DecodeStep * data;
         src_bit_pos += m_bpc;
       }
       if (TransMask()) {
         FX_FLOAT k = 1.0f - color_values[3];
         R = (1.0f - color_values[0]) * k;
         G = (1.0f - color_values[1]) * k;
         B = (1.0f - color_values[2]) * k;
@@ skipping 15 matching lines @@
   return m_pCachedBitmap ? m_pCachedBitmap->GetBuffer() : nullptr;
 }
 
 const uint8_t* CPDF_DIBSource::GetScanline(int line) const {
   if (m_bpc == 0) {
     return nullptr;
   }
   FX_SAFE_DWORD src_pitch = CalculatePitch8(m_bpc, m_nComponents, m_Width);
   if (!src_pitch.IsValid())
     return nullptr;
-  FX_DWORD src_pitch_value = src_pitch.ValueOrDie();
+  uint32_t src_pitch_value = src_pitch.ValueOrDie();
   const uint8_t* pSrcLine = nullptr;
   if (m_pCachedBitmap && src_pitch_value <= m_pCachedBitmap->GetPitch()) {
     if (line >= m_pCachedBitmap->GetHeight()) {
       line = m_pCachedBitmap->GetHeight() - 1;
     }
     pSrcLine = m_pCachedBitmap->GetScanline(line);
   } else if (m_pDecoder) {
     pSrcLine = m_pDecoder->GetScanline(line);
   } else {
     if (m_pStreamAcc->GetSize() >= (line + 1) * src_pitch_value) {
       pSrcLine = m_pStreamAcc->GetData() + line * src_pitch_value;
     }
   }
   if (!pSrcLine) {
     uint8_t* pLineBuf = m_pMaskedLine ? m_pMaskedLine : m_pLineBuf;
     FXSYS_memset(pLineBuf, 0xFF, m_Pitch);
     return pLineBuf;
   }
   if (m_bpc * m_nComponents == 1) {
     if (m_bImageMask && m_bDefaultDecode) {
-      for (FX_DWORD i = 0; i < src_pitch_value; i++) {
+      for (uint32_t i = 0; i < src_pitch_value; i++) {
         m_pLineBuf[i] = ~pSrcLine[i];
       }
     } else if (m_bColorKey) {
-      FX_DWORD reset_argb, set_argb;
+      uint32_t reset_argb, set_argb;
       reset_argb = m_pPalette ? m_pPalette[0] : 0xFF000000;
       set_argb = m_pPalette ? m_pPalette[1] : 0xFFFFFFFF;
       if (m_pCompData[0].m_ColorKeyMin == 0) {
         reset_argb = 0;
       }
       if (m_pCompData[0].m_ColorKeyMax == 1) {
         set_argb = 0;
       }
       set_argb = FXARGB_TODIB(set_argb);
       reset_argb = FXARGB_TODIB(reset_argb);
-      FX_DWORD* dest_scan = reinterpret_cast<FX_DWORD*>(m_pMaskedLine);
+      uint32_t* dest_scan = reinterpret_cast<uint32_t*>(m_pMaskedLine);
       for (int col = 0; col < m_Width; col++) {
         if (pSrcLine[col / 8] & (1 << (7 - col % 8))) {
           *dest_scan = set_argb;
         } else {
           *dest_scan = reset_argb;
         }
         dest_scan++;
       }
       return m_pMaskedLine;
     } else {
       FXSYS_memcpy(m_pLineBuf, pSrcLine, src_pitch_value);
     }
     return m_pLineBuf;
   }
   if (m_bpc * m_nComponents <= 8) {
     if (m_bpc == 8) {
       FXSYS_memcpy(m_pLineBuf, pSrcLine, src_pitch_value);
     } else {
       uint64_t src_bit_pos = 0;
       for (int col = 0; col < m_Width; col++) {
         unsigned int color_index = 0;
-        for (FX_DWORD color = 0; color < m_nComponents; color++) {
+        for (uint32_t color = 0; color < m_nComponents; color++) {
           unsigned int data = GetBits8(pSrcLine, src_bit_pos, m_bpc);
           color_index |= data << (color * m_bpc);
           src_bit_pos += m_bpc;
         }
         m_pLineBuf[col] = color_index;
       }
     }
     if (m_bColorKey) {
       uint8_t* pDestPixel = m_pMaskedLine;
       const uint8_t* pSrcPixel = m_pLineBuf;
@@ skipping 63 matching lines @@
                                         int dest_bpp,
                                         int dest_width,
                                         FX_BOOL bFlipX,
                                         int clip_left,
                                         int clip_width) const {
   if (line < 0 || !dest_scan || dest_bpp <= 0 || dest_width <= 0 ||
       clip_left < 0 || clip_width <= 0) {
     return;
   }
 
-  FX_DWORD src_width = m_Width;
+  uint32_t src_width = m_Width;
   FX_SAFE_DWORD pitch = CalculatePitch8(m_bpc, m_nComponents, m_Width);
   if (!pitch.IsValid())
     return;
 
   const uint8_t* pSrcLine = nullptr;
   if (m_pCachedBitmap) {
     pSrcLine = m_pCachedBitmap->GetScanline(line);
   } else if (m_pDecoder) {
     pSrcLine = m_pDecoder->GetScanline(line);
   } else {
-    FX_DWORD src_pitch = pitch.ValueOrDie();
+    uint32_t src_pitch = pitch.ValueOrDie();
     pitch *= (line + 1);
     if (!pitch.IsValid()) {
       return;
     }
 
     if (m_pStreamAcc->GetSize() >= pitch.ValueOrDie()) {
       pSrcLine = m_pStreamAcc->GetData() + line * src_pitch;
     }
   }
   int orig_Bpp = m_bpc * m_nComponents / 8;
@@ skipping 17 matching lines @@
     DownSampleScanline8Bit(orig_Bpp, dest_Bpp, src_width, pSrcLine, dest_scan,
                            dest_width, bFlipX, clip_left, clip_width);
   } else {
     DownSampleScanline32Bit(orig_Bpp, dest_Bpp, src_width, pSrcLine, dest_scan,
                             dest_width, bFlipX, clip_left, clip_width);
   }
 }
 
 void CPDF_DIBSource::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 {
-  FX_DWORD set_argb = (FX_DWORD)-1;
-  FX_DWORD reset_argb = 0;
+  uint32_t set_argb = (uint32_t)-1;
+  uint32_t reset_argb = 0;
   if (m_bImageMask) {
     if (m_bDefaultDecode) {
       set_argb = 0;
-      reset_argb = (FX_DWORD)-1;
+      reset_argb = (uint32_t)-1;
     }
   } else if (m_bColorKey) {
     reset_argb = m_pPalette ? m_pPalette[0] : 0xFF000000;
     set_argb = m_pPalette ? m_pPalette[1] : 0xFFFFFFFF;
     if (m_pCompData[0].m_ColorKeyMin == 0) {
       reset_argb = 0;
     }
     if (m_pCompData[0].m_ColorKeyMax == 1) {
       set_argb = 0;
     }
     set_argb = FXARGB_TODIB(set_argb);
     reset_argb = FXARGB_TODIB(reset_argb);
-    FX_DWORD* dest_scan_dword = reinterpret_cast<FX_DWORD*>(dest_scan);
+    uint32_t* dest_scan_dword = reinterpret_cast<uint32_t*>(dest_scan);
     for (int i = 0; i < clip_width; i++) {
-      FX_DWORD src_x = (clip_left + i) * src_width / dest_width;
+      uint32_t src_x = (clip_left + i) * src_width / dest_width;
       if (bFlipX) {
         src_x = src_width - src_x - 1;
       }
       src_x %= src_width;
       if (pSrcLine[src_x / 8] & (1 << (7 - src_x % 8))) {
         dest_scan_dword[i] = set_argb;
       } else {
         dest_scan_dword[i] = reset_argb;
       }
     }
     return;
   } else {
     if (dest_Bpp == 1) {
     } else if (m_pPalette) {
       reset_argb = m_pPalette[0];
       set_argb = m_pPalette[1];
     }
   }
   for (int i = 0; i < clip_width; i++) {
-    FX_DWORD src_x = (clip_left + i) * src_width / dest_width;
+    uint32_t src_x = (clip_left + i) * src_width / dest_width;
     if (bFlipX) {
       src_x = src_width - src_x - 1;
     }
     src_x %= src_width;
     int dest_pos = i * dest_Bpp;
     if (pSrcLine[src_x / 8] & (1 << (7 - src_x % 8))) {
       if (dest_Bpp == 1) {
         dest_scan[dest_pos] = static_cast<uint8_t>(set_argb);
       } else if (dest_Bpp == 3) {
         dest_scan[dest_pos] = FXARGB_B(set_argb);
         dest_scan[dest_pos + 1] = FXARGB_G(set_argb);
         dest_scan[dest_pos + 2] = FXARGB_R(set_argb);
       } else {
-        *reinterpret_cast<FX_DWORD*>(dest_scan + dest_pos) = set_argb;
+        *reinterpret_cast<uint32_t*>(dest_scan + dest_pos) = set_argb;
       }
     } else {
       if (dest_Bpp == 1) {
         dest_scan[dest_pos] = static_cast<uint8_t>(reset_argb);
       } else if (dest_Bpp == 3) {
         dest_scan[dest_pos] = FXARGB_B(reset_argb);
         dest_scan[dest_pos + 1] = FXARGB_G(reset_argb);
         dest_scan[dest_pos + 2] = FXARGB_R(reset_argb);
       } else {
-        *reinterpret_cast<FX_DWORD*>(dest_scan + dest_pos) = reset_argb;
+        *reinterpret_cast<uint32_t*>(dest_scan + dest_pos) = reset_argb;
       }
     }
   }
 }
 
 void CPDF_DIBSource::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 {
   if (m_bpc < 8) {
     uint64_t src_bit_pos = 0;
-    for (FX_DWORD col = 0; col < src_width; col++) {
+    for (uint32_t col = 0; col < src_width; col++) {
       unsigned int color_index = 0;
-      for (FX_DWORD color = 0; color < m_nComponents; color++) {
+      for (uint32_t color = 0; color < m_nComponents; color++) {
         unsigned int data = GetBits8(pSrcLine, src_bit_pos, m_bpc);
         color_index |= data << (color * m_bpc);
         src_bit_pos += m_bpc;
       }
       m_pLineBuf[col] = color_index;
     }
     pSrcLine = m_pLineBuf;
   }
   if (m_bColorKey) {
     for (int i = 0; i < clip_width; i++) {
-      FX_DWORD src_x = (clip_left + i) * src_width / dest_width;
+      uint32_t src_x = (clip_left + i) * src_width / dest_width;
       if (bFlipX) {
         src_x = src_width - src_x - 1;
       }
       src_x %= src_width;
       uint8_t* pDestPixel = dest_scan + i * 4;
       uint8_t index = pSrcLine[src_x];
       if (m_pPalette) {
         *pDestPixel++ = FXARGB_B(m_pPalette[index]);
         *pDestPixel++ = FXARGB_G(m_pPalette[index]);
         *pDestPixel++ = FXARGB_R(m_pPalette[index]);
       } else {
         *pDestPixel++ = index;
         *pDestPixel++ = index;
         *pDestPixel++ = index;
       }
       *pDestPixel = (index < m_pCompData[0].m_ColorKeyMin ||
                      index > m_pCompData[0].m_ColorKeyMax)
                         ? 0xFF
                         : 0;
     }
     return;
   }
   for (int i = 0; i < clip_width; i++) {
-    FX_DWORD src_x = (clip_left + i) * src_width / dest_width;
+    uint32_t src_x = (clip_left + i) * src_width / dest_width;
     if (bFlipX) {
       src_x = src_width - src_x - 1;
     }
     src_x %= src_width;
     uint8_t index = pSrcLine[src_x];
     if (dest_Bpp == 1) {
       dest_scan[i] = index;
     } else {
       int dest_pos = i * dest_Bpp;
       FX_ARGB argb = m_pPalette[index];
       dest_scan[dest_pos] = FXARGB_B(argb);
       dest_scan[dest_pos + 1] = FXARGB_G(argb);
       dest_scan[dest_pos + 2] = FXARGB_R(argb);
     }
   }
 }
 
 void CPDF_DIBSource::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 {
   // last_src_x used to store the last seen src_x position which should be
   // in [0, src_width). Set the initial value to be an invalid src_x value.
-  FX_DWORD last_src_x = src_width;
+  uint32_t last_src_x = src_width;
   FX_ARGB last_argb = FXARGB_MAKE(0xFF, 0xFF, 0xFF, 0xFF);
   FX_FLOAT unit_To8Bpc = 255.0f / ((1 << m_bpc) - 1);
   for (int i = 0; i < clip_width; i++) {
     int dest_x = clip_left + i;
-    FX_DWORD src_x = (bFlipX ? (dest_width - dest_x - 1) : dest_x) *
+    uint32_t src_x = (bFlipX ? (dest_width - dest_x - 1) : dest_x) *
                      (int64_t)src_width / dest_width;
     src_x %= src_width;
 
     uint8_t* pDestPixel = dest_scan + i * dest_Bpp;
     FX_ARGB argb;
     if (src_x == last_src_x) {
       argb = last_argb;
     } else {
       CFX_FixedBufGrow<uint8_t, 128> extracted_components(m_nComponents);
       const uint8_t* pSrcPixel = nullptr;
       if (m_bpc % 8 != 0) {
         // No need to check for 32-bit overflow, as |src_x| is bounded by
         // |src_width| and DownSampleScanline() already checked for overflow
         // with the pitch calculation.
         size_t num_bits = src_x * m_bpc * m_nComponents;
         uint64_t src_bit_pos = num_bits % 8;
         pSrcPixel = pSrcLine + num_bits / 8;
-        for (FX_DWORD j = 0; j < m_nComponents; ++j) {
+        for (uint32_t j = 0; j < m_nComponents; ++j) {
           extracted_components[j] = static_cast<uint8_t>(
               GetBits8(pSrcPixel, src_bit_pos, m_bpc) * unit_To8Bpc);
           src_bit_pos += m_bpc;
         }
         pSrcPixel = extracted_components;
       } else {
         pSrcPixel = pSrcLine + src_x * orig_Bpp;
         if (m_bpc == 16) {
-          for (FX_DWORD j = 0; j < m_nComponents; ++j)
+          for (uint32_t j = 0; j < m_nComponents; ++j)
             extracted_components[j] = pSrcPixel[j * 2];
           pSrcPixel = extracted_components;
         }
       }
 
       if (m_pColorSpace) {
         uint8_t color[4];
         const FX_BOOL bTransMask = TransMask();
         if (m_bDefaultDecode) {
           m_pColorSpace->TranslateImageLine(color, pSrcPixel, 1, 0, 0,
                                             bTransMask);
         } else {
-          for (FX_DWORD j = 0; j < m_nComponents; ++j) {
+          for (uint32_t j = 0; j < m_nComponents; ++j) {
             FX_FLOAT component_value =
                 static_cast<FX_FLOAT>(extracted_components[j]);
             int color_value = static_cast<int>(
                 (m_pCompData[j].m_DecodeMin +
                  m_pCompData[j].m_DecodeStep * component_value) *
                     255.0f +
                 0.5f);
             extracted_components[j] =
                 color_value > 255 ? 255 : (color_value < 0 ? 0 : color_value);
           }
@@ skipping 16 matching lines @@
                       ? 0xFF
                       : 0;
         }
         argb &= 0xFFFFFF;
         argb |= alpha << 24;
       }
       last_src_x = src_x;
       last_argb = argb;
     }
     if (dest_Bpp == 4) {
-      *reinterpret_cast<FX_DWORD*>(pDestPixel) = FXARGB_TODIB(argb);
+      *reinterpret_cast<uint32_t*>(pDestPixel) = FXARGB_TODIB(argb);
     } else {
       *pDestPixel++ = FXARGB_B(argb);
       *pDestPixel++ = FXARGB_G(argb);
       *pDestPixel = FXARGB_R(argb);
     }
   }
 }
 
 FX_BOOL CPDF_DIBSource::TransMask() const {
   return m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK &&
@@ skipping 19 matching lines @@
   m_pCache = nullptr;
   m_pImage = nullptr;
 }
 
 CPDF_ImageLoaderHandle::~CPDF_ImageLoaderHandle() {}
 
 FX_BOOL CPDF_ImageLoaderHandle::Start(CPDF_ImageLoader* pImageLoader,
                                       const CPDF_ImageObject* pImage,
                                       CPDF_PageRenderCache* pCache,
                                       FX_BOOL bStdCS,
-                                      FX_DWORD GroupFamily,
+                                      uint32_t GroupFamily,
                                       FX_BOOL bLoadMask,
                                       CPDF_RenderStatus* pRenderStatus,
                                       int32_t nDownsampleWidth,
                                       int32_t nDownsampleHeight) {
   m_pImageLoader = pImageLoader;
   m_pCache = pCache;
   m_pImage = const_cast<CPDF_ImageObject*>(pImage);
   m_nDownsampleWidth = nDownsampleWidth;
   m_nDownsampleHeight = nDownsampleHeight;
   FX_BOOL ret;
@@ skipping 44 matching lines @@
       m_pImageLoader->m_MatteColor = m_pImage->m_pImage->m_MatteColor;
     }
   }
   return ret;
 }
 
 FX_BOOL CPDF_ImageLoader::Start(const CPDF_ImageObject* pImage,
                                 CPDF_PageRenderCache* pCache,
                                 CPDF_ImageLoaderHandle*& LoadHandle,
                                 FX_BOOL bStdCS,
-                                FX_DWORD GroupFamily,
+                                uint32_t GroupFamily,
                                 FX_BOOL bLoadMask,
                                 CPDF_RenderStatus* pRenderStatus,
                                 int32_t nDownsampleWidth,
                                 int32_t nDownsampleHeight) {
   m_nDownsampleWidth = nDownsampleWidth;
   m_nDownsampleHeight = nDownsampleHeight;
   LoadHandle = new CPDF_ImageLoaderHandle;
   return LoadHandle->Start(this, pImage, pCache, bStdCS, GroupFamily, bLoadMask,
                            pRenderStatus, m_nDownsampleWidth,
                            m_nDownsampleHeight);
 }
 
 FX_BOOL CPDF_ImageLoader::Continue(CPDF_ImageLoaderHandle* LoadHandle,
                                    IFX_Pause* pPause) {
   return LoadHandle->Continue(pPause);
 }
 
 CPDF_ImageLoader::~CPDF_ImageLoader() {
   if (!m_bCached) {
     delete m_pBitmap;
     delete m_pMask;
   }
 }