"NULL !=" = NULL

src/core/SkRTree.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRTree.h"
 #include "SkTSort.h"
 
@@ skipping 57 matching lines @@
             return;
         } else {
             fRoot.fChild.subtree = allocateNode(0);
             fRoot.fChild.subtree->fNumChildren = 0;
         }
     }
 
     Branch* newSibling = insert(fRoot.fChild.subtree, &newBranch);
     fRoot.fBounds = this->computeBounds(fRoot.fChild.subtree);
 
-    if (NULL != newSibling) {
+    if (newSibling) {
         Node* oldRoot = fRoot.fChild.subtree;
         Node* newRoot = this->allocateNode(oldRoot->fLevel + 1);
         newRoot->fNumChildren = 2;
         *newRoot->child(0) = fRoot;
         *newRoot->child(1) = *newSibling;
         fRoot.fChild.subtree = newRoot;
         fRoot.fBounds = this->computeBounds(fRoot.fChild.subtree);
     }
 
     ++fCount;
@@ skipping 47 matching lines @@
 }
 
 SkRTree::Branch* SkRTree::insert(Node* root, Branch* branch, uint16_t level) {
     Branch* toInsert = branch;
     if (root->fLevel != level) {
         int childIndex = this->chooseSubtree(root, branch);
         toInsert = this->insert(root->child(childIndex)->fChild.subtree, branch, level);
         root->child(childIndex)->fBounds = this->computeBounds(
             root->child(childIndex)->fChild.subtree);
     }
-    if (NULL != toInsert) {
+    if (toInsert) {
         if (root->fNumChildren == fMaxChildren) {
             // handle overflow by splitting. TODO: opportunistic reinsertion
 
             // decide on a distribution to divide with
             Node* newSibling = this->allocateNode(root->fLevel);
             Branch* toDivide = SkNEW_ARRAY(Branch, fMaxChildren + 1);
             for (int i = 0; i < fMaxChildren; ++i) {
                 toDivide[i] = *root->child(i);
             }
             toDivide[fMaxChildren] = *toInsert;
@@ skipping 323 matching lines @@
 
 // Expand 'out' to include 'joinWith'
 static inline void join_no_empty_check(const SkIRect& joinWith, SkIRect* out) {
     // since we check for empty bounds on insert, we know we'll never have empty rects
     // and we can save the empty check that SkIRect::join requires
     if (joinWith.fLeft < out->fLeft) { out->fLeft = joinWith.fLeft; }
     if (joinWith.fTop < out->fTop) { out->fTop = joinWith.fTop; }
     if (joinWith.fRight > out->fRight) { out->fRight = joinWith.fRight; }
     if (joinWith.fBottom > out->fBottom) { out->fBottom = joinWith.fBottom; }
 }