Style Change: NULL->nullptr

src/core/SkPictureRecorder.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 "SkBigPicture.h"
 #include "SkData.h"
 #include "SkDrawable.h"
 #include "SkLayerInfo.h"
 #include "SkPictureRecorder.h"
 #include "SkPictureUtils.h"
 #include "SkRecord.h"
 #include "SkRecordDraw.h"
 #include "SkRecordOpts.h"
 #include "SkRecorder.h"
 #include "SkTypes.h"
 
 SkPictureRecorder::SkPictureRecorder() {
     fActivelyRecording = false;
     fRecorder.reset(new SkRecorder(nullptr, SkRect::MakeWH(0, 0), &fMiniRecorder));
 }
 
 SkPictureRecorder::~SkPictureRecorder() {}
 
 SkCanvas* SkPictureRecorder::beginRecording(const SkRect& cullRect,
-                                            SkBBHFactory* bbhFactory /* = NULL */,
+                                            SkBBHFactory* bbhFactory /* = nullptr */,
                                             uint32_t recordFlags /* = 0 */) {
     fCullRect = cullRect;
     fFlags = recordFlags;
 
     if (bbhFactory) {
         fBBH.reset((*bbhFactory)(cullRect));
         SkASSERT(fBBH.get());
     }
 
     if (!fRecord) {
@@ skipping 23 matching lines @@
     SkRecordOptimize(fRecord);
 
     SkAutoTUnref<SkLayerInfo> saveLayerData;
 
     if (fBBH && (fFlags & kComputeSaveLayerInfo_RecordFlag)) {
         saveLayerData.reset(new SkLayerInfo);
     }
 
     SkDrawableList* drawableList = fRecorder->getDrawableList();
     SkBigPicture::SnapshotArray* pictList =
-        drawableList ? drawableList->newDrawableSnapshot() : NULL;
+        drawableList ? drawableList->newDrawableSnapshot() : nullptr;
 
     if (fBBH.get()) {
         if (saveLayerData) {
             SkRecordComputeLayers(fCullRect, *fRecord, pictList, fBBH.get(), saveLayerData);
         } else {
             SkRecordFillBounds(fCullRect, *fRecord, fBBH.get());
         }
         SkRect bbhBound = fBBH->getRootBound();
         SkASSERT((bbhBound.isEmpty() || fCullRect.contains(bbhBound))
             || (bbhBound.isEmpty() && fCullRect.isEmpty()));
         fCullRect = bbhBound;
     }
 
     size_t subPictureBytes = fRecorder->approxBytesUsedBySubPictures();
     for (int i = 0; pictList && i < pictList->count(); i++) {
         subPictureBytes += SkPictureUtils::ApproximateBytesUsed(pictList->begin()[i]);
     }
     return new SkBigPicture(fCullRect, fRecord.detach(), pictList, fBBH.detach(),
                             saveLayerData.detach(), subPictureBytes);
 }
 
 SkPicture* SkPictureRecorder::endRecordingAsPicture(const SkRect& cullRect) {
     fCullRect = cullRect;
     return this->endRecordingAsPicture();
 }
 
 
 void SkPictureRecorder::partialReplay(SkCanvas* canvas) const {
-    if (NULL == canvas) {
+    if (nullptr == canvas) {
         return;
     }
 
     int drawableCount = 0;
-    SkDrawable* const* drawables = NULL;
+    SkDrawable* const* drawables = nullptr;
     SkDrawableList* drawableList = fRecorder->getDrawableList();
     if (drawableList) {
         drawableCount = drawableList->count();
         drawables = drawableList->begin();
     }
-    SkRecordDraw(*fRecord, canvas, NULL, drawables, drawableCount, NULL/*bbh*/, NULL/*callback*/);
+    SkRecordDraw(*fRecord, canvas, nullptr, drawables, drawableCount, nullptr/*bbh*/, nullptr/*callback*/);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class SkRecordedDrawable : public SkDrawable {
     SkAutoTUnref<SkRecord>          fRecord;
     SkAutoTUnref<SkBBoxHierarchy>   fBBH;
     SkAutoTDelete<SkDrawableList>   fDrawableList;
     const SkRect                    fBounds;
     const bool                      fDoSaveLayerInfo;
 
 public:
     SkRecordedDrawable(SkRecord* record, SkBBoxHierarchy* bbh, SkDrawableList* drawableList,
                        const SkRect& bounds, bool doSaveLayerInfo)
         : fRecord(SkRef(record))
         , fBBH(SkSafeRef(bbh))
         , fDrawableList(drawableList)   // we take ownership
         , fBounds(bounds)
         , fDoSaveLayerInfo(doSaveLayerInfo)
     {}
 
 protected:
     SkRect onGetBounds() override { return fBounds; }
 
     void onDraw(SkCanvas* canvas) override {
-        SkDrawable* const* drawables = NULL;
+        SkDrawable* const* drawables = nullptr;
         int drawableCount = 0;
         if (fDrawableList) {
             drawables = fDrawableList->begin();
             drawableCount = fDrawableList->count();
         }
-        SkRecordDraw(*fRecord, canvas, NULL, drawables, drawableCount, fBBH, NULL/*callback*/);
+        SkRecordDraw(*fRecord, canvas, nullptr, drawables, drawableCount, fBBH, nullptr/*callback*/);
     }
 
     SkPicture* onNewPictureSnapshot() override {
-        SkBigPicture::SnapshotArray* pictList = NULL;
+        SkBigPicture::SnapshotArray* pictList = nullptr;
         if (fDrawableList) {
             // TODO: should we plumb-down the BBHFactory and recordFlags from our host
             //       PictureRecorder?
             pictList = fDrawableList->newDrawableSnapshot();
         }
 
         SkAutoTUnref<SkLayerInfo> saveLayerData;
 
         if (fBBH && fDoSaveLayerInfo) {
             saveLayerData.reset(new SkLayerInfo);
 
-            SkBBoxHierarchy* bbh = NULL;    // we've already computed fBBH (received in constructor)
+            SkBBoxHierarchy* bbh = nullptr;    // we've already computed fBBH (received in constructor)
             // TODO: update saveLayer info computation to reuse the already computed
             // bounds in 'fBBH'
             SkRecordComputeLayers(fBounds, *fRecord, pictList, bbh, saveLayerData);
         }
 
         size_t subPictureBytes = 0;
         for (int i = 0; pictList && i < pictList->count(); i++) {
             subPictureBytes += SkPictureUtils::ApproximateBytesUsed(pictList->begin()[i]);
         }
         // SkBigPicture will take ownership of a ref on both fRecord and fBBH.
@@ skipping 13 matching lines @@
 
     if (fBBH.get()) {
         SkRecordFillBounds(fCullRect, *fRecord, fBBH.get());
     }
 
     SkDrawable* drawable =
             new SkRecordedDrawable(fRecord, fBBH, fRecorder->detachDrawableList(), fCullRect,
                                    SkToBool(fFlags & kComputeSaveLayerInfo_RecordFlag));
 
     // release our refs now, so only the drawable will be the owner.
-    fRecord.reset(NULL);
-    fBBH.reset(NULL);
+    fRecord.reset(nullptr);
+    fBBH.reset(nullptr);
 
     return drawable;
 }