"NULL !=" = NULL

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
@@ skipping 727 matching lines @@
             SkSafeRef(fPrevTarget);
             context->setRenderTarget(target);
             fContext = context;
         }
         AutoRenderTarget(GrContext* context) {
             fPrevTarget = context->getRenderTarget();
             SkSafeRef(fPrevTarget);
             fContext = context;
         }
         ~AutoRenderTarget() {
-            if (NULL != fContext) {
+            if (fContext) {
                 fContext->setRenderTarget(fPrevTarget);
             }
             SkSafeUnref(fPrevTarget);
         }
     private:
         GrContext*      fContext;
         GrRenderTarget* fPrevTarget;
     };
 
     /**
@@ skipping 13 matching lines @@
     class AutoMatrix : public ::SkNoncopyable {
     public:
         AutoMatrix() : fContext(NULL) {}
 
         ~AutoMatrix() { this->restore(); }
 
         /**
          * Initializes by pre-concat'ing the context's current matrix with the preConcat param.
          */
         void setPreConcat(GrContext* context, const SkMatrix& preConcat, GrPaint* paint = NULL) {
-            SkASSERT(NULL != context);
+            SkASSERT(context);
 
             this->restore();
 
             fContext = context;
             fMatrix = context->getMatrix();
             this->preConcat(preConcat, paint);
         }
 
         /**
          * Sets the context's matrix to identity. Returns false if the inverse matrix is required to
          * update a paint but the matrix cannot be inverted.
          */
         bool setIdentity(GrContext* context, GrPaint* paint = NULL) {
-            SkASSERT(NULL != context);
+            SkASSERT(context);
 
             this->restore();
 
-            if (NULL != paint) {
+            if (paint) {
                 if (!paint->localCoordChangeInverse(context->getMatrix())) {
                     return false;
                 }
             }
             fMatrix = context->getMatrix();
             fContext = context;
             context->setIdentityMatrix();
             return true;
         }
 
         /**
          * Replaces the context's matrix with a new matrix. Returns false if the inverse matrix is
          * required to update a paint but the matrix cannot be inverted.
          */
         bool set(GrContext* context, const SkMatrix& newMatrix, GrPaint* paint = NULL) {
-            if (NULL != paint) {
+            if (paint) {
                 if (!this->setIdentity(context, paint)) {
                     return false;
                 }
                 this->preConcat(newMatrix, paint);
             } else {
                 this->restore();
                 fContext = context;
                 fMatrix = context->getMatrix();
                 context->setMatrix(newMatrix);
             }
             return true;
         }
 
         /**
          * If this has been initialized then the context's matrix will be further updated by
          * pre-concat'ing the preConcat param. The matrix that will be restored remains unchanged.
          * The paint is assumed to be relative to the context's matrix at the time this call is
          * made, not the matrix at the time AutoMatrix was first initialized. In other words, this
          * performs an incremental update of the paint.
          */
         void preConcat(const SkMatrix& preConcat, GrPaint* paint = NULL) {
-            if (NULL != paint) {
+            if (paint) {
                 paint->localCoordChange(preConcat);
             }
             fContext->concatMatrix(preConcat);
         }
 
         /**
          * Returns false if never initialized or the inverse matrix was required to update a paint
          * but the matrix could not be inverted.
          */
-        bool succeeded() const { return NULL != fContext; }
+        bool succeeded() const { return SkToBool(fContext); }
 
         /**
          * If this has been initialized then the context's original matrix is restored.
          */
         void restore() {
-            if (NULL != fContext) {
+            if (fContext) {
                 fContext->setMatrix(fMatrix);
                 fContext = NULL;
             }
         }
 
     private:
         GrContext*  fContext;
         SkMatrix    fMatrix;
     };
 
@@ skipping 18 matching lines @@
         AutoClip(GrContext* context, const SkRect& newClipRect)
         : fContext(context)
         , fNewClipStack(newClipRect) {
             fNewClipData.fClipStack = &fNewClipStack;
 
             fOldClip = fContext->getClip();
             fContext->setClip(&fNewClipData);
         }
 
         ~AutoClip() {
-            if (NULL != fContext) {
+            if (fContext) {
                 fContext->setClip(fOldClip);
             }
         }
     private:
         GrContext*        fContext;
         const GrClipData* fOldClip;
 
         SkClipStack       fNewClipStack;
         GrClipData        fNewClipData;
     };
@@ skipping 180 matching lines @@
       : fContext(NULL)
       , fTexture(NULL) {
       this->set(context, desc, match);
     }
 
     ~GrAutoScratchTexture() {
         this->reset();
     }
 
     void reset() {
-        if (NULL != fContext && NULL != fTexture) {
+        if (fContext && fTexture) {
             fContext->unlockScratchTexture(fTexture);
             fTexture->unref();
             fTexture = NULL;
         }
     }
 
     /*
      * When detaching a texture we do not unlock it in the texture cache but
      * we do set the returnToCache flag. In this way the texture remains
      * "locked" in the texture cache until it is freed and recycled in
@@ skipping 12 matching lines @@
         GrTexture* texture = fTexture;
         fTexture = NULL;
 
         // This GrAutoScratchTexture has a ref from lockAndRefScratchTexture, which we give up now.
         // The cache also has a ref which we are lending to the caller of detach(). When the caller
         // lets go of the ref and the ref count goes to 0 internal_dispose will see this flag is
         // set and re-ref the texture, thereby restoring the cache's ref.
         SkASSERT(!texture->unique());
         texture->impl()->setFlag((GrTextureFlags) GrTextureImpl::kReturnToCache_FlagBit);
         texture->unref();
-        SkASSERT(NULL != texture->getCacheEntry());
+        SkASSERT(texture->getCacheEntry());
 
         return texture;
     }
 
     GrTexture* set(GrContext* context,
                    const GrTextureDesc& desc,
                    GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch) {
         this->reset();
 
         fContext = context;
-        if (NULL != fContext) {
+        if (fContext) {
             fTexture = fContext->lockAndRefScratchTexture(desc, match);
             if (NULL == fTexture) {
                 fContext = NULL;
             }
             return fTexture;
         } else {
             return NULL;
         }
     }
 
     GrTexture* texture() { return fTexture; }
 
 private:
     GrContext*                    fContext;
     GrTexture*                    fTexture;
 };
 
 #endif