"NULL !=" = NULL

src/core/SkClipStack.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkClipStack.h"
 #include "SkPath.h"
@@ skipping 579 matching lines @@
             break;
         }
         element->~Element();
         fDeque.pop_back();
     }
 }
 
 void SkClipStack::getBounds(SkRect* canvFiniteBound,
                             BoundsType* boundType,
                             bool* isIntersectionOfRects) const {
-    SkASSERT(NULL != canvFiniteBound && NULL != boundType);
+    SkASSERT(canvFiniteBound && boundType);
 
     Element* element = (Element*)fDeque.back();
 
     if (NULL == element) {
         // the clip is wide open - the infinite plane w/ no pixels un-writeable
         canvFiniteBound->setEmpty();
         *boundType = kInsideOut_BoundsType;
-        if (NULL != isIntersectionOfRects) {
+        if (isIntersectionOfRects) {
             *isIntersectionOfRects = false;
         }
         return;
     }
 
     *canvFiniteBound = element->fFiniteBound;
     *boundType = element->fFiniteBoundType;
-    if (NULL != isIntersectionOfRects) {
+    if (isIntersectionOfRects) {
         *isIntersectionOfRects = element->fIsIntersectionOfRects;
     }
 }
 
 bool SkClipStack::intersectRectWithClip(SkRect* rect) const {
-    SkASSERT(NULL != rect);
+    SkASSERT(rect);
 
     SkRect bounds;
     SkClipStack::BoundsType bt;
     this->getBounds(&bounds, &bt);
     if (bt == SkClipStack::kInsideOut_BoundsType) {
         if (bounds.contains(*rect)) {
             return false;
         } else {
             // If rect's x values are both within bound's x range we
             // could clip here. Same for y. But we don't bother to check.
@@ skipping 27 matching lines @@
         element = iter.prev();
     }
     return true;
 }
 
 void SkClipStack::pushElement(const Element& element) {
     // Use reverse iterator instead of back because Rect path may need previous
     SkDeque::Iter iter(fDeque, SkDeque::Iter::kBack_IterStart);
     Element* prior = (Element*) iter.prev();
 
-    if (NULL != prior) {
+    if (prior) {
         if (prior->canBeIntersectedInPlace(fSaveCount, element.getOp())) {
             switch (prior->fType) {
                 case Element::kEmpty_Type:
                     SkDEBUGCODE(prior->checkEmpty();)
                     return;
                 case Element::kRect_Type:
                     if (Element::kRect_Type == element.getType()) {
                         if (prior->rectRectIntersectAllowed(element.getRect(), element.isAA())) {
                             SkRect isectRect;
                             if (!isectRect.intersect(prior->getRect(), element.getRect())) {
@@ skipping 78 matching lines @@
 
     if (NULL == fStack) {
         return NULL;
     }
 
     fIter.reset(fStack->fDeque, SkDeque::Iter::kBack_IterStart);
 
     const SkClipStack::Element* element = NULL;
 
     for (element = (const SkClipStack::Element*) fIter.prev();
-         NULL != element;
+         element;
          element = (const SkClipStack::Element*) fIter.prev()) {
 
         if (op == element->fOp) {
             // The Deque's iterator is actually one pace ahead of the
             // returned value. So while "element" is the element we want to
             // return, the iterator is actually pointing at (and will
             // return on the next "next" or "prev" call) the element
             // in front of it in the deque. Bump the iterator forward a
             // step so we get the expected result.
             if (NULL == fIter.next()) {
@@ skipping 19 matching lines @@
     fIter.reset(stack.fDeque, static_cast<SkDeque::Iter::IterStart>(startLoc));
 }
 
 // helper method
 void SkClipStack::getConservativeBounds(int offsetX,
                                         int offsetY,
                                         int maxWidth,
                                         int maxHeight,
                                         SkRect* devBounds,
                                         bool* isIntersectionOfRects) const {
-    SkASSERT(NULL != devBounds);
+    SkASSERT(devBounds);
 
     devBounds->setLTRB(0, 0,
                        SkIntToScalar(maxWidth), SkIntToScalar(maxHeight));
 
     SkRect temp;
     SkClipStack::BoundsType boundType;
 
     // temp starts off in canvas space here
     this->getBounds(&temp, &boundType, isIntersectionOfRects);
     if (SkClipStack::kInsideOut_BoundsType == boundType) {
@@ skipping 78 matching lines @@
 
 void SkClipStack::dump() const {
     B2TIter iter(*this);
     const Element* e;
     while ((e = iter.next())) {
         e->dump();
         SkDebugf("\n");
     }
 }
 #endif