"NULL !=" = NULL

src/gpu/GrAAHairLinePathRenderer.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 "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 666 matching lines @@
         (*vert)[1].fCoverage = coverage;
         (*vert)[2].fPos = a - vec + ortho;
         (*vert)[2].fCoverage = 0;
         (*vert)[3].fPos = b + vec + ortho;
         (*vert)[3].fCoverage = 0;
         (*vert)[4].fPos = a - vec - ortho;
         (*vert)[4].fCoverage = 0;
         (*vert)[5].fPos = b + vec - ortho;
         (*vert)[5].fCoverage = 0;
 
-        if (NULL != toSrc) {
+        if (toSrc) {
             toSrc->mapPointsWithStride(&(*vert)->fPos,
                                        sizeof(LineVertex),
                                        kVertsPerLineSeg);
         }
     } else {
         // just make it degenerate and likely offscreen
         for (int i = 0; i < kVertsPerLineSeg; ++i) {
             (*vert)[i].fPos.set(SK_ScalarMax, SK_ScalarMax);
         }
     }
@@ skipping 103 matching lines @@
     // Seed the dev bounds with some pts known to be inside. Each quad and conic grows the bounding
     // box to include its vertices.
     SkPoint seedPts[2];
     if (quadCnt) {
         seedPts[0] = quads[0];
         seedPts[1] = quads[2];
     } else if (conicCnt) {
         seedPts[0] = conics[0];
         seedPts[1] = conics[2];
     }
-    if (NULL != toDevice) {
+    if (toDevice) {
         toDevice->mapPoints(seedPts, 2);
     }
     devBounds->set(seedPts[0], seedPts[1]);
 
     int unsubdivQuadCnt = quads.count() / 3;
     for (int i = 0; i < unsubdivQuadCnt; ++i) {
         SkASSERT(qSubdivs[i] >= 0);
         add_quads(&quads[3*i], qSubdivs[i], toDevice, toSrc, &verts, devBounds);
     }
 
@@ skipping 170 matching lines @@
 
         static const int kEdgeAttrIndex = 1;
 
         // Check devBounds
         SkASSERT(check_bounds<BezierVertex>(drawState, devBounds, arg.vertices(),
                                             kVertsPerQuad * quadCnt + kVertsPerQuad * conicCnt));
 
         if (quadCnt > 0) {
             GrEffect* hairQuadEffect = GrQuadEffect::Create(kHairlineAA_GrEffectEdgeType,
                                                             *target->caps());
-            SkASSERT(NULL != hairQuadEffect);
+            SkASSERT(hairQuadEffect);
             GrDrawState::AutoRestoreEffects are(drawState);
             target->setIndexSourceToBuffer(fQuadsIndexBuffer);
             drawState->setGeometryProcessor(hairQuadEffect, kEdgeAttrIndex)->unref();
             int quads = 0;
             while (quads < quadCnt) {
                 int n = SkTMin(quadCnt - quads, kNumQuadsInIdxBuffer);
                 target->drawIndexed(kTriangles_GrPrimitiveType,
                                     kVertsPerQuad*quads,               // startV
                                     0,                                 // startI
                                     kVertsPerQuad*n,                   // vCount
                                     kIdxsPerQuad*n,                    // iCount
                                     &devBounds);
                 quads += n;
             }
         }
 
         if (conicCnt > 0) {
             GrDrawState::AutoRestoreEffects are(drawState);
             GrEffect* hairConicEffect = GrConicEffect::Create(kHairlineAA_GrEffectEdgeType,
                                                               *target->caps());
-            SkASSERT(NULL != hairConicEffect);
+            SkASSERT(hairConicEffect);
             drawState->setGeometryProcessor(hairConicEffect, 1, 2)->unref();
             int conics = 0;
             while (conics < conicCnt) {
                 int n = SkTMin(conicCnt - conics, kNumQuadsInIdxBuffer);
                 target->drawIndexed(kTriangles_GrPrimitiveType,
                                     kVertsPerQuad*(quadCnt + conics),  // startV
                                     0,                                 // startI
                                     kVertsPerQuad*n,                   // vCount
                                     kIdxsPerQuad*n,                    // iCount
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }