Style Change: NULL->nullptr

src/effects/SkLayerDrawLooper.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.
  */
 #include "SkCanvas.h"
 #include "SkColor.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkLayerDrawLooper.h"
 #include "SkString.h"
 #include "SkStringUtils.h"
 #include "SkUnPreMultiply.h"
 
 SkLayerDrawLooper::LayerInfo::LayerInfo() {
     fPaintBits = 0;                     // ignore our paint fields
     fColorMode = SkXfermode::kDst_Mode; // ignore our color
     fOffset.set(0, 0);
     fPostTranslate = false;
 }
 
 SkLayerDrawLooper::SkLayerDrawLooper()
-        : fRecs(NULL),
-          fTopRec(NULL),
+        : fRecs(nullptr),
+          fTopRec(nullptr),
           fCount(0) {
 }
 
 SkLayerDrawLooper::~SkLayerDrawLooper() {
     Rec* rec = fRecs;
     while (rec) {
         Rec* next = rec->fNext;
         delete rec;
         rec = next;
     }
@@ skipping 90 matching lines @@
     m.postTranslate(dx, dy);
     canvas->setMatrix(m);
 }
 
 SkLayerDrawLooper::LayerDrawLooperContext::LayerDrawLooperContext(
         const SkLayerDrawLooper* looper) : fCurrRec(looper->fRecs) {}
 
 bool SkLayerDrawLooper::LayerDrawLooperContext::next(SkCanvas* canvas,
                                                      SkPaint* paint) {
     canvas->restore();
-    if (NULL == fCurrRec) {
+    if (nullptr == fCurrRec) {
         return false;
     }
 
     ApplyInfo(paint, fCurrRec->fPaint, fCurrRec->fInfo);
 
     canvas->save();
     if (fCurrRec->fInfo.fPostTranslate) {
         postTranslate(canvas, fCurrRec->fInfo.fOffset.fX,
                       fCurrRec->fInfo.fOffset.fY);
     } else {
@@ skipping 12 matching lines @@
     const Rec* rec = fRecs;
 
     // bottom layer needs to be just blur(maskfilter)
     if ((rec->fInfo.fPaintBits & ~kMaskFilter_Bit)) {
         return false;
     }
     if (SkXfermode::kSrc_Mode != rec->fInfo.fColorMode) {
         return false;
     }
     const SkMaskFilter* mf = rec->fPaint.getMaskFilter();
-    if (NULL == mf) {
+    if (nullptr == mf) {
         return false;
     }
     SkMaskFilter::BlurRec maskBlur;
     if (!mf->asABlur(&maskBlur)) {
         return false;
     }
 
     rec = rec->fNext;
     // top layer needs to be "plain"
     if (rec->fInfo.fPaintBits) {
@@ skipping 105 matching lines @@
             str->append("false ");
         }
 
         rec->fPaint.toString(str);
         rec = rec->fNext;
     }
 }
 #endif
 
 SkLayerDrawLooper::Builder::Builder()
-        : fRecs(NULL),
-          fTopRec(NULL),
+        : fRecs(nullptr),
+          fTopRec(nullptr),
           fCount(0) {
 }
 
 SkLayerDrawLooper::Builder::~Builder() {
     Rec* rec = fRecs;
     while (rec) {
         Rec* next = rec->fNext;
         delete rec;
         rec = next;
     }
 }
 
 SkPaint* SkLayerDrawLooper::Builder::addLayer(const LayerInfo& info) {
     fCount += 1;
 
     Rec* rec = new Rec;
     rec->fNext = fRecs;
     rec->fInfo = info;
     fRecs = rec;
-    if (NULL == fTopRec) {
+    if (nullptr == fTopRec) {
         fTopRec = rec;
     }
 
     return &rec->fPaint;
 }
 
 void SkLayerDrawLooper::Builder::addLayer(SkScalar dx, SkScalar dy) {
     LayerInfo info;
 
     info.fOffset.set(dx, dy);
     (void)this->addLayer(info);
 }
 
 SkPaint* SkLayerDrawLooper::Builder::addLayerOnTop(const LayerInfo& info) {
     fCount += 1;
 
     Rec* rec = new Rec;
-    rec->fNext = NULL;
+    rec->fNext = nullptr;
     rec->fInfo = info;
-    if (NULL == fRecs) {
+    if (nullptr == fRecs) {
         fRecs = rec;
     } else {
         SkASSERT(fTopRec);
         fTopRec->fNext = rec;
     }
     fTopRec = rec;
 
     return &rec->fPaint;
 }
 
 SkLayerDrawLooper* SkLayerDrawLooper::Builder::detachLooper() {
     SkLayerDrawLooper* looper = new SkLayerDrawLooper;
     looper->fCount = fCount;
     looper->fRecs = fRecs;
 
     fCount = 0;
-    fRecs = NULL;
-    fTopRec = NULL;
+    fRecs = nullptr;
+    fTopRec = nullptr;
 
     return looper;
 }