Style Change: NULL->nullptr

tools/PictureBenchmark.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Timer.h"
 #include "PictureBenchmark.h"
 #include "SkCanvas.h"
 #include "SkPicture.h"
 #include "SkString.h"
 #include "picture_utils.h"
 
 namespace sk_tools {
 
 PictureBenchmark::PictureBenchmark()
     : fRepeats(1)
-    , fRenderer(NULL)
+    , fRenderer(nullptr)
     , fTimerResult(TimerData::kAvg_Result)
     , fTimerTypes(0)
     , fTimeIndividualTiles(false)
     , fPurgeDecodedTex(false)
-    , fWriter(NULL) {
+    , fWriter(nullptr) {
 }
 
 PictureBenchmark::~PictureBenchmark() {
     SkSafeUnref(fRenderer);
 }
 
 void PictureBenchmark::setTimersToShow(bool wall,
                                        bool truncatedWall,
                                        bool cpu,
                                        bool truncatedCpu,
                                        bool gpu) {
     fTimerTypes = 0;
     fTimerTypes |= wall ? TimerData::kWall_Flag : 0;
     fTimerTypes |= truncatedWall ? TimerData::kTruncatedWall_Flag : 0;
     fTimerTypes |= cpu ? TimerData::kCpu_Flag : 0;
     fTimerTypes |= truncatedCpu ? TimerData::kTruncatedCpu_Flag : 0;
     fTimerTypes |= gpu ? TimerData::kGpu_Flag : 0;
 }
 
 Timer* PictureBenchmark::setupTimer(bool useGLTimer) {
 #if SK_SUPPORT_GPU
-    if (useGLTimer && fRenderer != NULL && fRenderer->isUsingGpuDevice()) {
+    if (useGLTimer && fRenderer != nullptr && fRenderer->isUsingGpuDevice()) {
         return new Timer(fRenderer->getGLContext());
     }
 #endif
-    return new Timer(NULL);
+    return new Timer(nullptr);
 }
 
 PictureRenderer* PictureBenchmark::setRenderer(sk_tools::PictureRenderer* renderer) {
     SkRefCnt_SafeAssign(fRenderer, renderer);
     return renderer;
 }
 
 void PictureBenchmark::run(SkPicture* pict, bool useMultiPictureDraw) {
     SkASSERT(pict);
-    if (NULL == pict) {
+    if (nullptr == pict) {
         return;
     }
 
-    SkASSERT(fRenderer != NULL);
-    if (NULL == fRenderer) {
+    SkASSERT(fRenderer != nullptr);
+    if (nullptr == fRenderer) {
         return;
     }
 
-    fRenderer->init(pict, NULL, NULL, NULL, false, useMultiPictureDraw);
+    fRenderer->init(pict, nullptr, nullptr, nullptr, false, useMultiPictureDraw);
 
     // We throw this away to remove first time effects (such as paging in this program)
     fRenderer->setup();
 
-    fRenderer->render(NULL);
+    fRenderer->render(nullptr);
     fRenderer->resetState(true);   // flush, swapBuffers and Finish
 
     if (fPurgeDecodedTex) {
         fRenderer->purgeTextures();
     }
 
     bool usingGpu = false;
 #if SK_SUPPORT_GPU
     usingGpu = fRenderer->isUsingGpuDevice();
 #endif
@@ skipping 17 matching lines @@
     if (TimerData::kPerIter_Result == fTimerResult && fRepeats > 1) {
         // interpret this flag combination to mean: generate 'fRepeats'
         // numbers by averaging each rendering 'kNumInnerLoops' times
         numOuterLoops = fRepeats;
         numInnerLoops = kNumInnerLoops;
     }
 
     if (fTimeIndividualTiles) {
         TiledPictureRenderer* tiledRenderer = fRenderer->getTiledRenderer();
         SkASSERT(tiledRenderer && tiledRenderer->supportsTimingIndividualTiles());
-        if (NULL == tiledRenderer || !tiledRenderer->supportsTimingIndividualTiles()) {
+        if (nullptr == tiledRenderer || !tiledRenderer->supportsTimingIndividualTiles()) {
             return;
         }
         int xTiles, yTiles;
         if (!tiledRenderer->tileDimensions(xTiles, yTiles)) {
             return;
         }
 
         int x, y;
         while (tiledRenderer->nextTile(x, y)) {
             // There are two timers, which will behave slightly differently:
@@ skipping 70 matching lines @@
 
         for (int outer = 0; outer < numOuterLoops; ++outer) {
             SkAutoTDelete<Timer> perRunTimer(this->setupTimer(false));
             TimerData perRunTimerData(numInnerLoops);
 
             longRunningTimer->start();
             for (int inner = 0; inner < numInnerLoops; ++inner) {
                 fRenderer->setup();
 
                 perRunTimer->start();
-                fRenderer->render(NULL);
+                fRenderer->render(nullptr);
                 perRunTimer->truncatedEnd();
                 fRenderer->resetState(false);   // flush & swapBuffers, but don't Finish
                 perRunTimer->end();
 
                 SkAssertResult(perRunTimerData.appendTimes(perRunTimer.get()));
 
                 if (fPurgeDecodedTex) {
                     fRenderer->purgeTextures();
                 }
             }
@@ skipping 23 matching lines @@
                 fTimerResult,
                 timerTypes,
                 numInnerLoops);
 #endif
     }
 
     fRenderer->end();
 }
 
 }