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

core/src/fxcrt/fx_basic_array.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/fxcrt/fx_basic.h"
 #include "third_party/base/numerics/safe_math.h"
 
 CFX_BasicArray::CFX_BasicArray(int unit_size)
     : m_pData(NULL), m_nSize(0), m_nMaxSize(0) {
   if (unit_size < 0 || unit_size > (1 << 28)) {
     m_nUnitSize = 4;
   } else {
     m_nUnitSize = unit_size;
   }
 }
 CFX_BasicArray::~CFX_BasicArray() {
   FX_Free(m_pData);
 }
 FX_BOOL CFX_BasicArray::SetSize(int nNewSize) {
   if (nNewSize <= 0) {
     FX_Free(m_pData);
     m_pData = NULL;
     m_nSize = m_nMaxSize = 0;
     return 0 == nNewSize;
   }
 
-  if (m_pData == NULL) {
+  if (!m_pData) {
     pdfium::base::CheckedNumeric<int> totalSize = nNewSize;
     totalSize *= m_nUnitSize;
     if (!totalSize.IsValid()) {
       m_nSize = m_nMaxSize = 0;
       return FALSE;
     }
     m_pData = FX_Alloc(uint8_t, totalSize.ValueOrDie());
     m_nSize = m_nMaxSize = nNewSize;
   } else if (nNewSize <= m_nMaxSize) {
     if (nNewSize > m_nSize) {
       FXSYS_memset(m_pData + m_nSize * m_nUnitSize, 0,
                    (nNewSize - m_nSize) * m_nUnitSize);
     }
     m_nSize = nNewSize;
   } else {
     int nNewMax = nNewSize < m_nMaxSize ? m_nMaxSize : nNewSize;
     pdfium::base::CheckedNumeric<int> totalSize = nNewMax;
     totalSize *= m_nUnitSize;
     if (!totalSize.IsValid() || nNewMax < m_nSize) {
       return FALSE;
     }
     uint8_t* pNewData = FX_Realloc(uint8_t, m_pData, totalSize.ValueOrDie());
-    if (pNewData == NULL) {
+    if (!pNewData) {
       return FALSE;
     }
     FXSYS_memset(pNewData + m_nSize * m_nUnitSize, 0,
                  (nNewMax - m_nSize) * m_nUnitSize);
     m_pData = pNewData;
     m_nSize = nNewSize;
     m_nMaxSize = nNewMax;
   }
   return TRUE;
 }
@@ skipping 45 matching lines @@
   if (nMoveCount) {
     FXSYS_memmove(m_pData + nIndex * m_nUnitSize,
                   m_pData + (nIndex + nCount) * m_nUnitSize,
                   nMoveCount * m_nUnitSize);
   }
   m_nSize -= nCount;
   return TRUE;
 }
 FX_BOOL CFX_BasicArray::InsertAt(int nStartIndex,
                                  const CFX_BasicArray* pNewArray) {
-  if (pNewArray == NULL) {
+  if (!pNewArray) {
     return FALSE;
   }
   if (pNewArray->m_nSize == 0) {
     return TRUE;
   }
   if (!InsertSpaceAt(nStartIndex, pNewArray->m_nSize)) {
     return FALSE;
   }
   FXSYS_memcpy(m_pData + nStartIndex * m_nUnitSize, pNewArray->m_pData,
                pNewArray->m_nSize * m_nUnitSize);
   return TRUE;
 }
 const void* CFX_BasicArray::GetDataPtr(int index) const {
-  if (index < 0 || index >= m_nSize || m_pData == NULL) {
+  if (index < 0 || index >= m_nSize || !m_pData) {
     return NULL;
   }
   return m_pData + index * m_nUnitSize;
 }
 CFX_BaseSegmentedArray::CFX_BaseSegmentedArray(int unit_size,
                                                int segment_units,
                                                int index_size)
     : m_UnitSize(unit_size),
       m_SegmentSize(segment_units),
       m_IndexSize(index_size),
@@ skipping 10 matching lines @@
 }
 CFX_BaseSegmentedArray::~CFX_BaseSegmentedArray() {
   RemoveAll();
 }
 static void _ClearIndex(int level, int size, void** pIndex) {
   if (level == 0) {
     FX_Free(pIndex);
     return;
   }
   for (int i = 0; i < size; i++) {
-    if (pIndex[i] == NULL) {
+    if (!pIndex[i]) {

[Tom Sepez, 2015/12/14 18:27:00]

nit: flip this around and lose the !

[Lei Zhang, 2015/12/15 01:58:36]

Done.

       continue;
     }
     _ClearIndex(level - 1, size, (void**)pIndex[i]);
   }
   FX_Free(pIndex);
 }
 void CFX_BaseSegmentedArray::RemoveAll() {
-  if (m_pIndex == NULL) {
+  if (!m_pIndex) {
     return;
   }
   _ClearIndex(m_IndexDepth, m_IndexSize, (void**)m_pIndex);
   m_pIndex = NULL;
   m_IndexDepth = 0;
   m_DataSize = 0;
 }
 void* CFX_BaseSegmentedArray::Add() {
   if (m_DataSize % m_SegmentSize) {
     return GetAt(m_DataSize++);
   }
   void* pSegment = FX_Alloc2D(uint8_t, m_UnitSize, m_SegmentSize);
-  if (m_pIndex == NULL) {
+  if (!m_pIndex) {
     m_pIndex = pSegment;
     m_DataSize++;
     return pSegment;
   }
   if (m_IndexDepth == 0) {
     void** pIndex = FX_Alloc(void*, m_IndexSize);
     pIndex[0] = m_pIndex;
     pIndex[1] = pSegment;
     m_pIndex = pIndex;
     m_DataSize++;
@@ skipping 15 matching lines @@
   if (m_DataSize == tree_size * m_SegmentSize) {
     void** pIndex = FX_Alloc(void*, m_IndexSize);
     pIndex[0] = m_pIndex;
     m_pIndex = pIndex;
     m_IndexDepth++;
   } else {
     tree_size /= m_IndexSize;
   }
   void** pSpot = (void**)m_pIndex;
   for (i = 1; i < m_IndexDepth; i++) {
-    if (pSpot[seg_index / tree_size] == NULL) {
+    if (!pSpot[seg_index / tree_size]) {
       pSpot[seg_index / tree_size] = FX_Alloc(void*, m_IndexSize);
     }
     pSpot = (void**)pSpot[seg_index / tree_size];
     seg_index = seg_index % tree_size;
     tree_size /= m_IndexSize;
   }
   if (i < m_IndexDepth) {
     FX_Free(pSegment);
     RemoveAll();
     return NULL;
@@ skipping 43 matching lines @@
                                            void* param) const {
   if (level == 0) {
     int count = m_DataSize - start;
     if (count > m_SegmentSize) {
       count = m_SegmentSize;
     }
     start += count;
     return IterateSegment((const uint8_t*)pIndex, count, callback, param);
   }
   for (int i = 0; i < m_IndexSize; i++) {
-    if (pIndex[i] == NULL) {
+    if (!pIndex[i]) {
       continue;
     }
     void* p =
         IterateIndex(level - 1, start, (void**)pIndex[i], callback, param);
     if (p) {
       return p;
     }
   }
   return NULL;
 }
 void* CFX_BaseSegmentedArray::Iterate(FX_BOOL (*callback)(void* param,
                                                           void* pData),
                                       void* param) const {
-  if (m_pIndex == NULL) {
+  if (!m_pIndex) {
     return NULL;
   }
   int start = 0;
   return IterateIndex(m_IndexDepth, start, (void**)m_pIndex, callback, param);
 }
 void* CFX_BaseSegmentedArray::GetAt(int index) const {
   if (index < 0 || index >= m_DataSize) {
     return NULL;
   }
   if (m_IndexDepth == 0) {
@@ skipping 24 matching lines @@
         FX_Free(pIndex[i % m_IndexSize]);
         pIndex[i % m_IndexSize] = NULL;
       }
     } else {
       FX_Free(m_pIndex);
       m_pIndex = NULL;
     }
   }
   m_DataSize -= count;
 }