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

core/src/fxge/dib/fx_dib_main.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/include/fxge/fx_dib.h"
 
 #include <limits.h>
 
@@ skipping 71 matching lines @@
     return FALSE;
   }
   if (pBuffer) {
     m_pBuffer = pBuffer;
     m_bExtBuf = TRUE;
   } else {
     int size = pitch * height + 4;
     int oomlimit = _MAX_OOM_LIMIT_;
     if (oomlimit >= 0 && size >= oomlimit) {
       m_pBuffer = FX_TryAlloc(uint8_t, size);
-      if (m_pBuffer == NULL) {
+      if (!m_pBuffer) {
         return FALSE;
       }
     } else {
       m_pBuffer = FX_Alloc(uint8_t, size);
     }
   }
   m_Width = width;
   m_Height = height;
   m_Pitch = pitch;
   if (HasAlpha() && format != FXDIB_Argb) {
@@ skipping 140 matching lines @@
     }
     return 0xff - index;
   }
   if (GetBPP() == 1) {
     return index ? 0xffffffff : 0xff000000;
   }
   return index * 0x10101 | 0xff000000;
 }
 void CFX_DIBSource::SetPaletteEntry(int index, FX_DWORD color) {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
-  if (m_pPalette == NULL) {
+  if (!m_pPalette) {
     BuildPalette();
   }
   m_pPalette[index] = color;
 }
 int CFX_DIBSource::FindPalette(FX_DWORD color) const {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
-  if (m_pPalette == NULL) {
+  if (!m_pPalette) {
     if (IsCmykImage()) {
       if (GetBPP() == 1) {
         return ((uint8_t)color == 0xff) ? 0 : 1;
       }
       return 0xff - (uint8_t)color;
     }
     if (GetBPP() == 1) {
       return ((uint8_t)color == 0xff) ? 1 : 0;
     }
     return (uint8_t)color;
   }
   int palsize = (1 << GetBPP());
   for (int i = 0; i < palsize; i++)
     if (m_pPalette[i] == color) {
       return i;
     }
   return -1;
 }
 void CFX_DIBitmap::Clear(FX_DWORD color) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return;
   }
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       FXSYS_memset(m_pBuffer, (color & 0xff000000) ? 0xff : 0,
                    m_Pitch * m_Height);
       break;
     case FXDIB_1bppRgb: {
       int index = FindPalette(color);
       FXSYS_memset(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
@@ skipping 79 matching lines @@
   height = dest_rect.bottom - dest_rect.top;
 }
 FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left,
                                      int dest_top,
                                      int width,
                                      int height,
                                      const CFX_DIBSource* pSrcBitmap,
                                      int src_left,
                                      int src_top,
                                      void* pIccTransform) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(),
                  pSrcBitmap->GetHeight(), src_left, src_top, NULL);
   if (width == 0 || height == 0) {
     return TRUE;
   }
   FXDIB_Format dest_format = GetFormat();
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
-  if (dest_format == src_format && pIccTransform == NULL) {
+  if (dest_format == src_format && !pIccTransform) {
     if (GetBPP() == 1) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
         for (int col = 0; col < width; col++) {
           if (src_scan[(src_left + col) / 8] &
               (1 << (7 - (src_left + col) % 8))) {
             dest_scan[(dest_left + col) / 8] |= 1
                                                 << (7 - (dest_left + col) % 8);
           } else {
@@ skipping 32 matching lines @@
 FX_BOOL CFX_DIBitmap::TransferMask(int dest_left,
                                    int dest_top,
                                    int width,
                                    int height,
                                    const CFX_DIBSource* pMask,
                                    FX_DWORD color,
                                    int src_left,
                                    int src_top,
                                    int alpha_flag,
                                    void* pIccTransform) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   ASSERT(HasAlpha() && (m_bpp >= 24));
   ASSERT(pMask->IsAlphaMask());
   if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
     return FALSE;
   }
   GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(),
                  pMask->GetHeight(), src_left, src_top, NULL);
   if (width == 0 || height == 0) {
@@ skipping 79 matching lines @@
           FXSYS_memcpy(dest_color_pos, color_p, comps);
           dest_color_pos += comps;
           *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
         }
       }
     }
   }
   return TRUE;
 }
 void CFX_DIBSource::CopyPalette(const FX_DWORD* pSrc, FX_DWORD size) {
-  if (pSrc == NULL || GetBPP() > 8) {
+  if (!pSrc || GetBPP() > 8) {
     FX_Free(m_pPalette);
     m_pPalette = NULL;
   } else {
     FX_DWORD pal_size = 1 << GetBPP();
-    if (m_pPalette == NULL) {
+    if (!m_pPalette) {
       m_pPalette = FX_Alloc(FX_DWORD, pal_size);
     }
     if (pal_size > size) {
       pal_size = size;
     }
     FXSYS_memcpy(m_pPalette, pSrc, pal_size * sizeof(FX_DWORD));
   }
 }
 void CFX_DIBSource::GetPalette(FX_DWORD* pal, int alpha) const {
   ASSERT(GetBPP() <= 8 && !IsCmykImage());
@@ skipping 62 matching lines @@
                    m_pAlphaMask->m_Pitch);
   } else {
     m_pAlphaMask->Clear(0xff000000);
   }
   return TRUE;
 }
 const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
 FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel,
                                   const CFX_DIBSource* pSrcBitmap,
                                   FXDIB_Channel srcChannel) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   CFX_DIBSource* pSrcClone = (CFX_DIBSource*)pSrcBitmap;
   CFX_DIBitmap* pDst = this;
   int destOffset, srcOffset;
   if (srcChannel == FXDIB_Alpha) {
     if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask()) {
       return FALSE;
     }
     if (pSrcBitmap->GetBPP() == 1) {
       pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
-      if (pSrcClone == NULL) {
+      if (!pSrcClone) {
         return FALSE;
       }
     }
     if (pSrcBitmap->GetFormat() == FXDIB_Argb) {
       srcOffset = 3;
     } else {
       srcOffset = 0;
     }
   } else {
     if (pSrcBitmap->IsAlphaMask()) {
       return FALSE;
     }
     if (pSrcBitmap->GetBPP() < 24) {
       if (pSrcBitmap->IsCmykImage()) {
         pSrcClone = pSrcBitmap->CloneConvert(
             (FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x20));
       } else {
         pSrcClone = pSrcBitmap->CloneConvert(
             (FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x18));
       }
-      if (pSrcClone == NULL) {
+      if (!pSrcClone) {
         return FALSE;
       }
     }
     srcOffset = g_ChannelOffset[srcChannel];
   }
   if (destChannel == FXDIB_Alpha) {
     if (IsAlphaMask()) {
       if (!ConvertFormat(FXDIB_8bppMask)) {
         if (pSrcClone != pSrcBitmap) {
           delete pSrcClone;
@@ skipping 41 matching lines @@
       }
     }
     destOffset = g_ChannelOffset[destChannel];
   }
   if (srcChannel == FXDIB_Alpha && pSrcClone->m_pAlphaMask) {
     CFX_DIBitmap* pAlphaMask = pSrcClone->m_pAlphaMask;
     if (pSrcClone->GetWidth() != m_Width ||
         pSrcClone->GetHeight() != m_Height) {
       if (pAlphaMask) {
         pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
-        if (pAlphaMask == NULL) {
+        if (!pAlphaMask) {
           if (pSrcClone != pSrcBitmap) {
             delete pSrcClone;
           }
           return FALSE;
         }
       }
     }
     if (pSrcClone != pSrcBitmap) {
       pSrcClone->m_pAlphaMask = NULL;
       delete pSrcClone;
     }
     pSrcClone = pAlphaMask;
     srcOffset = 0;
   } else if (pSrcClone->GetWidth() != m_Width ||
              pSrcClone->GetHeight() != m_Height) {
     CFX_DIBitmap* pSrcMatched = pSrcClone->StretchTo(m_Width, m_Height);
     if (pSrcClone != pSrcBitmap) {
       delete pSrcClone;
     }
-    if (pSrcMatched == NULL) {
+    if (!pSrcMatched) {
       return FALSE;
     }
     pSrcClone = pSrcMatched;
   }
   if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
     pDst = m_pAlphaMask;
     destOffset = 0;
   }
   int srcBytes = pSrcClone->GetBPP() / 8;
   int destBytes = pDst->GetBPP() / 8;
   for (int row = 0; row < m_Height; row++) {
     uint8_t* dest_pos = (uint8_t*)pDst->GetScanline(row) + destOffset;
     const uint8_t* src_pos = pSrcClone->GetScanline(row) + srcOffset;
     for (int col = 0; col < m_Width; col++) {
       *dest_pos = *src_pos;
       dest_pos += destBytes;
       src_pos += srcBytes;
     }
   }
   if (pSrcClone != pSrcBitmap && pSrcClone != pSrcBitmap->m_pAlphaMask) {
     delete pSrcClone;
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   int destOffset;
   if (destChannel == FXDIB_Alpha) {
     if (IsAlphaMask()) {
       if (!ConvertFormat(FXDIB_8bppMask)) {
         return FALSE;
       }
       destOffset = 0;
     } else {
@@ skipping 40 matching lines @@
   for (int row = 0; row < m_Height; row++) {
     uint8_t* scan_line = m_pBuffer + row * m_Pitch + destOffset;
     for (int col = 0; col < m_Width; col++) {
       *scan_line = value;
       scan_line += Bpp;
     }
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   ASSERT(pSrcBitmap->IsAlphaMask());
   if (!pSrcBitmap->IsAlphaMask()) {
     return FALSE;
   }
   if (!IsAlphaMask() && !HasAlpha()) {
     return LoadChannel(FXDIB_Alpha, pSrcBitmap, FXDIB_Alpha);
   }
   CFX_DIBitmap* pSrcClone = (CFX_DIBitmap*)pSrcBitmap;
   if (pSrcBitmap->GetWidth() != m_Width ||
       pSrcBitmap->GetHeight() != m_Height) {
     pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
-    if (pSrcClone == NULL) {
+    if (!pSrcClone) {
       return FALSE;
     }
   }
   if (IsAlphaMask()) {
     if (!ConvertFormat(FXDIB_8bppMask)) {
       if (pSrcClone != pSrcBitmap) {
         delete pSrcClone;
       }
       return FALSE;
     }
@@ skipping 32 matching lines @@
     } else {
       m_pAlphaMask->MultiplyAlpha(pSrcClone);
     }
   }
   if (pSrcClone != pSrcBitmap) {
     delete pSrcClone;
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   switch (GetFormat()) {
     case FXDIB_1bppRgb: {
-      if (m_pPalette == NULL) {
+      if (!m_pPalette) {
         return FALSE;
       }
       uint8_t gray[2];
       for (int i = 0; i < 2; i++) {
         int r = (uint8_t)(m_pPalette[i] >> 16);
         int g = (uint8_t)(m_pPalette[i] >> 8);
         int b = (uint8_t)m_pPalette[i];
         gray[i] = (uint8_t)FXRGB2GRAY(r, g, b);
       }
       CFX_DIBitmap* pMask = new CFX_DIBitmap;
@@ skipping 10 matching lines @@
             *dest_pos = gray[1];
           }
           dest_pos++;
         }
       }
       TakeOver(pMask);
       delete pMask;
       break;
     }
     case FXDIB_8bppRgb: {
-      if (m_pPalette == NULL) {
+      if (!m_pPalette) {
         return FALSE;
       }
       uint8_t gray[256];
       for (int i = 0; i < 256; i++) {
         int r = (uint8_t)(m_pPalette[i] >> 16);
         int g = (uint8_t)(m_pPalette[i] >> 8);
         int b = (uint8_t)m_pPalette[i];
         gray[i] = (uint8_t)FXRGB2GRAY(r, g, b);
       }
       CFX_DIBitmap* pMask = new CFX_DIBitmap;
@@ skipping 47 matching lines @@
       TakeOver(pMask);
       delete pMask;
       break;
     }
     default:
       return FALSE;
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       if (!ConvertFormat(FXDIB_8bppMask)) {
         return FALSE;
       }
       MultiplyAlpha(alpha);
       break;
     case FXDIB_8bppMask: {
@@ skipping 27 matching lines @@
         if (!ConvertFormat(FXDIB_Argb)) {
           return FALSE;
         }
         MultiplyAlpha(alpha);
       }
       break;
   }
   return TRUE;
 }
 FX_DWORD CFX_DIBitmap::GetPixel(int x, int y) const {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return 0;
   }
   uint8_t* pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
     case FXDIB_1bppMask: {
       if ((*pos) & (1 << (7 - x % 8))) {
         return 0xff000000;
       }
       return 0;
     }
@@ skipping 12 matching lines @@
     case FXDIB_Rgb32:
       return FXARGB_GETDIB(pos) | 0xff000000;
     case FXDIB_Argb:
       return FXARGB_GETDIB(pos);
     default:
       break;
   }
   return 0;
 }
 void CFX_DIBitmap::SetPixel(int x, int y, FX_DWORD color) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return;
   }
   if (x < 0 || x >= m_Width || y < 0 || y >= m_Height) {
     return;
   }
   uint8_t* pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       if (color >> 24) {
         *pos |= 1 << (7 - x % 8);
@@ skipping 54 matching lines @@
       break;
   }
 }
 void CFX_DIBitmap::DownSampleScanline(int line,
                                       uint8_t* dest_scan,
                                       int dest_bpp,
                                       int dest_width,
                                       FX_BOOL bFlipX,
                                       int clip_left,
                                       int clip_width) const {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return;
   }
   int src_Bpp = m_bpp / 8;
   uint8_t* scanline = m_pBuffer + line * m_Pitch;
   if (src_Bpp == 0) {
     for (int i = 0; i < clip_width; i++) {
       FX_DWORD dest_x = clip_left + i;
       FX_DWORD src_x = dest_x * m_Width / dest_width;
       if (bFlipX) {
         src_x = m_Width - src_x - 1;
@@ skipping 39 matching lines @@
       int dest_pos = i * src_Bpp;
       for (int b = 0; b < src_Bpp; b++) {
         dest_scan[dest_pos + b] = scanline[src_x + b];
       }
     }
   }
 }
 FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor,
                                         FX_DWORD backcolor) {
   ASSERT(!IsAlphaMask());
-  if (m_pBuffer == NULL || IsAlphaMask()) {
+  if (!m_pBuffer || IsAlphaMask()) {
     return FALSE;
   }
   int fc, fm, fy, fk, bc, bm, by, bk;
   int fr, fg, fb, br, bg, bb;
   FX_BOOL isCmykImage = IsCmykImage();
   if (isCmykImage) {
     fc = FXSYS_GetCValue(forecolor);
     fm = FXSYS_GetMValue(forecolor);
     fy = FXSYS_GetYValue(forecolor);
     fk = FXSYS_GetKValue(forecolor);
     bc = FXSYS_GetCValue(backcolor);
     bm = FXSYS_GetMValue(backcolor);
     by = FXSYS_GetYValue(backcolor);
     bk = FXSYS_GetKValue(backcolor);
   } else {
     fr = FXSYS_GetRValue(forecolor);
     fg = FXSYS_GetGValue(forecolor);
     fb = FXSYS_GetBValue(forecolor);
     br = FXSYS_GetRValue(backcolor);
     bg = FXSYS_GetGValue(backcolor);
     bb = FXSYS_GetBValue(backcolor);
   }
   if (m_bpp <= 8) {
     if (isCmykImage) {
-      if (forecolor == 0xff && backcolor == 0 && m_pPalette == NULL) {
+      if (forecolor == 0xff && backcolor == 0 && !m_pPalette) {
         return TRUE;
       }
-    } else if (forecolor == 0 && backcolor == 0xffffff && m_pPalette == NULL) {
+    } else if (forecolor == 0 && backcolor == 0xffffff && !m_pPalette) {
       return TRUE;
     }
-    if (m_pPalette == NULL) {
+    if (!m_pPalette) {
       BuildPalette();
     }
     int size = 1 << m_bpp;
     if (isCmykImage) {
       for (int i = 0; i < size; i++) {
         uint8_t b, g, r;
         AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette[i]),
                            FXSYS_GetMValue(m_pPalette[i]),
                            FXSYS_GetYValue(m_pPalette[i]),
                            FXSYS_GetKValue(m_pPalette[i]), r, g, b);
@@ skipping 67 matching lines @@
         *scanline = br + (fr - br) * gray / 255;
         scanline += gap;
       }
     }
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette,
                                int pal_size,
                                const FX_RECT* pRect) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   if (m_bpp != 8 && m_pPalette && m_AlphaFlag != 0) {
     return FALSE;
   }
   if (m_Width < 4 && m_Height < 4) {
     return FALSE;
   }
   FX_RECT rect(0, 0, m_Width, m_Height);
   if (pRect) {
@@ skipping 133 matching lines @@
         *dest_scan = *src_scan;
         dest_scan--;
         src_scan++;
       }
     }
   }
   return pFlipped;
 }
 CFX_DIBExtractor::CFX_DIBExtractor(const CFX_DIBSource* pSrc) {
   m_pBitmap = NULL;
-  if (pSrc->GetBuffer() == NULL) {
-    m_pBitmap = pSrc->Clone();
-  } else {
+  if (pSrc->GetBuffer()) {
     m_pBitmap = new CFX_DIBitmap;
     if (!m_pBitmap->Create(pSrc->GetWidth(), pSrc->GetHeight(),
                            pSrc->GetFormat(), pSrc->GetBuffer())) {
       delete m_pBitmap;
       m_pBitmap = NULL;
       return;
     }
     m_pBitmap->CopyPalette(pSrc->GetPalette());
     m_pBitmap->CopyAlphaMask(pSrc->m_pAlphaMask);
+  } else {
+    m_pBitmap = pSrc->Clone();
   }
 }
 CFX_DIBExtractor::~CFX_DIBExtractor() {
   delete m_pBitmap;
 }
 CFX_FilteredDIB::CFX_FilteredDIB() {
   m_pScanline = NULL;
   m_pSrc = NULL;
 }
 CFX_FilteredDIB::~CFX_FilteredDIB() {
@@ skipping 118 matching lines @@
 }
 FX_BOOL CFX_ImageRenderer::Continue(IFX_Pause* pPause) {
   if (m_Status == 1) {
     return m_Stretcher.Continue(pPause);
   }
   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->GetBuffer() == NULL) {
+    if (!pBitmap->GetBuffer()) {
       delete pBitmap;
       return FALSE;
     }
     if (pBitmap->IsAlphaMask()) {
       if (m_BitmapAlpha != 255) {
         if (m_AlphaFlag >> 8) {
           m_AlphaFlag =
               (((uint8_t)((m_AlphaFlag & 0xff) * m_BitmapAlpha / 255)) |
                ((m_AlphaFlag >> 8) << 8));
         } else {
@@ skipping 58 matching lines @@
   if (!m_pBitmap->Create(width, height, src_format)) {
     delete m_pBitmap;
     m_pBitmap = NULL;
     return FALSE;
   }
   if (pSrcPalette) {
     m_pBitmap->CopyPalette(pSrcPalette);
   }
   return TRUE;
 }