"NULL !=" = NULL

src/core/SkDraw.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 "SkDraw.h"
 #include "SkBlitter.h"
 #include "SkCanvas.h"
@@ skipping 610 matching lines @@
                             fDevice->drawRect(*this, r, newPaint);
                         } else {
                             this->drawRect(r, newPaint);
                         }
                     }
                 }
                 break;
             }
             case SkCanvas::kLines_PointMode:
 #ifndef SK_DISABLE_DASHING_OPTIMIZATION
-                if (2 == count && NULL != paint.getPathEffect()) {
+                if (2 == count && paint.getPathEffect()) {
                     // most likely a dashed line - see if it is one of the ones
                     // we can accelerate
                     SkStrokeRec rec(paint);
                     SkPathEffect::PointData pointData;
 
                     SkPath path;
                     path.moveTo(pts[0]);
                     path.lineTo(pts[1]);
 
                     SkRect cullRect = SkRect::Make(fRC->getBounds());
@@ skipping 290 matching lines @@
         return false;
     }
 
     SkVector src[2], dst[2];
     src[0].set(strokeWidth, 0);
     src[1].set(0, strokeWidth);
     matrix.mapVectors(dst, src, 2);
     SkScalar len0 = fast_len(dst[0]);
     SkScalar len1 = fast_len(dst[1]);
     if (len0 <= SK_Scalar1 && len1 <= SK_Scalar1) {
-        if (NULL != coverage) {
+        if (coverage) {
             *coverage = SkScalarAve(len0, len1);
         }
         return true;
     }
     return false;
 }
 
 void SkDraw::drawRRect(const SkRRect& rrect, const SkPaint& paint) const {
     SkDEBUGCODE(this->validate());
 
@@ skipping 1170 matching lines @@
 
     str->append(")");
 }
 #endif
 
 void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count,
                           const SkPoint vertices[], const SkPoint textures[],
                           const SkColor colors[], SkXfermode* xmode,
                           const uint16_t indices[], int indexCount,
                           const SkPaint& paint) const {
-    SkASSERT(0 == count || NULL != vertices);
+    SkASSERT(0 == count || vertices);
 
     // abort early if there is nothing to draw
     if (count < 3 || (indices && indexCount < 3) || fRC->isEmpty()) {
         return;
     }
 
     // transform out vertices into device coordinates
     SkAutoSTMalloc<16, SkPoint> storage(count);
     SkPoint* devVerts = storage.get();
     fMatrix->mapPoints(devVerts, vertices, count);
@@ skipping 17 matching lines @@
         // if we have no shader, we ignore the texture coordinates
         textures = NULL;
     } else if (NULL == textures) {
         // if we don't have texture coordinates, ignore the shader
         p.setShader(NULL);
         shader = NULL;
     }
 
     // setup the custom shader (if needed)
     SkAutoTUnref<SkComposeShader> composeShader;
-    if (NULL != colors) {
+    if (colors) {
         if (NULL == textures) {
             // just colors (no texture)
             shader = p.setShader(&triShader);
         } else {
             // colors * texture
             SkASSERT(shader);
             bool releaseMode = false;
             if (NULL == xmode) {
                 xmode = SkXfermode::Create(SkXfermode::kModulate_Mode);
                 releaseMode = true;
             }
             composeShader.reset(SkNEW_ARGS(SkComposeShader, (&triShader, shader, xmode)));
             p.setShader(composeShader);
             if (releaseMode) {
                 xmode->unref();
             }
         }
     }
 
     SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, p);
     // Abort early if we failed to create a shader context.
     if (blitter->isNullBlitter()) {
         return;
     }
 
     // setup our state and function pointer for iterating triangles
     VertState       state(count, indices, indexCount);
     VertState::Proc vertProc = state.chooseProc(vmode);
 
-    if (NULL != textures || NULL != colors) {
+    if (textures || colors) {
         while (vertProc(&state)) {
-            if (NULL != textures) {
+            if (textures) {
                 SkMatrix tempM;
                 if (texture_to_matrix(state, vertices, textures, &tempM)) {
                     SkShader::ContextRec rec(*fBitmap, p, *fMatrix);
                     rec.fLocalMatrix = &tempM;
                     if (!blitter->resetShaderContext(rec)) {
                         continue;
                     }
                 }
             }
-            if (NULL != colors) {
+            if (colors) {
                 // Find the context for triShader.
                 SkTriColorShader::TriColorShaderContext* triColorShaderContext;
 
                 SkShader::Context* shaderContext = blitter->getShaderContext();
                 SkASSERT(shaderContext);
                 if (p.getShader() == &triShader) {
                     triColorShaderContext =
                             static_cast<SkTriColorShader::TriColorShaderContext*>(shaderContext);
                 } else {
                     // The shader is a compose shader and triShader is its first shader.
@@ skipping 149 matching lines @@
         mask->fImage = SkMask::AllocImage(size);
         memset(mask->fImage, 0, mask->computeImageSize());
     }
 
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
         draw_into_mask(*mask, devPath, style);
     }
 
     return true;
 }