Style Change: NULL->nullptr

src/core/SkRecordDraw.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 "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkPatchUtils.h"
@@ skipping 46 matching lines @@
     }
 }
 
 void SkRecordPartialDraw(const SkRecord& record, SkCanvas* canvas,
                          SkPicture const* const drawablePicts[], int drawableCount,
                          int start, int stop,
                          const SkMatrix& initialCTM) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     stop = SkTMin(stop, record.count());
-    SkRecords::Draw draw(canvas, drawablePicts, NULL, drawableCount, &initialCTM);
+    SkRecords::Draw draw(canvas, drawablePicts, nullptr, drawableCount, &initialCTM);
     for (int i = start; i < stop; i++) {
         record.visit<void>(i, draw);
     }
 }
 
 namespace SkRecords {
 
 // NoOps draw nothing.
 template <> void Draw::draw(const NoOp&) {}
 
@@ skipping 38 matching lines @@
 DRAW(DrawTextOnPath, drawTextOnPath(r.text, r.byteLength, r.path, &r.matrix, r.paint));
 DRAW(DrawAtlas, drawAtlas(r.atlas, r.xforms, r.texs, r.colors, r.count, r.mode, r.cull, r.paint));
 DRAW(DrawVertices, drawVertices(r.vmode, r.vertexCount, r.vertices, r.texs, r.colors,
                                 r.xmode.get(), r.indices, r.indexCount, r.paint));
 #undef DRAW
 
 template <> void Draw::draw(const DrawDrawable& r) {
     SkASSERT(r.index >= 0);
     SkASSERT(r.index < fDrawableCount);
     if (fDrawables) {
-        SkASSERT(NULL == fDrawablePicts);
+        SkASSERT(nullptr == fDrawablePicts);
         fCanvas->drawDrawable(fDrawables[r.index], r.matrix);
     } else {
-        fCanvas->drawPicture(fDrawablePicts[r.index], r.matrix, NULL);
+        fCanvas->drawPicture(fDrawablePicts[r.index], r.matrix, nullptr);
     }
 }
 
 // This is an SkRecord visitor that fills an SkBBoxHierarchy.
 //
 // The interesting part here is how to calculate bounds for ops which don't
 // have intrinsic bounds.  What is the bounds of a Save or a Translate?
 //
 // We answer this by thinking about a particular definition of bounds: if I
 // don't execute this op, pixels in this rectangle might draw incorrectly.  So
@@ skipping 133 matching lines @@
     // We also take advantage of SaveLayer bounds when present to further cut the clip down.
     void updateClipBounds(const SaveLayer& op)  {
         if (op.bounds) {
             // adjustAndMap() intersects these layer bounds with the previous clip for us.
             fCurrentClipBounds = this->adjustAndMap(*op.bounds, op.paint);
         }
     }
 
     // The bounds of these ops must be calculated when we hit the Restore
     // from the bounds of the ops in the same Save block.
-    void trackBounds(const Save&)          { this->pushSaveBlock(NULL); }
+    void trackBounds(const Save&)          { this->pushSaveBlock(nullptr); }
     void trackBounds(const SaveLayer& op)  { this->pushSaveBlock(op.paint); }
     void trackBounds(const Restore&) { fBounds[fCurrentOp] = this->popSaveBlock(); }
 
     void trackBounds(const SetMatrix&)         { this->pushControl(); }
     void trackBounds(const ClipRect&)          { this->pushControl(); }
     void trackBounds(const ClipRRect&)         { this->pushControl(); }
     void trackBounds(const ClipPath&)          { this->pushControl(); }
     void trackBounds(const ClipRegion&)        { this->pushControl(); }
 
     // For all other ops, we can calculate and store the bounds directly now.
@@ skipping 23 matching lines @@
                 return true;
             }
 
             // Unusual Xfermodes require us to process a saved layer
             // even with operations outisde the clip.
             // For example, DstIn is used by masking layers.
             // https://code.google.com/p/skia/issues/detail?id=1291
             // https://crbug.com/401593
             SkXfermode* xfermode = paint->getXfermode();
             SkXfermode::Mode mode;
