Get rid of NULLs in core/

core/fxcrt/include/fx_basic.h

 // 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
 
 #ifndef CORE_FXCRT_INCLUDE_FX_BASIC_H_
 #define CORE_FXCRT_INCLUDE_FX_BASIC_H_
 
 #include <algorithm>
@@ skipping 458 matching lines @@
 
   void*& operator[](void* key);
 
   void SetAt(void* key, void* newValue) { (*this)[key] = newValue; }
 
   FX_BOOL RemoveKey(void* key);
 
   void RemoveAll();
 
   FX_POSITION GetStartPosition() const {
-    return (m_nCount == 0) ? NULL : (FX_POSITION)-1;
+    return (m_nCount == 0) ? nullptr : (FX_POSITION)-1;

[Tom Sepez, 2016/06/02 20:09:49]

overparenthesized.

[Lei Zhang, 2016/06/07 07:33:23]

Done.

   }
 
   void GetNextAssoc(FX_POSITION& rNextPosition,
                     void*& rKey,
                     void*& rValue) const;
 
   uint32_t GetHashTableSize() const { return m_nHashTableSize; }
 
   void InitHashTable(uint32_t hashSize, FX_BOOL bAllocNow = TRUE);
 
@@ skipping 18 matching lines @@
 
   CAssoc* GetAssocAt(void* key, uint32_t& hash) const;
 };
 
 template <class KeyType, class ValueType>
 class CFX_MapPtrTemplate : public CFX_MapPtrToPtr {
  public:
   CFX_MapPtrTemplate() : CFX_MapPtrToPtr(10) {}
 
   FX_BOOL Lookup(KeyType key, ValueType& rValue) const {
-    void* pValue = NULL;
+    void* pValue = nullptr;
     if (!CFX_MapPtrToPtr::Lookup((void*)(uintptr_t)key, pValue)) {
       return FALSE;
     }
     rValue = (ValueType)(uintptr_t)pValue;
     return TRUE;
   }
 
   ValueType& operator[](KeyType key) {
     return (ValueType&)CFX_MapPtrToPtr::operator[]((void*)(uintptr_t)key);
   }
 
   void SetAt(KeyType key, ValueType newValue) {
     CFX_MapPtrToPtr::SetAt((void*)(uintptr_t)key, (void*)(uintptr_t)newValue);
   }
 
   FX_BOOL RemoveKey(KeyType key) {
     return CFX_MapPtrToPtr::RemoveKey((void*)(uintptr_t)key);
   }
 
   void GetNextAssoc(FX_POSITION& rNextPosition,
                     KeyType& rKey,
                     ValueType& rValue) const {
-    void* pKey = NULL;
-    void* pValue = NULL;
+    void* pKey = nullptr;
+    void* pValue = nullptr;
     CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
     rKey = (KeyType)(uintptr_t)pKey;
     rValue = (ValueType)(uintptr_t)pValue;
   }
 };
 #endif  // PDF_ENABLE_XFA
 
 class CFX_PtrList {
  protected:
   struct CNode {
@@ skipping 36 matching lines @@
   int GetCount() const { return m_nCount; }
   FX_POSITION AddTail(void* newElement);
   FX_POSITION AddHead(void* newElement);
 
   void SetAt(FX_POSITION pos, void* newElement) {
     CNode* pNode = (CNode*)pos;
     pNode->data = newElement;
   }
   FX_POSITION InsertAfter(FX_POSITION pos, void* newElement);
 
-  FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL) const;
+  FX_POSITION Find(void* searchValue, FX_POSITION startAfter = nullptr) const;
   FX_POSITION FindIndex(int index) const;
 
   void RemoveAt(FX_POSITION pos);
   void RemoveAll();
 
  protected:
   CNode* m_pNodeHead;
   CNode* m_pNodeTail;
   int m_nCount;
   CNode* m_pNodeFree;
@@ skipping 45 matching lines @@
 
   class CountedObj : public ObjClass {
    public:
     CountedObj() {}
 
     CountedObj(const CountedObj& src) : ObjClass(src) {}
 
     int m_RefCount;
   };
 
-  CFX_CountRef() { m_pObject = NULL; }
+  CFX_CountRef() { m_pObject = nullptr; }
 
   CFX_CountRef(const Ref& ref) {
     m_pObject = ref.m_pObject;
     if (m_pObject) {
       m_pObject->m_RefCount++;
     }
   }
 
   ~CFX_CountRef() { SetNull(); }
 
@@ skipping 33 matching lines @@
   }
 
   void SetNull() {
     if (!m_pObject) {
       return;
     }
     m_pObject->m_RefCount--;
     if (m_pObject->m_RefCount <= 0) {
       delete m_pObject;
     }
-    m_pObject = NULL;
+    m_pObject = nullptr;
   }
 
   bool operator==(const Ref& ref) const { return m_pObject == ref.m_pObject; }
 
  protected:
   CountedObj* m_pObject;
 };
 class IFX_Pause {
  public:
   virtual ~IFX_Pause() {}
@@ skipping 48 matching lines @@
       list.start = nStart;
       list.count = temp_count;
       Append(list);
       nCount -= temp_count;
       nStart += temp_count;
     }
   }
 
   uint8_t* GetAt(int32_t nIndex) {
     if (nIndex < 0) {
-      return NULL;
+      return nullptr;
     }
     if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) {
-      return NULL;
+      return nullptr;
     }
     DataList* pCurList = m_DataLists.GetDataPtr(m_CurList);
     if (!pCurList || nIndex < pCurList->start ||
         nIndex >= pCurList->start + pCurList->count) {
-      pCurList = NULL;
+      pCurList = nullptr;
       int32_t iStart = 0;
       int32_t iEnd = m_DataLists.GetUpperBound();
       int32_t iMid = 0;
       while (iStart <= iEnd) {
         iMid = (iStart + iEnd) / 2;
         DataList* list = m_DataLists.GetDataPtr(iMid);
         if (nIndex < list->start) {
           iEnd = iMid - 1;
         } else if (nIndex >= list->start + list->count) {
           iStart = iMid + 1;
         } else {
           pCurList = list;
           m_CurList = iMid;
           break;
         }
       }
     }
-    return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;
+    return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit
+                    : nullptr;
   }
 
  protected:
   void Append(const DataList& list) {
     int32_t iStart = 0;
     int32_t iEnd = m_DataLists.GetUpperBound();
     int32_t iFind = 0;
     while (iStart <= iEnd) {
       int32_t iMid = (iStart + iEnd) / 2;
       DataList* cur_list = m_DataLists.GetDataPtr(iMid);
@@ skipping 99 matching lines @@
   FX_FLOAT e;
   FX_FLOAT f;
   FX_FLOAT g;
   FX_FLOAT h;
   FX_FLOAT i;
 };
 
 uint32_t GetBits32(const uint8_t* pData, int bitpos, int nbits);
 
 #endif  // CORE_FXCRT_INCLUDE_FX_BASIC_H_