Style Change: NULL->nullptr

bench/PathBench.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 "Benchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 206 matching lines @@
 class RandomPathBench : public Benchmark {
 public:
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
 protected:
     void createData(int minVerbs,
                     int maxVerbs,
                     bool allowMoves = true,
-                    SkRect* bounds = NULL) {
+                    SkRect* bounds = nullptr) {
         SkRect tempBounds;
-        if (NULL == bounds) {
+        if (nullptr == bounds) {
             tempBounds.setXYWH(0, 0, SK_Scalar1, SK_Scalar1);
             bounds = &tempBounds;
         }
         fVerbCnts.reset(kNumVerbCnts);
         for (int i = 0; i < kNumVerbCnts; ++i) {
             fVerbCnts[i] = fRandom.nextRangeU(minVerbs, maxVerbs + 1);
         }
         fVerbs.reset(kNumVerbs);
         for (int i = 0; i < kNumVerbs; ++i) {
             do {
@@ skipping 464 matching lines @@
             r.fLeft = rand.nextUScalar1() * 300;
             r.fTop =  rand.nextUScalar1() * 300;
             r.fRight =  r.fLeft + 2 * size;
             r.fBottom = r.fTop + 2 * size;
 
             SkPath temp;
 
             if (fZeroRad) {
                 make_arb_round_rect(&temp, r, 0, 0);
 
-                SkASSERT(temp.isRect(NULL));
+                SkASSERT(temp.isRect(nullptr));
             } else {
                 make_arb_round_rect(&temp, r, r.width() / 10, r.height() / 15);
             }
 
             canvas->drawPath(temp, paint);
         }
     }
 
 private:
     bool fZeroRad;      // should 0 radius rounds rects be tested?
@@ skipping 119 matching lines @@
     void onDraw(const int loops, SkCanvas*) override {
         if (fUseV2) {
             for (int i = 0; i < loops; ++i) {
                 for (int j = 0; j < 1000; ++j) {
                     fDst[0].fPts[0] = fRQ.evalAt(0.4f);
                 }
             }
         } else {
             for (int i = 0; i < loops; ++i) {
                 for (int j = 0; j < 1000; ++j) {
-                    fRQ.evalAt(0.4f, &fDst[0].fPts[0], NULL);
+                    fRQ.evalAt(0.4f, &fDst[0].fPts[0], nullptr);
                 }
             }
         }
     }
 };
 DEF_BENCH( return new ConicBench_EvalPos(false); )
 DEF_BENCH( return new ConicBench_EvalPos(true); )
 
 class ConicBench_EvalTan : public ConicBench_Chop {
     const bool fUseV2;
 public:
     ConicBench_EvalTan(bool useV2) : fUseV2(useV2) {
         fName.printf("conic-eval-tan%d", useV2);
     }
     void onDraw(const int loops, SkCanvas*) override {
         if (fUseV2) {
             for (int i = 0; i < loops; ++i) {
                 for (int j = 0; j < 1000; ++j) {
                     fDst[0].fPts[0] = fRQ.evalTangentAt(0.4f);
                 }
             }
         } else {
             for (int i = 0; i < loops; ++i) {
                 for (int j = 0; j < 1000; ++j) {
-                    fRQ.evalAt(0.4f, NULL, &fDst[0].fPts[0]);
+                    fRQ.evalAt(0.4f, nullptr, &fDst[0].fPts[0]);
                 }
             }
         }
     }
 };
 DEF_BENCH( return new ConicBench_EvalTan(false); )
 DEF_BENCH( return new ConicBench_EvalTan(true); )
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 152 matching lines @@
 DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::kOval_Type); )
 
 
 // These seem to be optimized away, which is troublesome for timing.
 /*
 DEF_BENCH( return new ConicBench_Chop5() )
 DEF_BENCH( return new ConicBench_ComputeError() )
 DEF_BENCH( return new ConicBench_asQuadTol() )
 DEF_BENCH( return new ConicBench_quadPow2() )
 */