Remove NULL in xfa/

xfa/fgas/crt/fgas_utils.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 "xfa/fgas/crt/fgas_utils.h"
 
 #include <algorithm>
 
@@ skipping 115 matching lines @@
     iCount = iBlockCount;
     iBlockCount = 0;
   } else {
     iBlockCount -= iCount;
   }
   return iCount;
 }
 void CFX_BaseArray::RemoveAll(FX_BOOL bLeaveMemory) {
   if (!bLeaveMemory) {
     uint8_t*& pBuffer = m_pData->pBuffer;
-    if (pBuffer != NULL) {
+    if (pBuffer) {
       FX_Free(pBuffer);
-      pBuffer = NULL;
+      pBuffer = nullptr;
     }
     m_pData->iTotalCount = 0;
   }
   m_pData->iBlockCount = 0;
 }
 
 CFX_BaseMassArrayImp::CFX_BaseMassArrayImp(int32_t iChunkSize,
                                            int32_t iBlockSize)
     : m_iChunkSize(iChunkSize),
       m_iBlockSize(iBlockSize),
@@ skipping 22 matching lines @@
         pChunk = FX_Alloc(uint8_t, iMemSize);
         if (m_iChunkCount < m_pData->GetSize()) {
           m_pData->SetAt(m_iChunkCount, pChunk);
         } else {
           m_pData->Add(pChunk);
         }
         m_iChunkCount++;
       }
     }
   }
-  ASSERT(pChunk != NULL);
+  ASSERT(pChunk);
   m_iBlockCount = index + 1;
   return pChunk + (index % m_iChunkSize) * m_iBlockSize;
 }
 uint8_t* CFX_BaseMassArrayImp::GetAt(int32_t index) const {
   ASSERT(index > -1 && index < m_iBlockCount);
   uint8_t* pChunk = (uint8_t*)m_pData->GetAt(index / m_iChunkSize);
-  ASSERT(pChunk != NULL);
+  ASSERT(pChunk);
   return pChunk + (index % m_iChunkSize) * m_iBlockSize;
 }
 int32_t CFX_BaseMassArrayImp::Append(const CFX_BaseMassArrayImp& src,
                                      int32_t iStart,
                                      int32_t iCount) {
   ASSERT(m_iBlockSize == src.m_iBlockSize);
   int32_t iAdded = src.m_iBlockCount;
   ASSERT(iStart > -1 && iStart < iAdded);
   if (iCount < 0) {
     iCount = iAdded;
@@ skipping 52 matching lines @@
   int32_t iDstChunkIndex = iDstStart / m_iChunkSize;
   int32_t iSrcChunkIndex = iSrcStart / src.m_iChunkSize;
   uint8_t* pDstChunk = (uint8_t*)GetAt(iDstStart);
   uint8_t* pSrcChunk = (uint8_t*)src.GetAt(iSrcStart);
   int32_t iDstChunkSize = m_iChunkSize - (iDstStart % m_iChunkSize);
   int32_t iSrcChunkSize = src.m_iChunkSize - (iSrcStart % src.m_iChunkSize);
   int32_t iCopySize =
       std::min(iSrcCount, std::min(iSrcChunkSize, iDstChunkSize));
   int32_t iCopyBytes = iCopySize * m_iBlockSize;
   while (iSrcCount > 0) {
-    ASSERT(pDstChunk != NULL && pSrcChunk != NULL);
+    ASSERT(pDstChunk && pSrcChunk);
     FXSYS_memcpy(pDstChunk, pSrcChunk, iCopyBytes);
     iSrcCount -= iCopySize;
     iSrcChunkSize -= iCopySize;
     if (iSrcChunkSize < 1) {
       iSrcChunkSize = src.m_iChunkSize;
       iSrcChunkIndex++;
       pSrcChunk = (uint8_t*)src.m_pData->GetAt(iSrcChunkIndex);
     } else {
       pSrcChunk += iCopyBytes;
     }
@@ skipping 15 matching lines @@
   } else {
     m_iBlockCount -= iCount;
   }
   return m_iBlockCount;
 }
 void CFX_BaseMassArrayImp::RemoveAll(FX_BOOL bLeaveMemory) {
   if (bLeaveMemory) {
     m_iBlockCount = 0;
     return;
   }
-  for (int32_t i = 0; i < m_iChunkCount; i++) {
-    void* p = m_pData->GetAt(i);
-    if (p == NULL) {
-      continue;
-    }
-    FX_Free(p);
-  }
+  for (int32_t i = 0; i < m_iChunkCount; i++)
+    FX_Free(m_pData->GetAt(i));
+
   m_pData->RemoveAll();
   m_iChunkCount = 0;
   m_iBlockCount = 0;
 }
 CFX_BaseMassArray::CFX_BaseMassArray(int32_t iChunkSize, int32_t iBlockSize) {
   m_pData = new CFX_BaseMassArrayImp(iChunkSize, iBlockSize);
 }
 CFX_BaseMassArray::~CFX_BaseMassArray() {
   delete m_pData;
 }
@@ skipping 42 matching lines @@
 }
 CFX_BaseDiscreteArray::~CFX_BaseDiscreteArray() {
   RemoveAll();
   delete static_cast<FX_BASEDISCRETEARRAYDATA*>(m_pData);
 }
 uint8_t* CFX_BaseDiscreteArray::AddSpaceTo(int32_t index) {
   ASSERT(index > -1);
   FX_BASEDISCRETEARRAYDATA* pData = (FX_BASEDISCRETEARRAYDATA*)m_pData;
   int32_t& iChunkCount = pData->iChunkCount;
   int32_t iChunkSize = pData->iChunkSize;
-  uint8_t* pChunk = NULL;
+  uint8_t* pChunk = nullptr;
   int32_t iChunk = index / iChunkSize;
   if (iChunk < iChunkCount) {
     pChunk = pData->ChunkBuffer.GetAt(iChunk);
   }
   if (!pChunk) {
     pChunk = FX_Alloc2D(uint8_t, iChunkSize, pData->iBlockSize);
     FXSYS_memset(pChunk, 0, iChunkSize * pData->iBlockSize);
     pData->ChunkBuffer.SetAtGrow(iChunk, pChunk);
     if (iChunkCount <= iChunk) {
       iChunkCount = iChunk + 1;
@@ skipping 37 matching lines @@
 void CFX_BaseStack::Pop() {
   int32_t& iBlockCount = m_pData->m_iBlockCount;
   if (iBlockCount < 1) {
     return;
   }
   iBlockCount--;
 }
 uint8_t* CFX_BaseStack::GetTopElement() const {
   int32_t iSize = m_pData->m_iBlockCount;
   if (iSize < 1) {
-    return NULL;
+    return nullptr;
   }
   return m_pData->GetAt(iSize - 1);
 }
 int32_t CFX_BaseStack::GetSize() const {
   return m_pData->m_iBlockCount;
 }
 uint8_t* CFX_BaseStack::GetAt(int32_t index) const {
   return m_pData->GetAt(index);
 }
 void CFX_BaseStack::RemoveAll(FX_BOOL bLeaveMemory) {
   m_pData->RemoveAll(bLeaveMemory);
 }