Get rid of NULLs in core/

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/fxcodec/include/fx_codec.h"
 #include "third_party/lcms2-2.6/include/lcms2.h"
 
@@ skipping 80 matching lines @@
 
 void* IccLib_CreateTransform(const unsigned char* pSrcProfileData,
                              uint32_t dwSrcProfileSize,
                              uint32_t& nSrcComponents,
                              const unsigned char* pDstProfileData,
                              uint32_t dwDstProfileSize,
                              int32_t nDstComponents,
                              int intent,
                              uint32_t dwSrcFormat = Icc_FORMAT_DEFAULT,
                              uint32_t dwDstFormat = Icc_FORMAT_DEFAULT) {
-  cmsHPROFILE srcProfile = NULL;
-  cmsHPROFILE dstProfile = NULL;
-  cmsHTRANSFORM hTransform = NULL;
-  CLcmsCmm* pCmm = NULL;
+  cmsHPROFILE srcProfile = nullptr;

[Tom Sepez, 2016/06/02 20:09:49]

nit:combine with 106.

[Lei Zhang, 2016/06/07 07:33:23]

Done.

+  cmsHPROFILE dstProfile = nullptr;
+  cmsHTRANSFORM hTransform = nullptr;
+  CLcmsCmm* pCmm = nullptr;
   nSrcComponents = 0;
   srcProfile = cmsOpenProfileFromMem((void*)pSrcProfileData, dwSrcProfileSize);
   if (!srcProfile) {
-    return NULL;
+    return nullptr;
   }
   if (!pDstProfileData && dwDstProfileSize == 0 && nDstComponents == 3) {
     dstProfile = cmsCreate_sRGBProfile();
   } else {
     dstProfile =
         cmsOpenProfileFromMem((void*)pDstProfileData, dwDstProfileSize);
   }
   if (!dstProfile) {
     cmsCloseProfile(srcProfile);
-    return NULL;
+    return nullptr;
   }
   int srcFormat;
   FX_BOOL bLab = FALSE;
   cmsColorSpaceSignature srcCS = cmsGetColorSpace(srcProfile);
   nSrcComponents = GetCSComponents(srcCS);
   if (srcCS == cmsSigLabData) {
     srcFormat =
         COLORSPACE_SH(PT_Lab) | CHANNELS_SH(nSrcComponents) | BYTES_SH(0);
     bLab = TRUE;
   } else {
     srcFormat =
         COLORSPACE_SH(PT_ANY) | CHANNELS_SH(nSrcComponents) | BYTES_SH(1);
     if (srcCS == cmsSigRgbData && T_DOSWAP(dwSrcFormat)) {
       srcFormat |= DOSWAP_SH(1);
     }
   }
   cmsColorSpaceSignature dstCS = cmsGetColorSpace(dstProfile);
   if (!CheckComponents(dstCS, nDstComponents, TRUE)) {
     cmsCloseProfile(srcProfile);
     cmsCloseProfile(dstProfile);
-    return NULL;
+    return nullptr;
   }
   switch (dstCS) {
     case cmsSigGrayData:
       hTransform = cmsCreateTransform(srcProfile, srcFormat, dstProfile,
                                       TYPE_GRAY_8, intent, 0);
       break;
     case cmsSigRgbData:
       hTransform = cmsCreateTransform(srcProfile, srcFormat, dstProfile,
                                       TYPE_BGR_8, intent, 0);
       break;
     case cmsSigCmykData:
       hTransform = cmsCreateTransform(
           srcProfile, srcFormat, dstProfile,
           T_DOSWAP(dwDstFormat) ? TYPE_KYMC_8 : TYPE_CMYK_8, intent, 0);
       break;
     default:
       break;
   }
   if (!hTransform) {
     cmsCloseProfile(srcProfile);
     cmsCloseProfile(dstProfile);
-    return NULL;
+    return nullptr;
   }
   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,
                                   uint32_t dwProfileSize,
                                   uint32_t& nComponents,
                                   int32_t intent,
                                   uint32_t dwSrcFormat) {
-  return IccLib_CreateTransform(pProfileData, dwProfileSize, nComponents, NULL,
-                                0, 3, intent, dwSrcFormat);
+  return IccLib_CreateTransform(pProfileData, dwProfileSize, nComponents,
+                                nullptr, 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,
                       uint32_t nSrcComponents,
@@ skipping 45 matching lines @@
 void IccLib_TranslateImage(void* pTransform,
                            unsigned char* pDest,
                            const unsigned char* pSrc,
                            int32_t pixels) {
   cmsDoTransform(((CLcmsCmm*)pTransform)->m_hTransform, (void*)pSrc, pDest,
                  pixels);
 }
 void* CreateProfile_Gray(double gamma) {
   cmsCIExyY* D50 = (cmsCIExyY*)cmsD50_xyY();
   if (!cmsWhitePointFromTemp(D50, 6504)) {
-    return NULL;
+    return nullptr;
   }
-  cmsToneCurve* curve = cmsBuildGamma(NULL, gamma);
+  cmsToneCurve* curve = cmsBuildGamma(nullptr, gamma);
   if (!curve) {
-    return NULL;
+    return nullptr;
   }
   void* profile = cmsCreateGrayProfile(D50, curve);
   cmsFreeToneCurve(curve);
   return profile;
 }
 CCodec_IccModule::IccCS GetProfileCSFromHandle(void* pProfile) {
   if (!pProfile) {
     return CCodec_IccModule::IccCS_Unknown;
   }
   switch (cmsGetColorSpace(pProfile)) {
@@ skipping 99 matching lines @@
  public:
   CFX_IccProfileCache();
   ~CFX_IccProfileCache();
   void* m_pProfile;
   uint32_t m_dwRate;
 
  protected:
   void Purge();
 };
 CFX_IccProfileCache::CFX_IccProfileCache() {
-  m_pProfile = NULL;
+  m_pProfile = nullptr;
   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(CLcmsCmm* pCmm = nullptr);
   ~CFX_IccTransformCache();
   void* m_pIccTransform;
   uint32_t m_dwRate;
   CLcmsCmm* m_pCmm;
 
  protected:
   void Purge();
 };
 CFX_IccTransformCache::CFX_IccTransformCache(CLcmsCmm* pCmm) {
-  m_pIccTransform = NULL;
+  m_pIccTransform = nullptr;
   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<<(uint32_t i);
 };
 CFX_ByteStringKey& CFX_ByteStringKey::operator<<(uint32_t i) {
   AppendBlock(&i, sizeof(uint32_t));
   return *this;
 }
 void* CCodec_IccModule::CreateProfile(CCodec_IccModule::IccParam* pIccParam,
                                       Icc_CLASS ic,
                                       CFX_BinaryBuf* pTransformKey) {
-  CFX_IccProfileCache* pCache = NULL;
+  CFX_IccProfileCache* pCache = nullptr;
   CFX_ByteStringKey key;
   CFX_ByteString text;
   key << pIccParam->ColorSpace << (pIccParam->dwProfileType | ic << 8);
   uint8_t ID[16];
   switch (pIccParam->dwProfileType) {
     case Icc_PARAMTYPE_NONE:
-      return NULL;
+      return nullptr;
     case Icc_PARAMTYPE_BUFFER:
       MD5ComputeID(pIccParam->pProfileData, pIccParam->dwProfileSize, ID);
       break;
     case Icc_PARAMTYPE_PARAM:
       FXSYS_memset(ID, 0, 16);
       switch (pIccParam->ColorSpace) {
         case IccCS_Gray:
           text.Format("%lf", pIccParam->Gamma);
           break;
         default:
@@ skipping 39 matching lines @@
   return pCache->m_pProfile;
 }
 void* CCodec_IccModule::CreateTransform(
     CCodec_IccModule::IccParam* pInputParam,
     CCodec_IccModule::IccParam* pOutputParam,
     CCodec_IccModule::IccParam* pProofParam,
     uint32_t dwIntent,
     uint32_t dwFlag,
     uint32_t dwPrfIntent,
     uint32_t dwPrfFlag) {
-  CLcmsCmm* pCmm = NULL;
+  CLcmsCmm* pCmm = nullptr;
   ASSERT(pInputParam && pOutputParam);
   CFX_ByteStringKey key;
   void* pInputProfile = CreateProfile(pInputParam, Icc_CLASS_INPUT, &key);
   if (!pInputProfile) {
-    return NULL;
+    return nullptr;
   }
   void* pOutputProfile = CreateProfile(pOutputParam, Icc_CLASS_OUTPUT, &key);
   if (!pOutputProfile) {
-    return NULL;
+    return nullptr;
   }
   uint32_t dwInputProfileType =
       TransferProfileType(pInputProfile, pInputParam->dwFormat);
   uint32_t dwOutputProfileType =
       TransferProfileType(pOutputProfile, pOutputParam->dwFormat);
   if (dwInputProfileType == 0 || dwOutputProfileType == 0) {
-    return NULL;
+    return nullptr;
   }
-  void* pProofProfile = NULL;
+  void* pProofProfile = nullptr;
   if (pProofParam) {
     pProofProfile = CreateProfile(pProofParam, Icc_CLASS_PROOF, &key);
   }
   key << dwInputProfileType << dwOutputProfileType << dwIntent << dwFlag
-      << (pProofProfile != NULL) << dwPrfIntent << dwPrfFlag;
+      << !!pProofProfile << dwPrfIntent << dwPrfFlag;
   CFX_ByteString TransformKey(key.GetBuffer(), key.GetSize());
   CFX_IccTransformCache* pTransformCache;
   auto it = m_MapTranform.find(TransformKey);
   if (it == m_MapTranform.end()) {
     pCmm = FX_Alloc(CLcmsCmm, 1);
     pCmm->m_nSrcComponents = T_CHANNELS(dwInputProfileType);
     pCmm->m_nDstComponents = T_CHANNELS(dwOutputProfileType);
     pCmm->m_bLab = T_COLORSPACE(pInputParam->dwFormat) == PT_Lab;
     pTransformCache = new CFX_IccTransformCache(pCmm);
     if (pProofProfile) {
@@ skipping 1464 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;
 }