"NULL !=" = NULL

src/core/SkPicture.cpp

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPictureFlat.h"
@@ skipping 216 matching lines @@
     int numNonDashedPathEffects = fNumPaintWithPathEffectUses -
                                   fNumFastPathDashEffects;
     bool suitableForDash = (0 == fNumPaintWithPathEffectUses) ||
                            (numNonDashedPathEffects < kNumPaintWithPathEffectsUsesTol
                                && 0 == sampleCount);
 
     bool ret = suitableForDash &&
                (fNumAAConcavePaths - fNumAAHairlineConcavePaths)
                    < kNumAAConcavePathsTol;
 
-    if (!ret && NULL != reason) {
+    if (!ret && reason) {
         if (!suitableForDash) {
             if (0 != sampleCount) {
                 *reason = "Can't use multisample on dash effect.";
             } else {
                 *reason = "Too many non dashed path effects.";
             }
         } else if ((fNumAAConcavePaths - fNumAAHairlineConcavePaths)
                     >= kNumAAConcavePathsTol)
             *reason = "Too many anti-aliased concave paths.";
         else
@@ skipping 41 matching lines @@
 #endif//SK_SUPPORT_LEGACY_PICTURE_CLONE
 
 // fRecord OK
 void SkPicture::EXPERIMENTAL_addAccelData(const SkPicture::AccelData* data) const {
     fAccelData.reset(SkRef(data));
 }
 
 // fRecord OK
 const SkPicture::AccelData* SkPicture::EXPERIMENTAL_getAccelData(
         SkPicture::AccelData::Key key) const {
-    if (NULL != fAccelData.get() && fAccelData->getKey() == key) {
+    if (fAccelData.get() && fAccelData->getKey() == key) {
         return fAccelData.get();
     }
     return NULL;
 }
 
 // fRecord OK
 SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() {
     static int32_t gNextID = 0;
 
     int32_t id = sk_atomic_inc(&gNextID);
@@ skipping 11 matching lines @@
     return ((SkPictureStateTree::Draw*)fOps[index])->fOffset;
 }
 
 const SkMatrix& SkPicture::OperationList::matrix(int index) const {
     SkASSERT(index < fOps.count());
     return *((SkPictureStateTree::Draw*)fOps[index])->fMatrix;
 }
 
 // fRecord OK
 void SkPicture::playback(SkCanvas* canvas, SkDrawPictureCallback* callback) const {
-    SkASSERT(NULL != canvas);
-    SkASSERT(NULL != fData.get() || NULL != fRecord.get());
+    SkASSERT(canvas);
+    SkASSERT(fData.get() || fRecord.get());
 
     // If the query contains the whole picture, don't bother with the BBH.
     SkRect clipBounds = { 0, 0, 0, 0 };
     (void)canvas->getClipBounds(&clipBounds);
     const bool useBBH = !clipBounds.contains(this->cullRect());
 
-    if (NULL != fData.get()) {
+    if (fData.get()) {
         SkPicturePlayback playback(this);
         playback.setUseBBH(useBBH);
         playback.draw(canvas, callback);
     }
-    if (NULL != fRecord.get()) {
+    if (fRecord.get()) {
         SkRecordDraw(*fRecord, canvas, useBBH ? fBBH.get() : NULL, callback);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static const char kMagic[] = { 's', 'k', 'i', 'a', 'p', 'i', 'c', 't' };
 
@@ skipping 169 matching lines @@
         info->fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
     }
 }
 
 // fRecord OK
 void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
     const SkPictureData* data = fData.get();
 
     // If we're a new-format picture, backport to old format for serialization.
     SkAutoTDelete<SkPicture> oldFormat;
-    if (NULL == data && NULL != fRecord.get()) {
+    if (NULL == data && fRecord.get()) {
         oldFormat.reset(backport(*fRecord, this->cullRect()));
         data = oldFormat->fData.get();
-        SkASSERT(NULL != data);
+        SkASSERT(data);
     }
 
     SkPictInfo info;
     this->createHeader(&info);
     SkASSERT(sizeof(SkPictInfo) == 32);
     stream->write(&info, sizeof(info));
 
-    if (NULL != data) {
+    if (data) {
         stream->writeBool(true);
         data->serialize(stream, encoder);
     } else {
         stream->writeBool(false);
     }
 }
 
 // fRecord OK
 void SkPicture::flatten(SkWriteBuffer& buffer) const {
     const SkPictureData* data = fData.get();
 
     // If we're a new-format picture, backport to old format for serialization.
     SkAutoTDelete<SkPicture> oldFormat;
-    if (NULL == data && NULL != fRecord.get()) {
+    if (NULL == data && fRecord.get()) {
         oldFormat.reset(backport(*fRecord, this->cullRect()));
         data = oldFormat->fData.get();
-        SkASSERT(NULL != data);
+        SkASSERT(data);
     }
 
     SkPictInfo info;
     this->createHeader(&info);
     buffer.writeByteArray(&info.fMagic, sizeof(info.fMagic));
     buffer.writeUInt(info.fVersion);
     buffer.writeRect(info.fCullRect);
     buffer.writeUInt(info.fFlags);
 
-    if (NULL != data) {
+    if (data) {
         buffer.writeBool(true);
         data->flatten(buffer);
     } else {
         buffer.writeBool(false);
     }
 }
 
 #if SK_SUPPORT_GPU
 // fRecord OK
 bool SkPicture::suitableForGpuRasterization(GrContext* context, const char **reason) const {
     if (fRecord.get()) {
         return fAnalysis.suitableForGpuRasterization(reason, 0);
     }
     if (NULL == fData.get()) {
-        if (NULL != reason) {
+        if (reason) {
             *reason = "Missing internal data.";
         }
         return false;
     }
 
     return fData->suitableForGpuRasterization(context, reason);
 }
 #endif
 
 // fRecord OK
@@ skipping 52 matching lines @@
         SkRecordFillBounds(*record, fBBH.get());
     }
     this->needsNewGenID();
 }
 
 // Note that we are assuming that this entry point will only be called from
 // one thread. Currently the only client of this method is
 // SkGpuDevice::EXPERIMENTAL_optimize which should be only called from a single
 // thread.
 void SkPicture::addDeletionListener(DeletionListener* listener) const {
-    SkASSERT(NULL != listener);
+    SkASSERT(listener);
 
     *fDeletionListeners.append() = SkRef(listener);
 }
 
 void SkPicture::callDeletionListeners() {
     for (int i = 0; i < fDeletionListeners.count(); ++i) {
         fDeletionListeners[i]->onDeletion(this->uniqueID());
     }
 
     fDeletionListeners.unrefAll();
 }
 
 // fRecord OK
 int SkPicture::approximateOpCount() const {
     SkASSERT(fRecord.get() || fData.get());
     if (fRecord.get()) {
         return fRecord->count();
     }
     if (fData.get()) {
         return fData->opCount();
     }
     return 0;
 }