Remove FX_DWORD from core/ and delete definition

core/fxcodec/codec/fx_codec_icc.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/fxcodec/codec/codec_int.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "third_party/lcms2-2.6/include/lcms2.h"
 
-const FX_DWORD N_COMPONENT_LAB = 3;
-const FX_DWORD N_COMPONENT_GRAY = 1;
-const FX_DWORD N_COMPONENT_RGB = 3;
-const FX_DWORD N_COMPONENT_CMYK = 4;
-const FX_DWORD N_COMPONENT_DEFAULT = 3;
+const uint32_t N_COMPONENT_LAB = 3;
+const uint32_t N_COMPONENT_GRAY = 1;
+const uint32_t N_COMPONENT_RGB = 3;
+const uint32_t N_COMPONENT_CMYK = 4;
+const uint32_t N_COMPONENT_DEFAULT = 3;
 
-FX_BOOL MD5ComputeID(const void* buf, FX_DWORD dwSize, uint8_t ID[16]) {
+FX_BOOL MD5ComputeID(const void* buf, uint32_t dwSize, uint8_t ID[16]) {
   return cmsMD5computeIDExt(buf, dwSize, ID);
 }
 struct CLcmsCmm {
   cmsHTRANSFORM m_hTransform;
   int m_nSrcComponents;
   int m_nDstComponents;
   FX_BOOL m_bLab;
 };
 extern "C" {
 int ourHandler(int ErrorCode, const char* ErrorText) {
@@ skipping 32 matching lines @@
       break;
     default:
       if (nComponents != 3) {
         return FALSE;
       }
       break;
   }
   return TRUE;
 }
 
-FX_DWORD GetCSComponents(cmsColorSpaceSignature cs) {
-  FX_DWORD components;
+uint32_t GetCSComponents(cmsColorSpaceSignature cs) {
+  uint32_t components;
   switch (cs) {
     case cmsSigLabData:
       components = N_COMPONENT_LAB;
       break;
     case cmsSigGrayData:
       components = N_COMPONENT_GRAY;
       break;
     case cmsSigRgbData:
       components = N_COMPONENT_RGB;
       break;
     case cmsSigCmykData:
       components = N_COMPONENT_CMYK;
       break;
     default:
       components = N_COMPONENT_DEFAULT;
       break;
   }
   return components;
 }
 
 void* IccLib_CreateTransform(const unsigned char* pSrcProfileData,
-                             FX_DWORD dwSrcProfileSize,
-                             FX_DWORD& nSrcComponents,
+                             uint32_t dwSrcProfileSize,
+                             uint32_t& nSrcComponents,
                              const unsigned char* pDstProfileData,
-                             FX_DWORD dwDstProfileSize,
+                             uint32_t dwDstProfileSize,
                              int32_t nDstComponents,
                              int intent,
-                             FX_DWORD dwSrcFormat = Icc_FORMAT_DEFAULT,
-                             FX_DWORD dwDstFormat = Icc_FORMAT_DEFAULT) {
+                             uint32_t dwSrcFormat = Icc_FORMAT_DEFAULT,
+                             uint32_t dwDstFormat = Icc_FORMAT_DEFAULT) {
   cmsHPROFILE srcProfile = NULL;
   cmsHPROFILE dstProfile = NULL;
   cmsHTRANSFORM hTransform = NULL;
   CLcmsCmm* pCmm = NULL;
   nSrcComponents = 0;
   srcProfile = cmsOpenProfileFromMem((void*)pSrcProfileData, dwSrcProfileSize);
   if (!srcProfile) {
     return NULL;
   }
   if (!pDstProfileData && dwDstProfileSize == 0 && nDstComponents == 3) {
@@ skipping 52 matching lines @@
   pCmm = new CLcmsCmm;
   pCmm->m_nSrcComponents = nSrcComponents;
   pCmm->m_nDstComponents = nDstComponents;
   pCmm->m_hTransform = hTransform;
   pCmm->m_bLab = bLab;
   cmsCloseProfile(srcProfile);
   cmsCloseProfile(dstProfile);
   return pCmm;
 }
 void* IccLib_CreateTransform_sRGB(const unsigned char* pProfileData,
-                                  FX_DWORD dwProfileSize,
-                                  FX_DWORD& nComponents,
+                                  uint32_t dwProfileSize,
+                                  uint32_t& nComponents,
                                   int32_t intent,
-                                  FX_DWORD dwSrcFormat) {
+                                  uint32_t dwSrcFormat) {
   return IccLib_CreateTransform(pProfileData, dwProfileSize, nComponents, NULL,
                                 0, 3, intent, dwSrcFormat);
 }
 void IccLib_DestroyTransform(void* pTransform) {
   if (!pTransform) {
     return;
   }
   cmsDeleteTransform(((CLcmsCmm*)pTransform)->m_hTransform);
   delete (CLcmsCmm*)pTransform;
 }
 void IccLib_Translate(void* pTransform,
-                      FX_DWORD nSrcComponents,
+                      uint32_t nSrcComponents,
                       FX_FLOAT* pSrcValues,
                       FX_FLOAT* pDestValues) {
   if (!pTransform) {
     return;
   }
   CLcmsCmm* p = (CLcmsCmm*)pTransform;
   uint8_t output[4];
   if (p->m_bLab) {
     CFX_FixedBufGrow<double, 16> inputs(nSrcComponents);
     double* input = inputs;
-    for (FX_DWORD i = 0; i < nSrcComponents; i++) {
+    for (uint32_t i = 0; i < nSrcComponents; i++) {
       input[i] = pSrcValues[i];
     }
     cmsDoTransform(p->m_hTransform, input, output, 1);
   } else {
     CFX_FixedBufGrow<uint8_t, 16> inputs(nSrcComponents);
     uint8_t* input = inputs;
-    for (FX_DWORD i = 0; i < nSrcComponents; i++) {
+    for (uint32_t i = 0; i < nSrcComponents; i++) {
       if (pSrcValues[i] > 1.0f) {
         input[i] = 255;
       } else if (pSrcValues[i] < 0) {
         input[i] = 0;
       } else {
         input[i] = (int)(pSrcValues[i] * 255.0f);
       }
     }
     cmsDoTransform(p->m_hTransform, input, output, 1);
   }
@@ skipping 60 matching lines @@
     case cmsSigCmykData:
       return ICodec_IccModule::IccCS_Cmyk;
     case cmsSigCmyData:
       return ICodec_IccModule::IccCS_Cmy;
     default:
       return ICodec_IccModule::IccCS_Unknown;
   }
 }
 ICodec_IccModule::IccCS CCodec_IccModule::GetProfileCS(
     const uint8_t* pProfileData,
-    FX_DWORD dwProfileSize) {
+    uint32_t dwProfileSize) {
   ICodec_IccModule::IccCS cs;
   cmsHPROFILE hProfile =
       cmsOpenProfileFromMem((void*)pProfileData, dwProfileSize);
   if (!hProfile) {
     return IccCS_Unknown;
   }
   cs = GetProfileCSFromHandle(hProfile);
   if (hProfile) {
     cmsCloseProfile(hProfile);
   }
   return cs;
 }
 ICodec_IccModule::IccCS CCodec_IccModule::GetProfileCS(IFX_FileRead* pFile) {
   if (!pFile) {
     return IccCS_Unknown;
   }
   ICodec_IccModule::IccCS cs;
-  FX_DWORD dwSize = (FX_DWORD)pFile->GetSize();
+  uint32_t dwSize = (uint32_t)pFile->GetSize();
   uint8_t* pBuf = FX_Alloc(uint8_t, dwSize);
   pFile->ReadBlock(pBuf, 0, dwSize);
   cs = GetProfileCS(pBuf, dwSize);
   FX_Free(pBuf);
   return cs;
 }
-FX_DWORD TransferProfileType(void* pProfile, FX_DWORD dwFormat) {
+uint32_t TransferProfileType(void* pProfile, uint32_t dwFormat) {
   cmsColorSpaceSignature cs = cmsGetColorSpace(pProfile);
   switch (cs) {
     case cmsSigXYZData:
       return TYPE_XYZ_16;
     case cmsSigLabData:
       return TYPE_Lab_DBL;
     case cmsSigLuvData:
       return TYPE_YUV_8;
     case cmsSigYCbCrData:
       return TYPE_YCbCr_8;
@@ skipping 29 matching lines @@
       return T_DOSWAP(dwFormat) ? TYPE_KYMC12_8 : TYPE_CMYK12_8;
     default:
       return 0;
   }
 }
 class CFX_IccProfileCache {
  public:
   CFX_IccProfileCache();
   ~CFX_IccProfileCache();
   void* m_pProfile;
-  FX_DWORD m_dwRate;
+  uint32_t m_dwRate;
 
  protected:
   void Purge();
 };
 CFX_IccProfileCache::CFX_IccProfileCache() {
   m_pProfile = NULL;
   m_dwRate = 1;
 }
 CFX_IccProfileCache::~CFX_IccProfileCache() {
   if (m_pProfile) {
     cmsCloseProfile(m_pProfile);
   }
 }
 void CFX_IccProfileCache::Purge() {}
 class CFX_IccTransformCache {
  public:
   CFX_IccTransformCache(CLcmsCmm* pCmm = NULL);
   ~CFX_IccTransformCache();
   void* m_pIccTransform;
-  FX_DWORD m_dwRate;
+  uint32_t m_dwRate;
   CLcmsCmm* m_pCmm;
 
  protected:
   void Purge();
 };
 CFX_IccTransformCache::CFX_IccTransformCache(CLcmsCmm* pCmm) {
   m_pIccTransform = NULL;
   m_dwRate = 1;
   m_pCmm = pCmm;
 }
 CFX_IccTransformCache::~CFX_IccTransformCache() {
   if (m_pIccTransform) {
     cmsDeleteTransform(m_pIccTransform);
   }
   FX_Free(m_pCmm);
 }
 void CFX_IccTransformCache::Purge() {}
 class CFX_ByteStringKey : public CFX_BinaryBuf {
  public:
   CFX_ByteStringKey() : CFX_BinaryBuf() {}
-  CFX_ByteStringKey& operator<<(FX_DWORD i);
+  CFX_ByteStringKey& operator<<(uint32_t i);
 };
-CFX_ByteStringKey& CFX_ByteStringKey::operator<<(FX_DWORD i) {
-  AppendBlock(&i, sizeof(FX_DWORD));
+CFX_ByteStringKey& CFX_ByteStringKey::operator<<(uint32_t i) {
+  AppendBlock(&i, sizeof(uint32_t));
   return *this;
 }
 void* CCodec_IccModule::CreateProfile(ICodec_IccModule::IccParam* pIccParam,
                                       Icc_CLASS ic,
                                       CFX_BinaryBuf* pTransformKey) {
   CFX_IccProfileCache* pCache = NULL;
   CFX_ByteStringKey key;
   CFX_ByteString text;
   key << pIccParam->ColorSpace << (pIccParam->dwProfileType | ic << 8);
   uint8_t ID[16];
@@ skipping 48 matching lines @@
   } else {
     pCache = it->second;
     pCache->m_dwRate++;
   }
   return pCache->m_pProfile;
 }
 void* CCodec_IccModule::CreateTransform(
     ICodec_IccModule::IccParam* pInputParam,
     ICodec_IccModule::IccParam* pOutputParam,
     ICodec_IccModule::IccParam* pProofParam,
-    FX_DWORD dwIntent,
-    FX_DWORD dwFlag,
-    FX_DWORD dwPrfIntent,
-    FX_DWORD dwPrfFlag) {
+    uint32_t dwIntent,
+    uint32_t dwFlag,
+    uint32_t dwPrfIntent,
+    uint32_t dwPrfFlag) {
   CLcmsCmm* pCmm = NULL;
   ASSERT(pInputParam && pOutputParam);
   CFX_ByteStringKey key;
   void* pInputProfile = CreateProfile(pInputParam, Icc_CLASS_INPUT, &key);
   if (!pInputProfile) {
     return NULL;
   }
   void* pOutputProfile = CreateProfile(pOutputParam, Icc_CLASS_OUTPUT, &key);
   if (!pOutputProfile) {
     return NULL;
   }
-  FX_DWORD dwInputProfileType =
+  uint32_t dwInputProfileType =
       TransferProfileType(pInputProfile, pInputParam->dwFormat);
-  FX_DWORD dwOutputProfileType =
+  uint32_t dwOutputProfileType =
       TransferProfileType(pOutputProfile, pOutputParam->dwFormat);
   if (dwInputProfileType == 0 || dwOutputProfileType == 0) {
     return NULL;
   }
   void* pProofProfile = NULL;
   if (pProofParam) {
     pProofProfile = CreateProfile(pProofParam, Icc_CLASS_PROOF, &key);
   }
   key << dwInputProfileType << dwOutputProfileType << dwIntent << dwFlag
       << (pProofProfile != NULL) << dwPrfIntent << dwPrfFlag;
@@ skipping 27 matching lines @@
   for (const auto& pair : m_MapProfile) {
     delete pair.second;
   }
   m_MapProfile.clear();
   for (const auto& pair : m_MapTranform) {
     delete pair.second;
   }
   m_MapTranform.clear();
 }
 void* CCodec_IccModule::CreateTransform_sRGB(const uint8_t* pProfileData,
-                                             FX_DWORD dwProfileSize,
-                                             FX_DWORD& nComponents,
+                                             uint32_t dwProfileSize,
+                                             uint32_t& nComponents,
                                              int32_t intent,
-                                             FX_DWORD dwSrcFormat) {
+                                             uint32_t dwSrcFormat) {
   return IccLib_CreateTransform_sRGB(pProfileData, dwProfileSize, nComponents,
                                      intent, dwSrcFormat);
 }
 
 void* CCodec_IccModule::CreateTransform_CMYK(const uint8_t* pSrcProfileData,
-                                             FX_DWORD dwSrcProfileSize,
-                                             FX_DWORD& nSrcComponents,
+                                             uint32_t dwSrcProfileSize,
+                                             uint32_t& nSrcComponents,
                                              const uint8_t* pDstProfileData,
-                                             FX_DWORD dwDstProfileSize,
+                                             uint32_t dwDstProfileSize,
                                              int32_t intent,
-                                             FX_DWORD dwSrcFormat,
-                                             FX_DWORD dwDstFormat) {
+                                             uint32_t dwSrcFormat,
+                                             uint32_t dwDstFormat) {
   return IccLib_CreateTransform(
       pSrcProfileData, dwSrcProfileSize, nSrcComponents, pDstProfileData,
       dwDstProfileSize, 4, intent, dwSrcFormat, dwDstFormat);
 }
 
 void CCodec_IccModule::DestroyTransform(void* pTransform) {
   IccLib_DestroyTransform(pTransform);
 }
 void CCodec_IccModule::Translate(void* pTransform,
                                  FX_FLOAT* pSrcValues,
@@ skipping 1411 matching lines @@
   uint8_t c1 = FXSYS_round(c * 255);
   uint8_t m1 = FXSYS_round(m * 255);
   uint8_t y1 = FXSYS_round(y * 255);
   uint8_t k1 = FXSYS_round(k * 255);
   uint8_t r, g, b;
   AdobeCMYK_to_sRGB1(c1, m1, y1, k1, r, g, b);
   R = 1.0f * r / 255;
   G = 1.0f * g / 255;
   B = 1.0f * b / 255;
 }