"NULL !=" = NULL

src/core/SkDeque.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkDeque.h"
@@ skipping 82 matching lines @@
             goto INIT_CHUNK;
         }
     }
 
     first->fBegin = begin;
 
     if (NULL == fFront) {
         SkASSERT(NULL == fBack);
         fFront = fBack = begin;
     } else {
-        SkASSERT(NULL != fBack);
+        SkASSERT(fBack);
         fFront = begin;
     }
 
     return begin;
 }
 
 void* SkDeque::push_back() {
     fCount += 1;
 
     if (NULL == fBackBlock) {
@@ skipping 20 matching lines @@
         }
     }
 
     last->fEnd = end;
     end -= fElemSize;
 
     if (NULL == fBack) {
         SkASSERT(NULL == fFront);
         fFront = fBack = end;
     } else {
-        SkASSERT(NULL != fFront);
+        SkASSERT(fFront);
         fBack = end;
     }
 
     return end;
 }
 
 void SkDeque::pop_front() {
     SkASSERT(fCount > 0);
     fCount -= 1;
 
     Block*  first = fFrontBlock;
 
     SkASSERT(first != NULL);
 
     if (first->fBegin == NULL) {  // we were marked empty from before
         first = first->fNext;
         first->fPrev = NULL;
         this->freeBlock(fFrontBlock);
         fFrontBlock = first;
         SkASSERT(first != NULL);    // else we popped too far
     }
 
     char* begin = first->fBegin + fElemSize;
     SkASSERT(begin <= first->fEnd);
 
     if (begin < fFrontBlock->fEnd) {
         first->fBegin = begin;
-        SkASSERT(NULL != first->fBegin);
+        SkASSERT(first->fBegin);
         fFront = first->fBegin;
     } else {
         first->fBegin = first->fEnd = NULL;  // mark as empty
         if (NULL == first->fNext) {
             fFront = fBack = NULL;
         } else {
-            SkASSERT(NULL != first->fNext->fBegin);
+            SkASSERT(first->fNext->fBegin);
             fFront = first->fNext->fBegin;
         }
     }
 }
 
 void SkDeque::pop_back() {
     SkASSERT(fCount > 0);
     fCount -= 1;
 
     Block* last = fBackBlock;
 
     SkASSERT(last != NULL);
 
     if (last->fEnd == NULL) {  // we were marked empty from before
         last = last->fPrev;
         last->fNext = NULL;
         this->freeBlock(fBackBlock);
         fBackBlock = last;
         SkASSERT(last != NULL);  // else we popped too far
     }
 
     char* end = last->fEnd - fElemSize;
     SkASSERT(end >= last->fBegin);
 
     if (end > last->fBegin) {
         last->fEnd = end;
-        SkASSERT(NULL != last->fEnd);
+        SkASSERT(last->fEnd);
         fBack = last->fEnd - fElemSize;
     } else {
         last->fBegin = last->fEnd = NULL;    // mark as empty
         if (NULL == last->fPrev) {
             fFront = fBack = NULL;
         } else {
-            SkASSERT(NULL != last->fPrev->fEnd);
+            SkASSERT(last->fPrev->fEnd);
             fBack = last->fPrev->fEnd - fElemSize;
         }
     }
 }
 
 int SkDeque::numBlocksAllocated() const {
     int numBlocks = 0;
 
     for (const Block* temp = fFrontBlock; temp; temp = temp->fNext) {
         ++numBlocks;
@@ skipping 62 matching lines @@
 // of the doubly linked list until a non-empty one is found. The fPos
 // member is then set to the first (or last) element in the block. If
 // there are no elements in the deque both fCurBlock and fPos will come
 // out of this routine NULL.
 void SkDeque::Iter::reset(const SkDeque& d, IterStart startLoc) {
     fElemSize = d.fElemSize;
 
     if (kFront_IterStart == startLoc) {
         // initialize the iterator to start at the front
         fCurBlock = d.fFrontBlock;
-        while (NULL != fCurBlock && NULL == fCurBlock->fBegin) {
+        while (fCurBlock && NULL == fCurBlock->fBegin) {
             fCurBlock = fCurBlock->fNext;
         }
         fPos = fCurBlock ? fCurBlock->fBegin : NULL;
     } else {
         // initialize the iterator to start at the back
         fCurBlock = d.fBackBlock;
-        while (NULL != fCurBlock && NULL == fCurBlock->fEnd) {
+        while (fCurBlock && NULL == fCurBlock->fEnd) {
             fCurBlock = fCurBlock->fPrev;
         }
         fPos = fCurBlock ? fCurBlock->fEnd - fElemSize : NULL;
     }
 }