"NULL !=" = NULL

src/utils/debugger/SkDrawCommand.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 "SkDrawCommand.h"
@@ skipping 130 matching lines @@
         xScale *= input.width() / (float) input.height();
     }
 
     SkRect dst = SkRect::MakeXYWH(SK_Scalar1, SK_Scalar1,
                                   xScale * input.width(),
                                   yScale * input.height());
 
     canvas->clear(0xFFFFFFFF);
     canvas->drawBitmapRect(input, NULL, dst);
 
-    if (NULL != srcRect) {
+    if (srcRect) {
         SkRect r = SkRect::MakeLTRB(srcRect->fLeft * xScale + SK_Scalar1,
                                     srcRect->fTop * yScale + SK_Scalar1,
                                     srcRect->fRight * xScale + SK_Scalar1,
                                     srcRect->fBottom * yScale + SK_Scalar1);
         SkPaint p;
         p.setColor(SK_ColorRED);
         p.setStyle(SkPaint::kStroke_Style);
 
         canvas->drawRect(r, p);
     }
@@ skipping 112 matching lines @@
 void SkConcatCommand::execute(SkCanvas* canvas) {
     canvas->concat(fMatrix);
 }
 
 SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
                                          const SkPaint* paint)
     : INHERITED(DRAW_BITMAP) {
     fBitmap = bitmap;
     fLeft = left;
     fTop = top;
-    if (NULL != paint) {
+    if (paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: "));
     fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: "));
-    if (NULL != paint) {
+    if (paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void SkDrawBitmapCommand::execute(SkCanvas* canvas) {
     canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr);
 }
 
 bool SkDrawBitmapCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
     return true;
 }
 
 SkDrawBitmapMatrixCommand::SkDrawBitmapMatrixCommand(const SkBitmap& bitmap,
                                                      const SkMatrix& matrix,
                                                      const SkPaint* paint)
     : INHERITED(DRAW_BITMAP_MATRIX) {
     fBitmap = bitmap;
     fMatrix = matrix;
-    if (NULL != paint) {
+    if (paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::MatrixToString(matrix));
-    if (NULL != paint) {
+    if (paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void SkDrawBitmapMatrixCommand::execute(SkCanvas* canvas) {
     canvas->drawBitmapMatrix(fBitmap, fMatrix, fPaintPtr);
 }
 
 bool SkDrawBitmapMatrixCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
     return true;
 }
 
 SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
                                                  const SkRect& dst, const SkPaint* paint)
     : INHERITED(DRAW_BITMAP_NINE) {
     fBitmap = bitmap;
     fCenter = center;
     fDst = dst;
-    if (NULL != paint) {
+    if (paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::IRectToString(center));
     fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
-    if (NULL != paint) {
+    if (paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void SkDrawBitmapNineCommand::execute(SkCanvas* canvas) {
     canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr);
 }
 
 bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
     return true;
 }
 
 SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,
                                                  const SkRect& dst, const SkPaint* paint,
                                                  SkCanvas::DrawBitmapRectFlags flags)
     : INHERITED(DRAW_BITMAP_RECT_TO_RECT) {
     fBitmap = bitmap;
-    if (NULL != src) {
+    if (src) {
         fSrc = *src;
     } else {
         fSrc.setEmpty();
     }
     fDst = dst;
 
-    if (NULL != paint) {
+    if (paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fFlags = flags;
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    if (NULL != src) {
+    if (src) {
         fInfo.push(SkObjectParser::RectToString(*src, "Src: "));
     }
     fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
-    if (NULL != paint) {
+    if (paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
     fInfo.push(SkObjectParser::IntToString(fFlags, "Flags: "));
 }
 
 void SkDrawBitmapRectCommand::execute(SkCanvas* canvas) {
     canvas->drawBitmapRectToRect(fBitmap, this->srcRect(), fDst, fPaintPtr, fFlags);
 }
 
 bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const {
@@ skipping 103 matching lines @@
 }
 
 SkDrawPictureCommand::SkDrawPictureCommand(const SkPicture* picture,
                                            const SkMatrix* matrix,
                                            const SkPaint* paint)
     : INHERITED(DRAW_PICTURE)
     , fPicture(SkRef(picture))
     , fMatrixPtr(NULL)
     , fPaintPtr(NULL) {
 
-    if (NULL != matrix) {
+    if (matrix) {
         fMatrix = *matrix;
         fMatrixPtr = &fMatrix;
     }
-    if (NULL != paint) {
+    if (paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     }
 
     SkString* temp = new SkString;
     temp->appendf("SkPicture: L: %f T: %f R: %f B: %f",
                   picture->cullRect().fLeft, picture->cullRect().fTop,
                   picture->cullRect().fRight, picture->cullRect().fBottom);
     fInfo.push(temp);
-    if (NULL != matrix) {
+    if (matrix) {
         fInfo.push(SkObjectParser::MatrixToString(*matrix));
     }
-    if (NULL != paint) {
+    if (paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void SkDrawPictureCommand::execute(SkCanvas* canvas) {
     canvas->drawPicture(fPicture, fMatrixPtr, fPaintPtr);
 }
 
 bool SkDrawPictureCommand::render(SkCanvas* canvas) const {
     canvas->clear(0xFFFFFFFF);
@@ skipping 188 matching lines @@
     render_drrect(canvas, fOuter, fInner);
     return true;
 }
 
 SkDrawSpriteCommand::SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top,
                                          const SkPaint* paint)
     : INHERITED(DRAW_SPRITE) {
     fBitmap = bitmap;
     fLeft = left;
     fTop = top;
-    if (NULL != paint) {
+    if (paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
 
     fInfo.push(SkObjectParser::BitmapToString(bitmap));
     fInfo.push(SkObjectParser::IntToString(left, "Left: "));
     fInfo.push(SkObjectParser::IntToString(top, "Top: "));
-    if (NULL != paint) {
+    if (paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void SkDrawSpriteCommand::execute(SkCanvas* canvas) {
     canvas->drawSprite(fBitmap, fLeft, fTop, fPaintPtr);
 }
 
 bool SkDrawSpriteCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
@@ skipping 21 matching lines @@
 }
 
 SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLength,
                                                  const SkPath& path, const SkMatrix* matrix,
                                                  const SkPaint& paint)
     : INHERITED(DRAW_TEXT_ON_PATH) {
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
     fPath = path;
-    if (NULL != matrix) {
+    if (matrix) {
         fMatrix = *matrix;
     } else {
         fMatrix.setIdentity();
     }
     fPaint = paint;
 
     fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
     fInfo.push(SkObjectParser::PathToString(path));
-    if (NULL != matrix) {
+    if (matrix) {
         fInfo.push(SkObjectParser::MatrixToString(*matrix));
     }
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) {
     canvas->drawTextOnPath(fText, fByteLength, fPath,
                            fMatrix.isIdentity() ? NULL : &fMatrix,
                            fPaint);
 }
 
 SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount,
                                              const SkPoint vertices[], const SkPoint texs[],
                                              const SkColor colors[], SkXfermode* xfermode,
                                              const uint16_t indices[], int indexCount,
                                              const SkPaint& paint)
     : INHERITED(DRAW_VERTICES) {
     fVmode = vmode;
 
     fVertexCount = vertexCount;
 
     fVertices = new SkPoint[vertexCount];
     memcpy(fVertices, vertices, vertexCount * sizeof(SkPoint));
 
-    if (NULL != texs) {
+    if (texs) {
         fTexs = new SkPoint[vertexCount];
         memcpy(fTexs, texs, vertexCount * sizeof(SkPoint));
     } else {
         fTexs = NULL;
     }
 
-    if (NULL != colors) {
+    if (colors) {
         fColors = new SkColor[vertexCount];
         memcpy(fColors, colors, vertexCount * sizeof(SkColor));
     } else {
         fColors = NULL;
     }
 
     fXfermode = xfermode;
-    if (NULL != fXfermode) {
+    if (fXfermode) {
         fXfermode->ref();
     }
 
     if (indexCount > 0) {
         fIndices = new uint16_t[indexCount];
         memcpy(fIndices, indices, indexCount * sizeof(uint16_t));
     } else {
         fIndices = NULL;
     }
 
@@ skipping 51 matching lines @@
     canvas->save();
 }
 
 void SkSaveCommand::trackSaveState(int* state) {
     (*state)++;
 }
 
 SkSaveLayerCommand::SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint,
                                        SkCanvas::SaveFlags flags)
     : INHERITED(SAVE_LAYER) {
-    if (NULL != bounds) {
+    if (bounds) {
         fBounds = *bounds;
     } else {
         fBounds.setEmpty();
     }
 
-    if (NULL != paint) {
+    if (paint) {
         fPaint = *paint;
         fPaintPtr = &fPaint;
     } else {
         fPaintPtr = NULL;
     }
     fFlags = flags;
 
-    if (NULL != bounds) {
+    if (bounds) {
         fInfo.push(SkObjectParser::RectToString(*bounds, "Bounds: "));
     }
-    if (NULL != paint) {
+    if (paint) {
         fInfo.push(SkObjectParser::PaintToString(*paint));
     }
     fInfo.push(SkObjectParser::SaveFlagsToString(flags));
 }
 
 void SkSaveLayerCommand::execute(SkCanvas* canvas) {
     canvas->saveLayer(fBounds.isEmpty() ? NULL : &fBounds,
                       fPaintPtr,
                       fFlags);
 }
@@ skipping 73 matching lines @@
     p.setColor(SK_ColorCYAN);
     p.setStyle(SkPaint::kStroke_Style);
     canvas->drawRect(fCullRect, p);
 }
 
 SkPopCullCommand::SkPopCullCommand() : INHERITED(POP_CULL) { }
 
 void SkPopCullCommand::execute(SkCanvas* canvas) {
     canvas->popCull();
 }