"NULL !=" = NULL

include/core/SkTInternalLList.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTInternalLList_DEFINED
 #define SkTInternalLList_DEFINED
 
@@ skipping 28 matching lines @@
  * This class implements a templated internal doubly linked list data structure.
  */
 template <class T> class SkTInternalLList : SkNoncopyable {
 public:
     SkTInternalLList()
         : fHead(NULL)
         , fTail(NULL) {
     }
 
     void remove(T* entry) {
-        SkASSERT(NULL != fHead && NULL != fTail);
+        SkASSERT(fHead && fTail);
         SkASSERT(this->isInList(entry));
 
         T* prev = entry->fPrev;
         T* next = entry->fNext;
 
-        if (NULL != prev) {
+        if (prev) {
             prev->fNext = next;
         } else {
             fHead = next;
         }
-        if (NULL != next) {
+        if (next) {
             next->fPrev = prev;
         } else {
             fTail = prev;
         }
 
         entry->fPrev = NULL;
         entry->fNext = NULL;
 
 #ifdef SK_DEBUG
         entry->fList = NULL;
 #endif
     }
 
     void addToHead(T* entry) {
         SkASSERT(NULL == entry->fPrev && NULL == entry->fNext);
         SkASSERT(NULL == entry->fList);
 
         entry->fPrev = NULL;
         entry->fNext = fHead;
-        if (NULL != fHead) {
+        if (fHead) {
             fHead->fPrev = entry;
         }
         fHead = entry;
         if (NULL == fTail) {
             fTail = entry;
         }
 
 #ifdef SK_DEBUG
         entry->fList = this;
 #endif
     }
 
     void addToTail(T* entry) {
         SkASSERT(NULL == entry->fPrev && NULL == entry->fNext);
         SkASSERT(NULL == entry->fList);
 
         entry->fPrev = fTail;
         entry->fNext = NULL;
-        if (NULL != fTail) {
+        if (fTail) {
             fTail->fNext = entry;
         }
         fTail = entry;
         if (NULL == fHead) {
             fHead = entry;
         }
 
 #ifdef SK_DEBUG
         entry->fList = this;
 #endif
     }
 
     /**
      * Inserts a new list entry before an existing list entry. The new entry must not already be
      * a member of this or any other list. If existingEntry is NULL then the new entry is added
      * at the tail.
      */
     void addBefore(T* newEntry, T* existingEntry) {
-        SkASSERT(NULL != newEntry);
+        SkASSERT(newEntry);
 
         if (NULL == existingEntry) {
             this->addToTail(newEntry);
             return;
         }
 
         SkASSERT(this->isInList(existingEntry));
         newEntry->fNext = existingEntry;
         T* prev = existingEntry->fPrev;
         existingEntry->fPrev = newEntry;
         newEntry->fPrev = prev;
         if (NULL == prev) {
             SkASSERT(fHead == existingEntry);
             fHead = newEntry;
         } else {
             prev->fNext = newEntry;
         }
 #ifdef SK_DEBUG
         newEntry->fList = this;
 #endif
     }
 
     /**
      * Inserts a new list entry after an existing list entry. The new entry must not already be
      * a member of this or any other list. If existingEntry is NULL then the new entry is added
      * at the head.
      */
     void addAfter(T* newEntry, T* existingEntry) {
-        SkASSERT(NULL != newEntry);
+        SkASSERT(newEntry);
 
         if (NULL == existingEntry) {
             this->addToHead(newEntry);
             return;
         }
 
         SkASSERT(this->isInList(existingEntry));
         newEntry->fPrev = existingEntry;
         T* next = existingEntry->fNext;
         existingEntry->fNext = newEntry;
@@ skipping 62 matching lines @@
         }
 
     private:
         T* fCurr;
     };
 
 #ifdef SK_DEBUG
     void validate() const {
         SkASSERT(!fHead == !fTail);
         Iter iter;
-        for (T* item = iter.init(*this, Iter::kHead_IterStart); NULL != item; item = iter.next()) {
+        for (T* item = iter.init(*this, Iter::kHead_IterStart); item; item = iter.next()) {
             SkASSERT(this->isInList(item));
             if (NULL == item->fPrev) {
                 SkASSERT(fHead == item);
             } else {
                 SkASSERT(item->fPrev->fNext == item);
             }
             if (NULL == item->fNext) {
                 SkASSERT(fTail == item);
             } else {
                 SkASSERT(item->fNext->fPrev == item);
             }
         }
     }
 
     /**
      * Debugging-only method that uses the list back pointer to check if 'entry' is indeed in 'this'
      * list.
      */
     bool isInList(const T* entry) const {
         return entry->fList == this;
     }
 
     /**
      * Debugging-only method that laboriously counts the list entries.
      */
     int countEntries() const {
         int count = 0;
-        for (T* entry = fHead; NULL != entry; entry = entry->fNext) {
+        for (T* entry = fHead; entry; entry = entry->fNext) {
             ++count;
         }
         return count;
     }
 #endif // SK_DEBUG
 
 private:
     T* fHead;
     T* fTail;
 
     typedef SkNoncopyable INHERITED;
 };
 
 #endif