Remove FX_DWORD from core/ and delete definition

core/fxcodec/codec/fx_codec_jpx_opj.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 <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 657 matching lines @@
     image->comps[0].prec = 16;
     image->comps[1].prec = 16;
     image->comps[2].prec = 16;
     return;
   }
 }
 class CJPX_Decoder {
  public:
   explicit CJPX_Decoder(CPDF_ColorSpace* cs);
   ~CJPX_Decoder();
-  FX_BOOL Init(const unsigned char* src_data, FX_DWORD src_size);
-  void GetInfo(FX_DWORD* width, FX_DWORD* height, FX_DWORD* components);
+  FX_BOOL Init(const unsigned char* src_data, uint32_t src_size);
+  void GetInfo(uint32_t* width, uint32_t* height, uint32_t* components);
   bool Decode(uint8_t* dest_buf,
               int pitch,
               const std::vector<uint8_t>& offsets);
 
  private:
   const uint8_t* m_SrcData;
-  FX_DWORD m_SrcSize;
+  uint32_t m_SrcSize;
   opj_image_t* image;
   opj_codec_t* l_codec;
   opj_stream_t* l_stream;
   const CPDF_ColorSpace* const m_ColorSpace;
 };
 
 CJPX_Decoder::CJPX_Decoder(CPDF_ColorSpace* cs)
     : image(nullptr), l_codec(nullptr), l_stream(nullptr), m_ColorSpace(cs) {}
 
 CJPX_Decoder::~CJPX_Decoder() {
   if (l_codec) {
     opj_destroy_codec(l_codec);
   }
   if (l_stream) {
     opj_stream_destroy(l_stream);
   }
   if (image) {
     opj_image_destroy(image);
   }
 }
 
-FX_BOOL CJPX_Decoder::Init(const unsigned char* src_data, FX_DWORD src_size) {
+FX_BOOL CJPX_Decoder::Init(const unsigned char* src_data, uint32_t src_size) {
   static const unsigned char szJP2Header[] = {
       0x00, 0x00, 0x00, 0x0c, 0x6a, 0x50, 0x20, 0x20, 0x0d, 0x0a, 0x87, 0x0a};
   if (!src_data || src_size < sizeof(szJP2Header))
     return FALSE;
 
   image = NULL;
   m_SrcData = src_data;
   m_SrcSize = src_size;
   DecodeData srcData(const_cast<unsigned char*>(src_data), src_size);
   l_stream = fx_opj_stream_create_memory_stream(&srcData,
@@ skipping 62 matching lines @@
     FX_Free(image->icc_profile_buf);
     image->icc_profile_buf = NULL;
     image->icc_profile_len = 0;
   }
   if (!image) {
     return FALSE;
   }
   return TRUE;
 }
 
-void CJPX_Decoder::GetInfo(FX_DWORD* width,
-                           FX_DWORD* height,
-                           FX_DWORD* components) {
-  *width = (FX_DWORD)image->x1;
-  *height = (FX_DWORD)image->y1;
-  *components = (FX_DWORD)image->numcomps;
+void CJPX_Decoder::GetInfo(uint32_t* width,
+                           uint32_t* height,
+                           uint32_t* components) {
+  *width = (uint32_t)image->x1;
+  *height = (uint32_t)image->y1;
+  *components = (uint32_t)image->numcomps;
 }
 
 bool CJPX_Decoder::Decode(uint8_t* dest_buf,
                           int pitch,
                           const std::vector<uint8_t>& offsets) {
   if (image->comps[0].w != image->x1 || image->comps[0].h != image->y1)
     return false;
 
   if (pitch<(int)(image->comps[0].w * 8 * image->numcomps + 31)>> 5 << 2)
     return false;
@@ skipping 60 matching lines @@
       }
     }
   }
   return true;
 }
 
 CCodec_JpxModule::CCodec_JpxModule() {}
 CCodec_JpxModule::~CCodec_JpxModule() {}
 
 CJPX_Decoder* CCodec_JpxModule::CreateDecoder(const uint8_t* src_buf,
-                                              FX_DWORD src_size,
+                                              uint32_t src_size,
                                               CPDF_ColorSpace* cs) {
   std::unique_ptr<CJPX_Decoder> decoder(new CJPX_Decoder(cs));
   return decoder->Init(src_buf, src_size) ? decoder.release() : nullptr;
 }
 
 void CCodec_JpxModule::GetImageInfo(CJPX_Decoder* pDecoder,
-                                    FX_DWORD* width,
-                                    FX_DWORD* height,
-                                    FX_DWORD* components) {
+                                    uint32_t* width,
+                                    uint32_t* height,
+                                    uint32_t* components) {
   pDecoder->GetInfo(width, height, components);
 }
 
 bool CCodec_JpxModule::Decode(CJPX_Decoder* pDecoder,
                               uint8_t* dest_data,
                               int pitch,
                               const std::vector<uint8_t>& offsets) {
   return pDecoder->Decode(dest_data, pitch, offsets);
 }
 
 void CCodec_JpxModule::DestroyDecoder(CJPX_Decoder* pDecoder) {
   delete pDecoder;
 }