"NULL !=" = NULL

src/device/xps/SkXPSDevice.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.
  */
 
 #ifndef UNICODE
 #define UNICODE
 #endif
@@ skipping 791 matching lines @@
         HRM(clampBrush->SetTileMode(SkToXpsTileMode[xy[0]][xy[1]]),
             "Could not set tile mode on visual brush for image brush.");
         HRM(clampBrush->SetOpacity(alpha / 255.0f),
             "Could not set opacity on visual brush for image brush.");
 
         HRM(clampBrush->QueryInterface(xpsBrush), "QI failed.");
     }
 
     SkTScopedComPtr<IXpsOMMatrixTransform> xpsMatrixToUse;
     HR(this->createXpsTransform(localMatrix, &xpsMatrixToUse));
-    if (NULL != xpsMatrixToUse.get()) {
+    if (xpsMatrixToUse.get()) {
         HRM((*xpsBrush)->SetTransformLocal(xpsMatrixToUse.get()),
             "Could not set transform for image brush.");
     } else {
         //TODO(bungeman): perspective bitmaps in general.
     }
 
     return S_OK;
 }
 
 HRESULT SkXPSDevice::createXpsGradientStop(const SkColor skColor,
                                            const SkScalar offset,
                                            IXpsOMGradientStop** xpsGradStop) {
     XPS_COLOR gradStopXpsColor = xps_color(skColor);
     HRM(this->fXpsFactory->CreateGradientStop(&gradStopXpsColor,
                                               NULL,
                                               SkScalarToFLOAT(offset),
                                               xpsGradStop),
         "Could not create gradient stop.");
     return S_OK;
 }
 
 HRESULT SkXPSDevice::createXpsLinearGradient(SkShader::GradientInfo info,
                                              const SkAlpha alpha,
                                              const SkMatrix& localMatrix,
                                              IXpsOMMatrixTransform* xpsMatrix,
                                              IXpsOMBrush** xpsBrush) {
     XPS_POINT startPoint;
     XPS_POINT endPoint;
-    if (NULL != xpsMatrix) {
+    if (xpsMatrix) {
         startPoint = xps_point(info.fPoint[0]);
         endPoint = xps_point(info.fPoint[1]);
     } else {
         transform_offsets(info.fColorOffsets, info.fColorCount,
                           info.fPoint[0], info.fPoint[1],
                           localMatrix);
         startPoint = xps_point(info.fPoint[0], localMatrix);
         endPoint = xps_point(info.fPoint[1], localMatrix);
     }
 
     SkTScopedComPtr<IXpsOMGradientStop> gradStop0;
     HR(createXpsGradientStop(info.fColors[0],
                              info.fColorOffsets[0],
                              &gradStop0));
 
     SkTScopedComPtr<IXpsOMGradientStop> gradStop1;
     HR(createXpsGradientStop(info.fColors[1],
                              info.fColorOffsets[1],
                              &gradStop1));
 
     SkTScopedComPtr<IXpsOMLinearGradientBrush> gradientBrush;
     HRM(this->fXpsFactory->CreateLinearGradientBrush(gradStop0.get(),
                                                      gradStop1.get(),
                                                      &startPoint,
                                                      &endPoint,
                                                      &gradientBrush),
         "Could not create linear gradient brush.");
-    if (NULL != xpsMatrix) {
+    if (xpsMatrix) {
         HRM(gradientBrush->SetTransformLocal(xpsMatrix),
             "Could not set transform on linear gradient brush.");
     }
 
     SkTScopedComPtr<IXpsOMGradientStopCollection> gradStopCollection;
     HRM(gradientBrush->GetGradientStops(&gradStopCollection),
         "Could not get linear gradient stop collection.");
     for (int i = 2; i < info.fColorCount; ++i) {
         SkTScopedComPtr<IXpsOMGradientStop> gradStop;
         HR(createXpsGradientStop(info.fColors[i],
@@ skipping 25 matching lines @@
 
     SkTScopedComPtr<IXpsOMGradientStop> gradStop1;
     HR(createXpsGradientStop(info.fColors[1],
                              info.fColorOffsets[1],
                              &gradStop1));
 
     //TODO: figure out how to fake better if not affine
     XPS_POINT centerPoint;
     XPS_POINT gradientOrigin;
     XPS_SIZE radiiSizes;
-    if (NULL != xpsMatrix) {
+    if (xpsMatrix) {
         centerPoint = xps_point(info.fPoint[0]);
         gradientOrigin = xps_point(info.fPoint[0]);
         radiiSizes.width = SkScalarToFLOAT(info.fRadius[0]);
         radiiSizes.height = SkScalarToFLOAT(info.fRadius[0]);
     } else {
         centerPoint = xps_point(info.fPoint[0], localMatrix);
         gradientOrigin = xps_point(info.fPoint[0], localMatrix);
 
         SkScalar radius = info.fRadius[0];
         SkVector vec[2];
@@ skipping 10 matching lines @@
     }
 
     SkTScopedComPtr<IXpsOMRadialGradientBrush> gradientBrush;
     HRM(this->fXpsFactory->CreateRadialGradientBrush(gradStop0.get(),
                                                      gradStop1.get(),
                                                      &centerPoint,
                                                      &gradientOrigin,
                                                      &radiiSizes,
                                                      &gradientBrush),
         "Could not create radial gradient brush.");
-    if (NULL != xpsMatrix) {
+    if (xpsMatrix) {
         HRM(gradientBrush->SetTransformLocal(xpsMatrix),
             "Could not set transform on radial gradient brush.");
     }
 
     SkTScopedComPtr<IXpsOMGradientStopCollection> gradStopCollection;
     HRM(gradientBrush->GetGradientStops(&gradStopCollection),
         "Could not get radial gradient stop collection.");
     for (int i = 2; i < info.fColorCount; ++i) {
         SkTScopedComPtr<IXpsOMGradientStop> gradStop;
         HR(createXpsGradientStop(info.fColors[i],
@@ skipping 55 matching lines @@
         shader->asAGradient(&info);
 
         if (1 == info.fColorCount) {
             SkColor color = info.fColors[0];
             SkAlpha alpha = skPaint.getAlpha();
             HR(this->createXpsSolidColorBrush(color, alpha, brush));
             return S_OK;
         }
 
         SkMatrix localMatrix = shader->getLocalMatrix();
-        if (NULL != parentTransform) {
+        if (parentTransform) {
             localMatrix.preConcat(*parentTransform);
         }
         SkTScopedComPtr<IXpsOMMatrixTransform> xpsMatrixToUse;
         HR(this->createXpsTransform(localMatrix, &xpsMatrixToUse));
 
         if (SkShader::kLinear_GradientType == gradientType) {
             HR(this->createXpsLinearGradient(info,
                                              skPaint.getAlpha(),
                                              localMatrix,
                                              xpsMatrixToUse.get(),
@@ skipping 25 matching lines @@
     SkShader::TileMode xy[2];
     SkShader::BitmapType bitmapType = shader->asABitmap(&outTexture,
                                                         &outMatrix,
                                                         xy);
     switch (bitmapType) {
         case SkShader::kNone_BitmapType:
             break;
         case SkShader::kDefault_BitmapType: {
             //TODO: outMatrix??
             SkMatrix localMatrix = shader->getLocalMatrix();
-            if (NULL != parentTransform) {
+            if (parentTransform) {
                 localMatrix.preConcat(*parentTransform);
             }
 
             SkTScopedComPtr<IXpsOMTileBrush> tileBrush;
             HR(this->createXpsImageBrush(outTexture,
                                          localMatrix,
                                          xy,
                                          skPaint.getAlpha(),
                                          &tileBrush));
 
@@ skipping 241 matching lines @@
     SkTDArray<BOOL> segmentStrokes;
     SkTDArray<FLOAT> segmentData;
 
     SkTScopedComPtr<IXpsOMGeometryFigure> xpsFigure;
     SkPath::Iter iter(path, true);
     SkPoint points[4];
     SkPath::Verb verb;
     while ((verb = iter.next(points)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kMove_Verb: {
-                if (NULL != xpsFigure.get()) {
+                if (xpsFigure.get()) {
                     HR(close_figure(segmentTypes, segmentStrokes, segmentData,
                                     stroke, fill,
                                     xpsFigure.get() , xpsFigures));
                     xpsFigure.reset();
                     segmentTypes.rewind();
                     segmentStrokes.rewind();
                     segmentData.rewind();
                 }
                 // Define the start point.
                 XPS_POINT startPoint = xps_point(points[0]);
@@ skipping 30 matching lines @@
                 break;
             case SkPath::kClose_Verb:
                 // we ignore these, and just get the whole segment from
                 // the corresponding line/quad/cubic verbs
                 break;
             default:
                 SkDEBUGFAIL("unexpected verb");
                 break;
         }
     }
-    if (NULL != xpsFigure.get()) {
+    if (xpsFigure.get()) {
         HR(close_figure(segmentTypes, segmentStrokes, segmentData,
                         stroke, fill,
                         xpsFigure.get(), xpsFigures));
     }
     return S_OK;
 }
 
 void SkXPSDevice::convertToPpm(const SkMaskFilter* filter,
                                SkMatrix* matrix,
                                SkVector* ppuScale,
@@ skipping 435 matching lines @@
     SkTScopedComPtr<IXpsOMMatrixTransform> xpsTransform;
     HRV(this->createXpsTransform(transform, &xpsTransform));
     if (xpsTransform.get()) {
         HRVM(shadedGeometry->SetTransformLocal(xpsTransform.get()),
              "Could not set transform for bitmap.");
     } else {
         //TODO: perspective that bitmap!
     }
 
     SkTScopedComPtr<IXpsOMGeometryFigure> rectFigure;
-    if (NULL != xpsTransform.get()) {
+    if (xpsTransform.get()) {
         const SkShader::TileMode xy[2] = {
             SkShader::kClamp_TileMode,
             SkShader::kClamp_TileMode,
         };
         SkTScopedComPtr<IXpsOMTileBrush> xpsImageBrush;
         HRV(this->createXpsImageBrush(bitmap,
                                       transform,
                                       xy,
                                       paint.getAlpha(),
                                       &xpsImageBrush));
@@ skipping 124 matching lines @@
             useCanvasForClip = true;
         } else {
             SkDEBUGFAIL("Attempt to add glyphs in perspective.");
             useCanvasForClip = false;
         }
     }
 
     SkTScopedComPtr<IXpsOMGlyphsEditor> glyphsEditor;
     HRM(glyphs->GetGlyphsEditor(&glyphsEditor), "Could not get glyph editor.");
 
-    if (NULL != text) {
+    if (text) {
         HRM(glyphsEditor->SetUnicodeString(text),
             "Could not set unicode string.");
     }
 
-    if (NULL != xpsGlyphs) {
+    if (xpsGlyphs) {
         HRM(glyphsEditor->SetGlyphIndices(xpsGlyphsLen, xpsGlyphs),
             "Could not set glyphs.");
     }
 
     HRM(glyphsEditor->ApplyEdits(), "Could not apply glyph edits.");
 
     SkTScopedComPtr<IXpsOMBrush> xpsFillBrush;
     HR(this->createXpsBrush(
             paint,
             &xpsFillBrush,
@@ skipping 279 matching lines @@
              IID_PPV_ARGS(&this->fXpsFactory)),
          "Could not create factory for layer.");
 
     HRVM(this->fXpsFactory->CreateCanvas(&this->fCurrentXpsCanvas),
          "Could not create canvas for layer.");
 }
 
 bool SkXPSDevice::allowImageFilter(const SkImageFilter*) {
     return false;
 }