Get rid of most instance of 'foo == NULL'

core/src/fpdfapi/fpdf_page/fpdf_page_colors.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 "pageint.h"
 
 #include <limits.h>
 
@@ skipping 670 matching lines @@
   if (m_pAlterCS && m_bOwn) {
     m_pAlterCS->ReleaseCS();
   }
   if (m_pProfile && m_pDocument) {
     m_pDocument->GetPageData()->ReleaseIccProfile(m_pProfile);
   }
 }
 
 FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) {
   CPDF_Stream* pStream = pArray->GetStream(1);
-  if (pStream == NULL) {
+  if (!pStream) {
     return FALSE;
   }
   m_pProfile = pDoc->LoadIccProfile(pStream);
   if (!m_pProfile) {
     return FALSE;
   }
   m_nComponents =
       m_pProfile
           ->GetComponents();  // Try using the nComponents from ICC profile
   CPDF_Dictionary* pDict = pStream->GetDict();
-  if (m_pProfile->m_pTransform == NULL) {  // No valid ICC profile or using sRGB
+  if (!m_pProfile->m_pTransform) {  // No valid ICC profile or using sRGB
     CPDF_Object* pAlterCSObj =
         pDict ? pDict->GetElementValue("Alternate") : NULL;
     if (pAlterCSObj) {
       CPDF_ColorSpace* pAlterCS = CPDF_ColorSpace::Load(pDoc, pAlterCSObj);
       if (pAlterCS) {
         if (m_nComponents == 0) {                 // NO valid ICC profile
           if (pAlterCS->CountComponents() > 0) {  // Use Alternative colorspace
             m_nComponents = pAlterCS->CountComponents();
             m_pAlterCS = pAlterCS;
             m_bOwn = TRUE;
@@ skipping 44 matching lines @@
                                 FX_FLOAT& R,
                                 FX_FLOAT& G,
                                 FX_FLOAT& B) const {
   if (m_pProfile && m_pProfile->m_bsRGB) {
     R = pBuf[0];
     G = pBuf[1];
     B = pBuf[2];
     return TRUE;
   }
   ICodec_IccModule* pIccModule = CPDF_ModuleMgr::Get()->GetIccModule();
-  if (m_pProfile->m_pTransform == NULL || pIccModule == NULL) {
+  if (!m_pProfile->m_pTransform || !pIccModule) {
     if (m_pAlterCS) {
       return m_pAlterCS->GetRGB(pBuf, R, G, B);
     }
     R = G = B = 0.0f;
     return TRUE;
   }
   FX_FLOAT rgb[3];
   pIccModule->SetComponents(m_nComponents);
   pIccModule->Translate(m_pProfile->m_pTransform, pBuf, rgb);
   R = rgb[0];
@@ skipping 37 matching lines @@
     ReverseRGB(pDestBuf, pSrcBuf, pixels);
   } else if (m_pProfile->m_pTransform) {
     int nMaxColors = 1;
     for (int i = 0; i < m_nComponents; i++) {
       nMaxColors *= 52;
     }
     if (m_nComponents > 3 || image_width * image_height < nMaxColors * 3 / 2) {
       CPDF_ModuleMgr::Get()->GetIccModule()->TranslateScanline(
           m_pProfile->m_pTransform, pDestBuf, pSrcBuf, pixels);
     } else {
-      if (m_pCache == NULL) {
+      if (!m_pCache) {
         ((CPDF_ICCBasedCS*)this)->m_pCache = FX_Alloc2D(uint8_t, nMaxColors, 3);
         uint8_t* temp_src = FX_Alloc2D(uint8_t, nMaxColors, m_nComponents);
         uint8_t* pSrc = temp_src;
         for (int i = 0; i < nMaxColors; i++) {
           FX_DWORD color = i;
           FX_DWORD order = nMaxColors / 52;
           for (int c = 0; c < m_nComponents; c++) {
             *pSrc++ = (uint8_t)(color / order * 5);
             color %= order;
             order /= 52;
@@ skipping 54 matching lines @@
 FX_BOOL CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) {
   if (pArray->GetCount() < 4) {
     return FALSE;
   }
   CPDF_Object* pBaseObj = pArray->GetElementValue(1);
   if (pBaseObj == m_pArray) {
     return FALSE;
   }
   CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
   m_pBaseCS = pDocPageData->GetColorSpace(pBaseObj, NULL);
-  if (m_pBaseCS == NULL) {
+  if (!m_pBaseCS) {
     return FALSE;
   }
   m_pCountedBaseCS = pDocPageData->FindColorSpacePtr(m_pBaseCS->GetArray());
   m_nBaseComponents = m_pBaseCS->CountComponents();
   m_pCompMinMax = FX_Alloc2D(FX_FLOAT, m_nBaseComponents, 2);
   FX_FLOAT defvalue;
   for (int i = 0; i < m_nBaseComponents; i++) {
     m_pBaseCS->GetDefaultValue(i, defvalue, m_pCompMinMax[i * 2],
                                m_pCompMinMax[i * 2 + 1]);
     m_pCompMinMax[i * 2 + 1] -= m_pCompMinMax[i * 2];
@@ skipping 160 matching lines @@
   }
   return TRUE;
 }
 FX_BOOL CPDF_SeparationCS::GetRGB(FX_FLOAT* pBuf,
                                   FX_FLOAT& R,
                                   FX_FLOAT& G,
                                   FX_FLOAT& B) const {
   if (m_Type == None) {
     return FALSE;
   }
-  if (m_pFunc == NULL) {
-    if (m_pAltCS == NULL) {
+  if (!m_pFunc) {
+    if (!m_pAltCS) {
       return FALSE;
     }
     int nComps = m_pAltCS->CountComponents();
     CFX_FixedBufGrow<FX_FLOAT, 16> results(nComps);
     for (int i = 0; i < nComps; i++) {
       results[i] = *pBuf;
     }
     return m_pAltCS->GetRGB(results, R, G, B);
   }
   CFX_FixedBufGrow<FX_FLOAT, 16> results(m_pFunc->CountOutputs());
@@ skipping 54 matching lines @@
   if (!pObj)
     return FALSE;
 
   m_nComponents = pObj->GetCount();
   CPDF_Object* pAltCS = pArray->GetElementValue(2);
   if (!pAltCS || pAltCS == m_pArray) {
     return FALSE;
   }
   m_pAltCS = Load(pDoc, pAltCS);
   m_pFunc = CPDF_Function::Load(pArray->GetElementValue(3));
-  if (m_pAltCS == NULL || m_pFunc == NULL) {
+  if (!m_pAltCS || !m_pFunc) {
     return FALSE;
   }
   if (m_pFunc->CountOutputs() < m_pAltCS->CountComponents()) {
     return FALSE;
   }
   return TRUE;
 }
 FX_BOOL CPDF_DeviceNCS::GetRGB(FX_FLOAT* pBuf,
                                FX_FLOAT& R,
                                FX_FLOAT& G,
                                FX_FLOAT& B) const {
-  if (m_pFunc == NULL) {
+  if (!m_pFunc) {
     return FALSE;
   }
   CFX_FixedBufGrow<FX_FLOAT, 16> results(m_pFunc->CountOutputs());
   int nresults = 0;
   m_pFunc->Call(pBuf, m_nComponents, results, nresults);
   if (nresults == 0) {
     return FALSE;
   }
   return m_pAltCS->GetRGB(results, R, G, B);
 }
@@ skipping 144 matching lines @@
                                  FX_FLOAT y,
                                  FX_FLOAT k) const {
   if (v_SetCMYK(pBuf, c, m, y, k)) {
     return TRUE;
   }
   FX_FLOAT R, G, B;
   AdobeCMYK_to_sRGB(c, m, y, k, R, G, B);
   return SetRGB(pBuf, R, G, B);
 }
 void CPDF_ColorSpace::GetDefaultColor(FX_FLOAT* buf) const {
-  if (buf == NULL || m_Family == PDFCS_PATTERN) {
+  if (!buf || m_Family == PDFCS_PATTERN) {
     return;
   }
   FX_FLOAT min, max;
   for (int i = 0; i < m_nComponents; i++) {
     GetDefaultValue(i, buf[i], min, max);
   }
 }
 int CPDF_ColorSpace::GetMaxIndex() const {
   if (m_Family != PDFCS_INDEXED) {
     return 0;
@@ skipping 66 matching lines @@
   m_pBuffer = NULL;
 }
 void CPDF_Color::ReleaseColorSpace() {
   if (m_pCS && m_pCS->m_pDocument && m_pCS->GetArray()) {
     m_pCS->m_pDocument->GetPageData()->ReleaseColorSpace(m_pCS->GetArray());
     m_pCS = NULL;
   }
 }
 void CPDF_Color::SetColorSpace(CPDF_ColorSpace* pCS) {
   if (m_pCS == pCS) {
-    if (m_pBuffer == NULL) {
+    if (!m_pBuffer) {
       m_pBuffer = pCS->CreateBuf();
     }
     ReleaseColorSpace();
     m_pCS = pCS;
     return;
   }
   ReleaseBuffer();
   ReleaseColorSpace();
   m_pCS = pCS;
   if (m_pCS) {
     m_pBuffer = pCS->CreateBuf();
     pCS->GetDefaultColor(m_pBuffer);
   }
 }
 void CPDF_Color::SetValue(FX_FLOAT* comps) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return;
   }
   if (m_pCS->GetFamily() != PDFCS_PATTERN) {
     FXSYS_memcpy(m_pBuffer, comps, m_pCS->CountComponents() * sizeof(FX_FLOAT));
   }
 }
 void CPDF_Color::SetValue(CPDF_Pattern* pPattern, FX_FLOAT* comps, int ncomps) {
   if (ncomps > MAX_PATTERN_COLORCOMPS) {
     return;
   }
-  if (m_pCS == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
+  if (!m_pCS || m_pCS->GetFamily() != PDFCS_PATTERN) {
     FX_Free(m_pBuffer);
     m_pCS = CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
     m_pBuffer = m_pCS->CreateBuf();
   }
   CPDF_DocPageData* pDocPageData = NULL;
   PatternValue* pvalue = (PatternValue*)m_pBuffer;
   if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {
     pDocPageData = pvalue->m_pPattern->m_pDocument->GetPageData();
     if (pDocPageData) {
       pDocPageData->ReleasePattern(pvalue->m_pPattern->m_pPatternObj);
@@ skipping 16 matching lines @@
 void CPDF_Color::Copy(const CPDF_Color* pSrc) {
   ReleaseBuffer();
   ReleaseColorSpace();
   m_pCS = pSrc->m_pCS;
   if (m_pCS && m_pCS->m_pDocument) {
     CPDF_Array* pArray = m_pCS->GetArray();
     if (pArray) {
       m_pCS = m_pCS->m_pDocument->GetPageData()->GetCopiedColorSpace(pArray);
     }
   }
-  if (m_pCS == NULL) {
+  if (!m_pCS) {
     return;
   }
   m_pBuffer = m_pCS->CreateBuf();
   FXSYS_memcpy(m_pBuffer, pSrc->m_pBuffer, m_pCS->GetBufSize());
   if (m_pCS->GetFamily() == PDFCS_PATTERN) {
     PatternValue* pvalue = (PatternValue*)m_pBuffer;
     if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {
       pvalue->m_pPattern =
           pvalue->m_pPattern->m_pDocument->GetPageData()->GetPattern(
               pvalue->m_pPattern->m_pPatternObj, FALSE,
               &pvalue->m_pPattern->m_ParentMatrix);
     }
   }
 }
 FX_BOOL CPDF_Color::GetRGB(int& R, int& G, int& B) const {
-  if (m_pCS == NULL || m_pBuffer == NULL) {
+  if (!m_pCS || !m_pBuffer) {
     return FALSE;
   }
   FX_FLOAT r = 0.0f, g = 0.0f, b = 0.0f;
   if (!m_pCS->GetRGB(m_pBuffer, r, g, b)) {
     return FALSE;
   }
   R = (int32_t)(r * 255 + 0.5f);
   G = (int32_t)(g * 255 + 0.5f);
   B = (int32_t)(b * 255 + 0.5f);
   return TRUE;
 }
 CPDF_Pattern* CPDF_Color::GetPattern() const {
-  if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
+  if (!m_pBuffer || m_pCS->GetFamily() != PDFCS_PATTERN) {
     return NULL;
   }
   PatternValue* pvalue = (PatternValue*)m_pBuffer;
   return pvalue->m_pPattern;
 }
 CPDF_ColorSpace* CPDF_Color::GetPatternCS() const {
-  if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
+  if (!m_pBuffer || m_pCS->GetFamily() != PDFCS_PATTERN) {
     return NULL;
   }
   return m_pCS->GetBaseCS();
 }
 FX_FLOAT* CPDF_Color::GetPatternColor() const {
-  if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
+  if (!m_pBuffer || m_pCS->GetFamily() != PDFCS_PATTERN) {
     return NULL;
   }
   PatternValue* pvalue = (PatternValue*)m_pBuffer;
   return pvalue->m_nComps ? pvalue->m_Comps : NULL;
 }
 FX_BOOL CPDF_Color::IsEqual(const CPDF_Color& other) const {
-  if (m_pCS != other.m_pCS || m_pCS == NULL) {
-    return FALSE;
-  }
-  return FXSYS_memcmp(m_pBuffer, other.m_pBuffer, m_pCS->GetBufSize()) == 0;
+  return m_pCS && m_pCS == other.m_pCS &&
+         FXSYS_memcmp(m_pBuffer, other.m_pBuffer, m_pCS->GetBufSize()) == 0;
 }