"NULL !=" = NULL

src/core/SkTLList.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 SkTLList_DEFINED
 #define SkTLList_DEFINED
 
@@ skipping 35 matching lines @@
         each object is using the space required for allocCnt unfragmented objects. */
     SkTLList(int allocCnt = 1) : fCount(0), fAllocCnt(allocCnt) {
         SkASSERT(allocCnt > 0);
         this->validate();
     }
 
     ~SkTLList() {
         this->validate();
         typename NodeList::Iter iter;
         Node* node = iter.init(fList, Iter::kHead_IterStart);
-        while (NULL != node) {
+        while (node) {
             SkTCast<T*>(node->fObj)->~T();
             Block* block = node->fBlock;
             node = iter.next();
             if (0 == --block->fNodesInUse) {
                 for (int i = 0; i < fAllocCnt; ++i) {
                     block->fNodes[i].~Node();
                 }
                 sk_free(block);
             }
         }
@@ skipping 52 matching lines @@
     Iter tailIter() const { return Iter(*this, Iter::kTail_IterStart); }
 
     T* head() { return Iter(*this, Iter::kHead_IterStart).get(); }
     T* tail() { return Iter(*this, Iter::kTail_IterStart).get(); }
     const T* head() const { return Iter(*this, Iter::kHead_IterStart).get(); }
     const T* tail() const { return Iter(*this, Iter::kTail_IterStart).get(); }
 
     void popHead() {
         this->validate();
         Node* node = fList.head();
-        if (NULL != node) {
+        if (node) {
             this->removeNode(node);
         }
         this->validate();
     }
 
     void popTail() {
         this->validate();
         Node* node = fList.head();
-        if (NULL != node) {
+        if (node) {
             this->removeNode(node);
         }
         this->validate();
     }
 
     void remove(T* t) {
         this->validate();
         Node* node = reinterpret_cast<Node*>(t);
         SkASSERT(reinterpret_cast<T*>(node->fObj) == t);
         this->removeNode(node);
@@ skipping 19 matching lines @@
     bool operator== (const SkTLList& list) const {
         if (this == &list) {
             return true;
         }
         if (fCount != list.fCount) {
             return false;
         }
         for (Iter a(*this, Iter::kHead_IterStart), b(list, Iter::kHead_IterStart);
              a.get();
              a.next(), b.next()) {
-            SkASSERT(NULL != b.get()); // already checked that counts match.
+            SkASSERT(b.get()); // already checked that counts match.
             if (!(*a.get() == *b.get())) {
                 return false;
             }
         }
         return true;
     }
     bool operator!= (const SkTLList& list) const { return !(*this == list); }
 
     /** The iterator becomes invalid if the element it refers to is removed from the list. */
     class Iter : private NodeList::Iter {
@@ skipping 23 matching lines @@
 
         T* prev() { return this->nodeToObj(INHERITED::prev()); }
 
         Iter& operator= (const Iter& iter) { INHERITED::operator=(iter); return *this; }
 
     private:
         friend class SkTLList;
         Node* getNode() { return INHERITED::get(); }
 
         T* nodeToObj(Node* node) {
-            if (NULL != node) {
+            if (node) {
                 return reinterpret_cast<T*>(node->fObj);
             } else {
                 return NULL;
             }
         }
     };
 
     // For use with operator new
     enum Placement {
         kBefore_Placement,
         kAfter_Placement,
     };
 
 private:
     struct Block {
         int fNodesInUse;
         Node fNodes[1];
     };
 
     size_t blockSize() const { return sizeof(Block) + sizeof(Node) * (fAllocCnt-1); }
 
     Node* createNode() {
         Node* node = fFreeList.head();
-        if (NULL != node) {
+        if (node) {
             fFreeList.remove(node);
             ++node->fBlock->fNodesInUse;
         } else {
             Block* block = reinterpret_cast<Block*>(sk_malloc_flags(this->blockSize(), 0));
             node = &block->fNodes[0];
             SkNEW_PLACEMENT(node, Node);
             node->fBlock = block;
             block->fNodesInUse = 1;
             for (int i = 1; i < fAllocCnt; ++i) {
                 SkNEW_PLACEMENT(block->fNodes + i, Node);
                 fFreeList.addToHead(block->fNodes + i);
                 block->fNodes[i].fBlock = block;
             }
         }
         ++fCount;
         return node;
     }
 
     void removeNode(Node* node) {
-        SkASSERT(NULL != node);
+        SkASSERT(node);
         fList.remove(node);
         SkTCast<T*>(node->fObj)->~T();
         if (0 == --node->fBlock->fNodesInUse) {
             Block* block = node->fBlock;
             for (int i = 0; i < fAllocCnt; ++i) {
                 if (block->fNodes + i != node) {
                     fFreeList.remove(block->fNodes + i);
                 }
                 block->fNodes[i].~Node();
             }
@@ skipping 85 matching lines @@
     int fCount;
     int fAllocCnt;
 
 };
 
 // Use the below macros rather than calling this directly
 template <typename T>
 void *operator new(size_t, SkTLList<T>* list,
                    typename SkTLList<T>::Placement placement,
                    const typename SkTLList<T>::Iter& location) {
-    SkASSERT(NULL != list);
+    SkASSERT(list);
     if (SkTLList<T>::kBefore_Placement == placement) {
         return list->internalAddBefore(location);
     } else {
         return list->internalAddAfter(location);
     }
 }
 
 // Skia doesn't use C++ exceptions but it may be compiled with them enabled. Having an op delete
 // to match the op new silences warnings about missing op delete when a constructor throws an
 // exception.
@@ skipping 11 matching lines @@
 #define SkNEW_INSERT_IN_LLIST_AFTER(list, location, type_name, args) \
     (new ((list), SkTLList< type_name >::kAfter_Placement, (location)) type_name args)
 
 #define SkNEW_INSERT_AT_LLIST_HEAD(list, type_name, args) \
     SkNEW_INSERT_IN_LLIST_BEFORE((list), (list)->headIter(), type_name, args)
 
 #define SkNEW_INSERT_AT_LLIST_TAIL(list, type_name, args) \
     SkNEW_INSERT_IN_LLIST_AFTER((list), (list)->tailIter(), type_name, args)
 
 #endif