-            // SrcOver is ok, and is also the common case with a NULL xfermode.
+            // SrcOver is ok, and is also the common case with a nullptr xfermode.
             // So we should make that the fast path and bypass the mode extraction
             // and test.
             if (xfermode && xfermode->asMode(&mode)) {
                 switch (mode) {
                     // For each of the following transfer modes, if the source
                     // alpha is zero (our transparent black), the resulting
                     // blended alpha is not necessarily equal to the original
                     // destination alpha.
                     case SkXfermode::kClear_Mode:
                     case SkXfermode::kSrc_Mode:
@@ skipping 180 matching lines @@
         return this->adjustAndMap(dst, &op.paint);
     }
 
     Bounds bounds(const DrawTextBlob& op) const {
         SkRect dst = op.blob->bounds();
         dst.offset(op.x, op.y);
         return this->adjustAndMap(dst, &op.paint);
     }
 
     Bounds bounds(const DrawDrawable& op) const {
-        return this->adjustAndMap(op.worstCaseBounds, NULL);
+        return this->adjustAndMap(op.worstCaseBounds, nullptr);
     }
 
     static void AdjustTextForFontMetrics(SkRect* rect, const SkPaint& paint) {
 #ifdef SK_DEBUG
         SkRect correct = *rect;
 #endif
         // crbug.com/373785 ~~> xPad = 4x yPad
         // crbug.com/424824 ~~> bump yPad from 2x text size to 2.5x
         const SkScalar yPad = 2.5f * paint.getTextSize(),
                        xPad = 4.0f * yPad;
@@ skipping 98 matching lines @@
         int                fStartIndex;
         bool               fIsSaveLayer;
         bool               fHasNestedSaveLayer;
         SkRect             fBounds;
         const SkPaint*     fPaint;
     };
 
     template <typename T> void trackSaveLayers(const T& op) {
         /* most ops aren't involved in saveLayers */
     }
-    void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, NULL, NULL); }
+    void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, nullptr, nullptr); }
     void trackSaveLayers(const SaveLayer& sl) { this->pushSaveLayerInfo(true, sl.bounds, sl.paint); }
     void trackSaveLayers(const Restore& r) { this->popSaveLayerInfo(); }
 
     void trackSaveLayersForPicture(const SkPicture* picture, const SkPaint* paint) {
         // For sub-pictures, we wrap their layer information within the parent
         // picture's rendering hierarchy
-        const SkLayerInfo* childData = NULL;
+        const SkLayerInfo* childData = nullptr;
         if (const SkBigPicture* bp = picture->asSkBigPicture()) {
             childData = static_cast<const SkLayerInfo*>(bp->accelData());
         }
         if (!childData) {
             // If the child layer hasn't been generated with saveLayer data we
             // assume the worst (i.e., that it does contain layers which nest
             // inside existing layers). Layers within sub-pictures that don't
             // have saveLayer data cannot be hoisted.
             // TODO: could the analysis data be use to fine tune this?
             this->updateStackForSaveLayer();
             return;
         }
 
         for (int i = 0; i < childData->numBlocks(); ++i) {
             const SkLayerInfo::BlockInfo& src = childData->block(i);
 
             FillBounds::Bounds newBound = fFillBounds.adjustAndMap(src.fBounds, paint);
             if (newBound.isEmpty()) {
                 continue;
             }
 
             this->updateStackForSaveLayer();
 
             SkLayerInfo::BlockInfo& dst = fAccelData->addBlock();
 
-            // If src.fPicture is NULL the layer is in dp.picture; otherwise
+            // If src.fPicture is nullptr the layer is in dp.picture; otherwise
             // it belongs to a sub-picture.
             dst.fPicture = src.fPicture ? src.fPicture : picture;
             dst.fPicture->ref();
             dst.fBounds = newBound;
             dst.fSrcBounds = src.fSrcBounds;
             dst.fLocalMat = src.fLocalMat;
             dst.fPreMat = src.fPreMat;
             dst.fPreMat.postConcat(fFillBounds.ctm());
             if (src.fPaint) {
                 dst.fPaint = new SkPaint(*src.fPaint);
@@ skipping 12 matching lines @@
         }
     }
 
     void trackSaveLayers(const DrawPicture& dp) {
         this->trackSaveLayersForPicture(dp.picture, dp.paint);
     }
 
     void trackSaveLayers(const DrawDrawable& dp) {
         SkASSERT(fPictList);
         SkASSERT(dp.index >= 0 && dp.index < fPictList->count());
-        const SkPaint* paint = NULL;    // drawables don't get a side-car paint
+        const SkPaint* paint = nullptr;    // drawables don't get a side-car paint
         this->trackSaveLayersForPicture(fPictList->begin()[dp.index], paint);
     }
 
     // Inform all the saveLayers already on the stack that they now have a
     // nested saveLayer inside them
     void updateStackForSaveLayer() {
         for (int index = fSaveLayerStack.count() - 1; index >= 0; --index) {
             if (fSaveLayerStack[index].fHasNestedSaveLayer) {
                 break;
             }
@@ skipping 26 matching lines @@
         fSaveLayerStack.pop(&sli);
 
         if (!sli.fIsSaveLayer) {
             return;
         }
 
         --fSaveLayersInStack;
 
         SkLayerInfo::BlockInfo& block = fAccelData->addBlock();
 
-        SkASSERT(NULL == block.fPicture);  // This layer is in the top-most picture
+        SkASSERT(nullptr == block.fPicture);  // This layer is in the top-most picture
 
         block.fBounds = fFillBounds.getBounds(sli.fStartIndex);
         block.fLocalMat = fFillBounds.ctm();
         block.fPreMat = SkMatrix::I();
         if (sli.fPaint) {
             block.fPaint = new SkPaint(*sli.fPaint);
         }
 
         block.fSrcBounds = sli.fBounds;
         block.fSaveLayerOpID = sli.fStartIndex;
@@ skipping 38 matching lines @@
     SkRecords::CollectLayers visitor(cullRect, record, pictList, data);
 
     for (int curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
 
     visitor.cleanUp(bbh);
 }