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

core/src/fpdfapi/fpdf_render/fpdf_render_image.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 "render_int.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_pageobj.h"
@@ skipping 11 matching lines @@
   }
   return render.m_Result;
 }
 void CPDF_RenderStatus::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
                                           int left,
                                           int top,
                                           FX_ARGB mask_argb,
                                           int bitmap_alpha,
                                           int blend_mode,
                                           int Transparency) {
-  if (pDIBitmap == NULL) {
+  if (!pDIBitmap) {
     return;
   }
   FX_BOOL bIsolated = Transparency & PDFTRANS_ISOLATED;
   FX_BOOL bGroup = Transparency & PDFTRANS_GROUP;
   if (blend_mode == FXDIB_BLEND_NORMAL) {
     if (!pDIBitmap->IsAlphaMask()) {
       if (bitmap_alpha < 255) {
         pDIBitmap->MultiplyAlpha(bitmap_alpha);
       }
       if (m_pDevice->SetDIBits(pDIBitmap, left, top)) {
@@ skipping 303 matching lines @@
           dest_height)) {
     if (m_LoadHandle) {
       m_Status = 4;
       return TRUE;
     }
     return FALSE;
   }
   return FALSE;
 }
 FX_BOOL CPDF_ImageRenderer::StartRenderDIBSource() {
-  if (m_Loader.m_pBitmap == NULL) {
+  if (!m_Loader.m_pBitmap) {
     return FALSE;
   }
   m_BitmapAlpha = 255;
   const CPDF_GeneralStateData* pGeneralState = m_pImageObject->m_GeneralState;
   if (pGeneralState) {
     m_BitmapAlpha = FXSYS_round(pGeneralState->m_FillAlpha * 255);
   }
   m_pDIBSource = m_Loader.m_pBitmap;
   if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_ALPHA &&
-      m_Loader.m_pMask == NULL) {
+      !m_Loader.m_pMask) {
     return StartBitmapAlpha();
   }
   if (pGeneralState && pGeneralState->m_pTR) {
     if (!pGeneralState->m_pTransferFunc) {
       ((CPDF_GeneralStateData*)pGeneralState)->m_pTransferFunc =
           m_pRenderStatus->GetTransferFunc(pGeneralState->m_pTR);
     }
     if (pGeneralState->m_pTransferFunc &&
         !pGeneralState->m_pTransferFunc->m_bIdentity) {
       m_pDIBSource = m_Loader.m_pBitmap =
@@ skipping 460 matching lines @@
       m_pRenderStatus->m_pDevice->SetDIBits(
           m_pQuickStretcher->m_pBitmap, m_pQuickStretcher->m_ResultLeft,
           m_pQuickStretcher->m_ResultTop, m_BlendType);
     return FALSE;
   }
   if (m_Status == 2) {
     if (m_pTransformer->Continue(pPause)) {
       return TRUE;
     }
     CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
-    if (pBitmap == NULL) {
+    if (!pBitmap) {
       return FALSE;
     }
     if (pBitmap->IsAlphaMask()) {
       if (m_BitmapAlpha != 255) {
         m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
       }
       m_Result = m_pRenderStatus->m_pDevice->SetBitMask(
           pBitmap, m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
           m_FillArgb);
     } else {
@@ skipping 69 matching lines @@
     return FALSE;
   }
   if (pDict->KeyExist("SMask") || pDict->KeyExist("Mask")) {
     return FALSE;
   }
   m_SrcWidth = pDict->GetInteger("Width");
   m_SrcHeight = pDict->GetInteger("Height");
   m_pCS = NULL;
   m_Bpp = 3;
   CPDF_Object* pCSObj = pDict->GetElementValue("ColorSpace");
-  if (pCSObj == NULL) {
+  if (!pCSObj) {
     return FALSE;
   }
   m_pCS = CPDF_ColorSpace::Load(pImageObj->m_pImage->GetDocument(), pCSObj);
-  if (m_pCS == NULL) {
+  if (!m_pCS) {
     return FALSE;
   }
   if (!_IsSupported(m_pCS)) {
     return FALSE;
   }
   m_Bpp = m_pCS->CountComponents();
   if (m_pCS->sRGB()) {
     m_pCS->ReleaseCS();
     m_pCS = NULL;
   }
@@ skipping 36 matching lines @@
       dest_y = m_ResultHeight - m_LineIndex - 1;
       src_y =
           (m_DestHeight - (dest_y + m_ClipTop) - 1) * src_height / m_DestHeight;
     } else {
       dest_y = m_LineIndex;
       src_y = (dest_y + m_ClipTop) * src_height / m_DestHeight;
     }
     const uint8_t* src_scan;
     if (m_pDecoder) {
       src_scan = m_pDecoder->GetScanline(src_y);
-      if (src_scan == NULL) {
+      if (!src_scan) {
         break;
       }
     } else {
       src_scan = m_StreamAcc.GetData();
-      if (src_scan == NULL) {
+      if (!src_scan) {
         break;
       }
       src_scan += src_y * src_pitch;
     }
     uint8_t* result_scan = result_buf + dest_y * m_pBitmap->GetPitch();
     for (int x = 0; x < m_ResultWidth; x++) {
       int dest_x = m_ClipLeft + x;
       int src_x = (m_bFlipX ? (m_DestWidth - dest_x - 1) : dest_x) * src_width /
                   m_DestWidth;
       const uint8_t* src_pixel = src_scan + src_x * m_Bpp;
-      if (m_pCS == NULL) {
+      if (!m_pCS) {
         *result_scan = src_pixel[2];
         result_scan++;
         *result_scan = src_pixel[1];
         result_scan++;
         *result_scan = src_pixel[0];
         result_scan++;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
         result_scan++;
 #endif
       } else {
         m_pCS->TranslateImageLine(result_scan, src_pixel, 1, 0, 0);
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
         result_scan += 4;
 #else
         result_scan += 3;
 #endif
       }
     }
     m_LineIndex++;
     if (pPause && pPause->NeedToPauseNow()) {
       return TRUE;
     }
   }
   return FALSE;
 }
 CFX_DIBitmap* CPDF_RenderStatus::LoadSMask(CPDF_Dictionary* pSMaskDict,
                                            FX_RECT* pClipRect,
                                            const CFX_Matrix* pMatrix) {
-  if (pSMaskDict == NULL) {
+  if (!pSMaskDict) {
     return NULL;
   }
   int width = pClipRect->right - pClipRect->left;
   int height = pClipRect->bottom - pClipRect->top;
   FX_BOOL bLuminosity = FALSE;
   bLuminosity = pSMaskDict->GetConstString("S") != "Alpha";
   CPDF_Stream* pGroup = pSMaskDict->GetStream("G");
-  if (pGroup == NULL) {
+  if (!pGroup) {
     return NULL;
   }
   nonstd::unique_ptr<CPDF_Function> pFunc;
   CPDF_Object* pFuncObj = pSMaskDict->GetElementValue("TR");
   if (pFuncObj && (pFuncObj->IsDictionary() || pFuncObj->IsStream()))
     pFunc.reset(CPDF_Function::Load(pFuncObj));
 
   CFX_Matrix matrix = *pMatrix;
   matrix.TranslateI(-pClipRect->left, -pClipRect->top);
   CPDF_Form form(m_pContext->m_pDocument, m_pContext->m_pPageResources, pGroup);
@@ skipping 97 matching lines @@
   } else if (pFunc) {
     int size = dest_pitch * height;
     for (int i = 0; i < size; i++) {
       dest_buf[i] = transfers[src_buf[i]];
     }
   } else {
     FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height);
   }
   return pMask.release();
 }