"NULL !=" = NULL

src/core/SkTextBlob.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTextBlob.h"
 
 #include "SkReadBuffer.h"
@@ skipping 94 matching lines @@
             return NULL;
         }
     }
 
     return blobBuilder.build();
 }
 
 SkTextBlob::RunIterator::RunIterator(const SkTextBlob* blob)
     : fBlob(blob)
     , fIndex(0) {
-    SkASSERT(NULL != blob);
+    SkASSERT(blob);
 }
 
 bool SkTextBlob::RunIterator::done() const {
     return NULL == fBlob->fRuns.get() || fIndex >= fBlob->fRuns->count();
 }
 
 void SkTextBlob::RunIterator::next() {
     SkASSERT(!this->done());
     fIndex++;
 }
@@ skipping 61 matching lines @@
     }
     fBounds.setEmpty();
 }
 
 SkTextBlobBuilder::~SkTextBlobBuilder() {
     // unused runs
     SkDELETE(fRuns);
 }
 
 void SkTextBlobBuilder::updateDeferredBounds() {
-    SkASSERT(!fDeferredBounds || (NULL != fRuns && !fRuns->empty()));
+    SkASSERT(!fDeferredBounds || (fRuns && !fRuns->empty()));
 
     if (!fDeferredBounds) {
         return;
     }
 
     // FIXME: measure the current run & union bounds
     fDeferredBounds = false;
 }
 
 void SkTextBlobBuilder::ensureRun(const SkPaint& font, SkTextBlob::GlyphPositioning pos,
@@ skipping 34 matching lines @@
                                       int count, SkPoint offset, const SkRect* bounds) {
     SkASSERT(count > 0);
 
     this->ensureRun(font, positioning, offset);
 
     unsigned posScalarsPerGlyph = SkTextBlob::ScalarsPerGlyph(positioning);
 
     fGlyphBuffer.append(count);
     fPosBuffer.append(count * posScalarsPerGlyph);
 
-    SkASSERT(NULL != fRuns && !fRuns->empty());
+    SkASSERT(fRuns && !fRuns->empty());
     SkTextBlob::Run& run = fRuns->back();
 
     run.count += count;
 
     // The current run might have been merged, so the start offset may point to prev run data.
     // Start from the back (which always points to the end of the current run buffers) instead.
     fCurrentRunBuffer.glyphs = fGlyphBuffer.isEmpty()
             ? NULL : fGlyphBuffer.end() - count;
     SkASSERT(NULL == fCurrentRunBuffer.glyphs || fCurrentRunBuffer.glyphs >= fGlyphBuffer.begin());
     fCurrentRunBuffer.pos = fPosBuffer.isEmpty()
             ? NULL : fPosBuffer.end() - count * posScalarsPerGlyph;
     SkASSERT(NULL == fCurrentRunBuffer.pos || fCurrentRunBuffer.pos >= fPosBuffer.begin());
 
     if (!fDeferredBounds) {
-        if (NULL != bounds) {
+        if (bounds) {
             fBounds.join(*bounds);
         } else {
             fDeferredBounds = true;
         }
     }
 }
 
 const SkTextBlobBuilder::RunBuffer& SkTextBlobBuilder::allocRun(const SkPaint& font, int count,
                                                                 SkScalar x, SkScalar y,
                                                                 const SkRect* bounds) {
@@ skipping 16 matching lines @@
     this->allocInternal(font, SkTextBlob::kFull_Positioning, count, SkPoint::Make(0, 0), bounds);
 
     return fCurrentRunBuffer;
 }
 
 const SkTextBlob* SkTextBlobBuilder::build() {
     const SkTextBlob* blob;
 
     if (fGlyphBuffer.count() > 0) {
         // we have some glyphs, construct a real blob
-        SkASSERT(NULL != fRuns && !fRuns->empty());
+        SkASSERT(fRuns && !fRuns->empty());
 
         this->updateDeferredBounds();
 
         // ownership of all buffers is transferred to the blob
         blob = SkNEW_ARGS(SkTextBlob, (fGlyphBuffer.detach(),
                                        fPosBuffer.detach(),
                                        fRuns,
                                        fBounds));
         fRuns = NULL;
         fBounds.setEmpty();
     } else {
         // empty blob
         SkASSERT(NULL == fRuns || fRuns->empty());
         SkASSERT(fBounds.isEmpty());
 
         blob = SkNEW_ARGS(SkTextBlob, (NULL, NULL, NULL, SkRect::MakeEmpty()));
     }
 
     return blob;
 }