"NULL !=" = NULL

tools/PictureRenderer.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 "PictureRenderer.h"
 #include "picture_utils.h"
 #include "SamplePipeControllers.h"
@@ skipping 42 matching lines @@
                            const SkString* mismatchPath,
                            const SkString* inputFilename,
                            bool useChecksumBasedFilenames) {
     this->CopyString(&fWritePath, writePath);
     this->CopyString(&fMismatchPath, mismatchPath);
     this->CopyString(&fInputFilename, inputFilename);
     fUseChecksumBasedFilenames = useChecksumBasedFilenames;
 
     SkASSERT(NULL == fPicture);
     SkASSERT(NULL == fCanvas.get());
-    if (NULL != fPicture || NULL != fCanvas.get()) {
+    if (fPicture || fCanvas.get()) {
         return;
     }
 
     SkASSERT(pict != NULL);
     if (NULL == pict) {
         return;
     }
 
     fPicture.reset(pict)->ref();
     fCanvas.reset(this->setupCanvas());
 }
 
 void PictureRenderer::CopyString(SkString* dest, const SkString* src) {
-    if (NULL != src) {
+    if (src) {
         dest->set(*src);
     } else {
         dest->reset();
     }
 }
 
 class FlagsDrawFilter : public SkDrawFilter {
 public:
     FlagsDrawFilter(PictureRenderer::DrawFilterFlags* flags) :
         fFlags(flags) {}
 
     virtual bool filter(SkPaint* paint, Type t) {
         paint->setFlags(paint->getFlags() & ~fFlags[t] & SkPaint::kAllFlags);
         if (PictureRenderer::kMaskFilter_DrawFilterFlag & fFlags[t]) {
             SkMaskFilter* maskFilter = paint->getMaskFilter();
-            if (NULL != maskFilter) {
+            if (maskFilter) {
                 paint->setMaskFilter(NULL);
             }
         }
         if (PictureRenderer::kHinting_DrawFilterFlag & fFlags[t]) {
             paint->setHinting(SkPaint::kNo_Hinting);
         } else if (PictureRenderer::kSlightHinting_DrawFilterFlag & fFlags[t]) {
             paint->setHinting(SkPaint::kSlight_Hinting);
         }
         return true;
     }
@@ skipping 101 matching lines @@
         height = SkMin32(height, fViewport.height());
     }
     return height;
 }
 
 /** Converts fPicture to a picture that uses a BBoxHierarchy.
  *  PictureRenderer subclasses that are used to test picture playback
  *  should call this method during init.
  */
 void PictureRenderer::buildBBoxHierarchy() {
-    SkASSERT(NULL != fPicture);
-    if (kNone_BBoxHierarchyType != fBBoxHierarchyType && NULL != fPicture) {
+    SkASSERT(fPicture);
+    if (kNone_BBoxHierarchyType != fBBoxHierarchyType && fPicture) {
         SkAutoTDelete<SkBBHFactory> factory(this->getFactory());
         SkPictureRecorder recorder;
         SkCanvas* canvas = recorder.beginRecording(fPicture->cullRect().width(), 
                                                    fPicture->cullRect().height(),
                                                    factory.get(),
                                                    this->recordFlags());
         fPicture->playback(canvas);
         fPicture.reset(recorder.endRecording());
     }
 }
@@ skipping 71 matching lines @@
     SkString outputFilename;
     const char *outputSubdirPtr = NULL;
     if (useChecksumBasedFilenames) {
         ImageDigest *imageDigestPtr = bitmapAndDigest.getImageDigestPtr();
         outputSubdirPtr = escapedInputFilename.c_str();
         outputFilename.set(imageDigestPtr->getHashType());
         outputFilename.append("_");
         outputFilename.appendU64(imageDigestPtr->getHashValue());
     } else {
         outputFilename.set(escapedInputFilename);
-        if (NULL != tileNumberPtr) {
+        if (tileNumberPtr) {
             outputFilename.append("-tile");
             outputFilename.appendS32(*tileNumberPtr);
         }
     }
     outputFilename.append(".png");
 
-    if (NULL != jsonSummaryPtr) {
+    if (jsonSummaryPtr) {
         ImageDigest *imageDigestPtr = bitmapAndDigest.getImageDigestPtr();
         SkString outputRelativePath;
         if (outputSubdirPtr) {
             outputRelativePath.set(outputSubdirPtr);
             outputRelativePath.append("/");  // always use "/", even on Windows
             outputRelativePath.append(outputFilename);
         } else {
             outputRelativePath.set(outputFilename);
         }
 
@@ skipping 59 matching lines @@
     if (NULL == fCanvas.get() || NULL == fPicture) {
         return false;
     }
 
     PipeController pipeController(fCanvas.get());
     SkGPipeWriter writer;
     SkCanvas* pipeCanvas = writer.startRecording(&pipeController);
     pipeCanvas->drawPicture(fPicture);
     writer.endRecording();
     fCanvas->flush();
-    if (NULL != out) {
+    if (out) {
         *out = SkNEW(SkBitmap);
         setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), 
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         fCanvas->readPixels(*out, 0, 0);
     }
     if (fEnableWrites) {
         return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
                      fUseChecksumBasedFilenames);
     } else {
         return true;
     }
 }
 
 SkString PipePictureRenderer::getConfigNameInternal() {
     return SkString("pipe");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void SimplePictureRenderer::init(const SkPicture* picture, const SkString* writePath,
                                  const SkString* mismatchPath, const SkString* inputFilename,
                                  bool useChecksumBasedFilenames) {
     INHERITED::init(picture, writePath, mismatchPath, inputFilename, useChecksumBasedFilenames);
     this->buildBBoxHierarchy();
 }
 
 bool SimplePictureRenderer::render(SkBitmap** out) {
     SkASSERT(fCanvas.get() != NULL);
-    SkASSERT(NULL != fPicture);
+    SkASSERT(fPicture);
     if (NULL == fCanvas.get() || NULL == fPicture) {
         return false;
     }
 
     fCanvas->drawPicture(fPicture);
     fCanvas->flush();
-    if (NULL != out) {
+    if (out) {
         *out = SkNEW(SkBitmap);
         setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), 
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         fCanvas->readPixels(*out, 0, 0);
     }
     if (fEnableWrites) {
         return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
                      fUseChecksumBasedFilenames);
     } else {
         return true;
@@ skipping 18 matching lines @@
     , fTileWidthPercentage(0.0)
     , fTileHeightPercentage(0.0)
     , fTileMinPowerOf2Width(0)
     , fCurrentTileOffset(-1)
     , fTilesX(0)
     , fTilesY(0) { }
 
 void TiledPictureRenderer::init(const SkPicture* pict, const SkString* writePath,
                                 const SkString* mismatchPath, const SkString* inputFilename,
                                 bool useChecksumBasedFilenames) {
-    SkASSERT(NULL != pict);
+    SkASSERT(pict);
     SkASSERT(0 == fTileRects.count());
     if (NULL == pict || fTileRects.count() != 0) {
         return;
     }
 
     // Do not call INHERITED::init(), which would create a (potentially large) canvas which is not
     // used by bench_pictures.
     fPicture.reset(pict)->ref();
     this->CopyString(&fWritePath, writePath);
     this->CopyString(&fMismatchPath, mismatchPath);
@@ skipping 174 matching lines @@
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         setup_bitmap(&bitmap, fTileWidth, fTileHeight);
     }
     bool success = true;
     for (int i = 0; i < fTileRects.count(); ++i) {
         draw_tile_to_canvas(fCanvas, fTileRects[i], fPicture);
         if (fEnableWrites) {
             success &= write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
                              fUseChecksumBasedFilenames, &i);
         }
-        if (NULL != out) {
+        if (out) {
             if (fCanvas->readPixels(&bitmap, 0, 0)) {
                 // Add this tile to the entire bitmap.
                 bitmapCopyAtOffset(bitmap, *out, SkScalarFloorToInt(fTileRects[i].left()),
                                    SkScalarFloorToInt(fTileRects[i].top()));
             } else {
                 success = false;
             }
         }
     }
     return success;
 }
 
 SkCanvas* TiledPictureRenderer::setupCanvas(int width, int height) {
     SkCanvas* canvas = this->INHERITED::setupCanvas(width, height);
-    SkASSERT(NULL != fPicture);
+    SkASSERT(fPicture);
     // Clip the tile to an area that is completely inside both the SkPicture and the viewport. This
     // is mostly important for tiles on the right and bottom edges as they may go over this area and
     // the picture may have some commands that draw outside of this area and so should not actually
     // be written.
     // Uses a clipRegion so that it will be unaffected by the scale factor, which may have been set
     // by INHERITED::setupCanvas.
     SkRegion clipRegion;
     clipRegion.setRect(0, 0, this->getViewWidth(), this->getViewHeight());
     canvas->clipRegion(clipRegion);
     return canvas;
@@ skipping 89 matching lines @@
 PictureRenderer* CreateGatherPixelRefsRenderer(const GrContext::Options& opts) {
     return SkNEW_ARGS(GatherRenderer, (opts));
 }
 #else
 PictureRenderer* CreateGatherPixelRefsRenderer() {
     return SkNEW(GatherRenderer);
 }
 #endif
 
 } // namespace sk_tools