Style Change: NULL->nullptr

src/effects/SkLayerRasterizer.cpp

 
 /*
  * Copyright 2006 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 "SkLayerRasterizer.h"
@@ skipping 18 matching lines @@
 
 SkLayerRasterizer::SkLayerRasterizer(SkDeque* layers) : fLayers(layers)
 {
 }
 
 // Helper function to call destructors on SkPaints held by layers and delete layers.
 static void clean_up_layers(SkDeque* layers) {
     SkDeque::F2BIter        iter(*layers);
     SkLayerRasterizer_Rec*  rec;
 
-    while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
+    while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != nullptr)
         rec->fPaint.~SkPaint();
 
     delete layers;
 }
 
 SkLayerRasterizer::~SkLayerRasterizer() {
     SkASSERT(fLayers);
     clean_up_layers(const_cast<SkDeque*>(fLayers));
 }
 
 static bool compute_bounds(const SkDeque& layers, const SkPath& path,
                            const SkMatrix& matrix,
                            const SkIRect* clipBounds, SkIRect* bounds) {
     SkDeque::F2BIter        iter(layers);
     SkLayerRasterizer_Rec*  rec;
 
     bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32);
 
-    while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
+    while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != nullptr) {
         const SkPaint&  paint = rec->fPaint;
         SkPath          fillPath, devPath;
         const SkPath*   p = &path;
 
         if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
             paint.getFillPath(path, &fillPath);
             p = &fillPath;
         }
         if (p->isEmpty()) {
             continue;
@@ skipping 60 matching lines @@
                                        -SkIntToScalar(mask->fBounds.fTop));
 
         draw.fMatrix    = &drawMatrix;
         draw.fRC        = &rectClip;
         draw.fClip      = &rectClip.bwRgn();
         // we set the matrixproc in the loop, as the matrix changes each time (potentially)
 
         SkDeque::F2BIter        iter(*fLayers);
         SkLayerRasterizer_Rec*  rec;
 
-        while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
+        while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != nullptr) {
             drawMatrix = translatedMatrix;
             drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
             draw.drawPath(path, rec->fPaint);
         }
     }
     return true;
 }
 
 SkFlattenable* SkLayerRasterizer::CreateProc(SkReadBuffer& buffer) {
     return new SkLayerRasterizer(ReadLayers(buffer));
@@ skipping 15 matching lines @@
 
 void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
 
     SkASSERT(fLayers);
     buffer.writeInt(fLayers->count());
 
     SkDeque::F2BIter                iter(*fLayers);
     const SkLayerRasterizer_Rec*    rec;
 
-    while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) {
+    while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != nullptr) {
         buffer.writePaint(rec->fPaint);
         buffer.writePoint(rec->fOffset);
     }
 }
 
 SkLayerRasterizer::Builder::Builder() : fLayers(new SkDeque(sizeof(SkLayerRasterizer_Rec))) {}
 
 SkLayerRasterizer::Builder::~Builder()
 {
-    if (fLayers != NULL) {
+    if (fLayers != nullptr) {
         clean_up_layers(fLayers);
     }
 }
 
 void SkLayerRasterizer::Builder::addLayer(const SkPaint& paint, SkScalar dx,
                                           SkScalar dy) {
     SkASSERT(fLayers);
     SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back();
 
     new (&rec->fPaint) SkPaint(paint);
     rec->fOffset.set(dx, dy);
 }
 
 SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() {
     SkLayerRasterizer* rasterizer;
     if (0 == fLayers->count()) {
-        rasterizer = NULL;
+        rasterizer = nullptr;
         delete fLayers;
     } else {
         rasterizer = new SkLayerRasterizer(fLayers);
     }
-    fLayers = NULL;
+    fLayers = nullptr;
     return rasterizer;
 }
 
 SkLayerRasterizer* SkLayerRasterizer::Builder::snapshotRasterizer() const {
     if (0 == fLayers->count()) {
-        return NULL;
+        return nullptr;
     }
     SkDeque* layers = new SkDeque(sizeof(SkLayerRasterizer_Rec), fLayers->count());
     SkDeque::F2BIter                iter(*fLayers);
     const SkLayerRasterizer_Rec*    recOrig;
     SkDEBUGCODE(int                 count = 0;)
-    while ((recOrig = static_cast<SkLayerRasterizer_Rec*>(iter.next())) != NULL) {
+    while ((recOrig = static_cast<SkLayerRasterizer_Rec*>(iter.next())) != nullptr) {
         SkDEBUGCODE(count++);
         SkLayerRasterizer_Rec* recCopy = static_cast<SkLayerRasterizer_Rec*>(layers->push_back());
         new (&recCopy->fPaint) SkPaint(recOrig->fPaint);
         recCopy->fOffset = recOrig->fOffset;
     }
     SkASSERT(fLayers->count() == count);
     SkASSERT(layers->count() == count);
     SkLayerRasterizer* rasterizer = new SkLayerRasterizer(layers);
     return rasterizer;
 }