"NULL !=" = NULL

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
@@ skipping 113 matching lines @@
 
     virtual void onChange() SK_OVERRIDE {
         const GrResourceInvalidatedMessage message = { fKey };
         SkMessageBus<GrResourceInvalidatedMessage>::Post(message);
     }
 };
 
 }  // namespace
 
 static void add_genID_listener(GrResourceKey key, SkPixelRef* pixelRef) {
-    SkASSERT(NULL != pixelRef);
+    SkASSERT(pixelRef);
     pixelRef->addGenIDChangeListener(SkNEW_ARGS(GrResourceInvalidator, (key)));
 }
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
 static GrTexture *load_etc1_texture(GrContext* ctx,
                                     const GrTextureParams* params,
                                     const SkBitmap &bm, GrTextureDesc desc) {
     SkAutoTUnref<SkData> data(bm.pixelRef()->refEncodedData());
 
     // Is this even encoded data?
@@ skipping 36 matching lines @@
     } else {
         return NULL;
     }
 
     // This texture is likely to be used again so leave it in the cache
     GrCacheID cacheID;
     generate_bitmap_cache_id(bm, &cacheID);
 
     GrResourceKey key;
     GrTexture* result = ctx->createTexture(params, desc, cacheID, bytes, 0, &key);
-    if (NULL != result) {
+    if (result) {
         add_genID_listener(key, bm.pixelRef());
     }
     return result;
 }
 #endif   // SK_IGNORE_ETC1_SUPPORT
 
 static GrTexture *load_yuv_texture(GrContext* ctx, const GrTextureParams* params,
                                    const SkBitmap& bm, const GrTextureDesc& desc) {
     GrTexture* result = NULL;
     
@@ skipping 41 matching lines @@
                     kRenderTarget_GrTextureFlagBit |
                     kNoStencil_GrTextureFlagBit;
 
     // This texture is likely to be used again so leave it in the cache
     GrCacheID cacheID;
     generate_bitmap_cache_id(bm, &cacheID);
 
     GrResourceKey key;
     result = ctx->createTexture(params, rtDesc, cacheID, NULL, 0, &key);
     GrRenderTarget* renderTarget = result ? result->asRenderTarget() : NULL;
-    if (NULL != renderTarget) {
+    if (renderTarget) {
         add_genID_listener(key, bm.pixelRef());
         SkAutoTUnref<GrEffect> yuvToRgbEffect(GrYUVtoRGBEffect::Create(
             yuvTextures[0].texture(), yuvTextures[1].texture(), yuvTextures[2].texture()));
         GrPaint paint;
         paint.addColorEffect(yuvToRgbEffect);
         SkRect r = SkRect::MakeWH(SkIntToScalar(yuvSizes[0].fWidth),
                                   SkIntToScalar(yuvSizes[0].fHeight));
         GrContext::AutoRenderTarget autoRT(ctx, renderTarget);
         GrContext::AutoMatrix am;
         am.setIdentity(ctx);
@@ skipping 30 matching lines @@
             // our compressed data will be trimmed, so pass width() for its
             // "rowBytes", since they are the same now.
 
             if (cache) {
                 GrCacheID cacheID;
                 generate_bitmap_cache_id(origBitmap, &cacheID);
 
                 GrResourceKey key;
                 GrTexture* result = ctx->createTexture(params, desc, cacheID,
                                                        storage.get(), bitmap->width(), &key);
-                if (NULL != result) {
+                if (result) {
                     add_genID_listener(key, origBitmap.pixelRef());
                 }
                 return result;
             } else {
                 GrTexture* result = ctx->lockAndRefScratchTexture(desc,
                                                             GrContext::kExact_ScratchTexMatch);
                 result->writePixels(0, 0, bitmap->width(),
                                     bitmap->height(), desc.fConfig,
                                     storage.get());
                 return result;
@@ skipping 14 matching lines @@
         cache
         // Make sure that the underlying device supports ETC1 textures before we go ahead
         // and check the data.
         && ctx->getGpu()->caps()->isConfigTexturable(kETC1_GrPixelConfig)
         // If the bitmap had compressed data and was then uncompressed, it'll still return
         // compressed data on 'refEncodedData' and upload it. Probably not good, since if
         // the bitmap has available pixels, then they might not be what the decompressed
         // data is.
         && !(bitmap->readyToDraw())) {
         GrTexture *texture = load_etc1_texture(ctx, params, *bitmap, desc);
-        if (NULL != texture) {
+        if (texture) {
             return texture;
         }
     }
 #endif   // SK_IGNORE_ETC1_SUPPORT
 
     else {
         GrTexture *texture = load_yuv_texture(ctx, params, *bitmap, desc);
-        if (NULL != texture) {
+        if (texture) {
             return texture;
         }
     }
     SkAutoLockPixels alp(*bitmap);
     if (!bitmap->readyToDraw()) {
         return NULL;
     }
     if (cache) {
         // This texture is likely to be used again so leave it in the cache
         GrCacheID cacheID;
         generate_bitmap_cache_id(origBitmap, &cacheID);
 
         GrResourceKey key;
         GrTexture* result = ctx->createTexture(params, desc, cacheID,
                                                bitmap->getPixels(), bitmap->rowBytes(), &key);
-        if (NULL != result) {
+        if (result) {
             add_genID_listener(key, origBitmap.pixelRef());
         }
         return result;
    } else {
         // This texture is unlikely to be used again (in its present form) so
         // just use a scratch texture. This will remove the texture from the
         // cache so no one else can find it. Additionally, once unlocked, the
         // scratch texture will go to the end of the list for purging so will
         // likely be available for this volatile bitmap the next time around.
         GrTexture* result = ctx->lockAndRefScratchTexture(desc, GrContext::kExact_ScratchTexMatch);
@@ skipping 39 matching lines @@
         result = sk_gr_create_bitmap_texture(ctx, cache, params, bitmap);
     }
     if (NULL == result) {
         GrPrintf("---- failed to create texture for cache [%d %d]\n",
                     bitmap.width(), bitmap.height());
     }
     return result;
 }
 
 void GrUnlockAndUnrefCachedBitmapTexture(GrTexture* texture) {
-    SkASSERT(NULL != texture->getContext());
+    SkASSERT(texture->getContext());
 
     texture->getContext()->unlockScratchTexture(texture);
     texture->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // alphatype is ignore for now, but if GrPixelConfig is expanded to encompass
 // alpha info, that will be considered.
 GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType ct, SkAlphaType) {
@@ skipping 54 matching lines @@
 
     grPaint->setDither(skPaint.isDither());
     grPaint->setAntiAlias(skPaint.isAntiAlias());
 
     SkXfermode::Coeff sm;
     SkXfermode::Coeff dm;
 
     SkXfermode* mode = skPaint.getXfermode();
     GrEffect* xferEffect = NULL;
     if (SkXfermode::AsNewEffectOrCoeff(mode, &xferEffect, &sm, &dm)) {
-        if (NULL != xferEffect) {
+        if (xferEffect) {
             grPaint->addColorEffect(xferEffect)->unref();
             sm = SkXfermode::kOne_Coeff;
             dm = SkXfermode::kZero_Coeff;
         }
     } else {
         //SkDEBUGCODE(SkDebugf("Unsupported xfer mode.\n");)
         // Fall back to src-over
         sm = SkXfermode::kOne_Coeff;
         dm = SkXfermode::kISA_Coeff;
     }
     grPaint->setBlendFunc(sk_blend_to_grblend(sm), sk_blend_to_grblend(dm));
     
     //set the color of the paint to the one of the parameter
     grPaint->setColor(paintColor);
 
     SkColorFilter* colorFilter = skPaint.getColorFilter();
-    if (NULL != colorFilter) {
+    if (colorFilter) {
         // if the source color is a constant then apply the filter here once rather than per pixel
         // in a shader.
         if (constantColor) {
             SkColor filtered = colorFilter->filterColor(skPaint.getColor());
             grPaint->setColor(SkColor2GrColor(filtered));
         } else {
             SkAutoTUnref<GrEffect> effect(colorFilter->asNewEffect(context));
-            if (NULL != effect.get()) {
+            if (effect.get()) {
                 grPaint->addColorEffect(effect);
             }
         }
     }
 
 #ifndef SK_IGNORE_GPU_DITHER
     // If the dither flag is set, then we need to see if the underlying context
     // supports it. If not, then install a dither effect.
     if (skPaint.isDither() && grPaint->numColorStages() > 0) {
         // What are we rendering into?
         const GrRenderTarget *target = context->getRenderTarget();
-        SkASSERT(NULL != target);
+        SkASSERT(target);
 
         // Suspect the dithering flag has no effect on these configs, otherwise
         // fall back on setting the appropriate state.
         if (target->config() == kRGBA_8888_GrPixelConfig ||
             target->config() == kBGRA_8888_GrPixelConfig) {
             // The dither flag is set and the target is likely
             // not going to be dithered by the GPU.
             SkAutoTUnref<GrEffect> effect(GrDitherEffect::Create());
-            if (NULL != effect.get()) {
+            if (effect.get()) {
                 grPaint->addColorEffect(effect);
                 grPaint->setDither(false);
             }
         }
     }
 #endif
 }
 
 /**
  * Unlike GrContext::AutoMatrix, this doesn't require setting a new matrix. GrContext::AutoMatrix
  * likes to set the new matrix in its constructor because it is usually necessary to simulataneously
  * update a GrPaint. This AutoMatrix is used while initially setting up GrPaint, however.
  */
 class AutoMatrix {
 public:
     AutoMatrix(GrContext* context) {
         fMatrix = context->getMatrix();
         fContext = context;
     }
     ~AutoMatrix() {
-        SkASSERT(NULL != fContext);
+        SkASSERT(fContext);
         fContext->setMatrix(fMatrix);
     }
 private:
     GrContext* fContext;
     SkMatrix fMatrix;
 };
 
 void SkPaint2GrPaintShader(GrContext* context, const SkPaint& skPaint,
                            bool constantColor, GrPaint* grPaint) {
     SkShader* shader = skPaint.getShader();
@@ skipping 12 matching lines @@
         // SkShader::asNewEffect() may do offscreen rendering. Save off the current RT, clip, and
         // matrix. We don't reset the matrix on the context because SkShader::asNewEffect may use
         // GrContext::getMatrix() to know the transformation from local coords to device space.
         GrContext::AutoRenderTarget art(context, NULL);
         GrContext::AutoClip ac(context, GrContext::AutoClip::kWideOpen_InitialClip);
         AutoMatrix am(context);
 
         // Allow the shader to modify paintColor and also create an effect to be installed as
         // the first color effect on the GrPaint.
         GrEffect* effect = NULL;
-        if (shader->asNewEffect(context, skPaint, NULL, &paintColor, &effect) && NULL != effect) {
+        if (shader->asNewEffect(context, skPaint, NULL, &paintColor, &effect) && effect) {
             grPaint->addColorEffect(effect)->unref();
             constantColor = false;
         }
     }
 
     // The grcolor is automatically set when calling asneweffect.
     // If the shader can be seen as an effect it returns true and adds its effect to the grpaint.
     SkPaint2GrPaintNoShader(context, skPaint, paintColor, constantColor, grPaint);
 }