Remove const from `const int loops`.

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 33 matching lines @@
 
 protected:
     const char* onGetName() override {
         fName.printf("path_%s_%s_",
                      fFlags & kStroke_Flag ? "stroke" : "fill",
                      fFlags & kBig_Flag ? "big" : "small");
         this->appendName(&fName);
         return fName.c_str();
     }
 
-    void onDraw(const int loops, SkCanvas* canvas) override {
+    void onDraw(int loops, SkCanvas* canvas) override {
         SkPaint paint(fPaint);
         this->setupPaint(&paint);
 
         SkPath path;
         this->makePath(&path);
         if (fFlags & kBig_Flag) {
             const SkMatrix m = SkMatrix::MakeScale(SkIntToScalar(10), SkIntToScalar(10));
             path.transform(m);
         }
 
@@ skipping 257 matching lines @@
 
 protected:
     const char* onGetName() override {
         return "path_create";
     }
 
     void onDelayedSetup() override {
         this->createData(10, 100);
     }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         for (int i = 0; i < loops; ++i) {
             if (i % 1000 == 0) {
                 fPath.reset();  // PathRef memory can grow without bound otherwise.
             }
             this->makePath(&fPath);
         }
         this->restartMakingPaths();
     }
 
 private:
@@ skipping 13 matching lines @@
     }
     void onDelayedSetup() override {
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
         fCopies.reset(kPathCnt);
         for (int i = 0; i < kPathCnt; ++i) {
             this->makePath(&fPaths[i]);
         }
         this->finishedMakingPaths();
     }
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         for (int i = 0; i < loops; ++i) {
             int idx = i & (kPathCnt - 1);
             fCopies[idx] = fPaths[idx];
         }
     }
 
 private:
     enum {
         // must be a pow 2
         kPathCnt = 1 << 5,
@@ skipping 19 matching lines @@
         fPaths.reset(kPathCnt);
         for (int i = 0; i < kPathCnt; ++i) {
             this->makePath(&fPaths[i]);
         }
         this->finishedMakingPaths();
         if (!fInPlace) {
             fTransformed.reset(kPathCnt);
         }
     }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         if (fInPlace) {
             for (int i = 0; i < loops; ++i) {
                 fPaths[i & (kPathCnt - 1)].transform(fMatrix);
             }
         } else {
             for (int i = 0; i < loops; ++i) {
                 int idx = i & (kPathCnt - 1);
                 fPaths[idx].transform(fMatrix, &fTransformed[idx]);
             }
         }
@@ skipping 26 matching lines @@
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
         fCopies.reset(kPathCnt);
         for (int i = 0; i < kPathCnt; ++i) {
             this->makePath(&fPaths[i]);
             fCopies[i] = fPaths[i];
         }
         this->finishedMakingPaths();
     }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         for (int i = 0; i < loops; ++i) {
             int idx = i & (kPathCnt - 1);
             fParity ^= (fPaths[idx] == fCopies[idx & ~0x1]);
         }
     }
 
 private:
     bool fParity; // attempt to keep compiler from optimizing out the ==
     enum {
         // must be a pow 2
@@ skipping 43 matching lines @@
         this->createData(10, 100, allowMoves);
         fPaths0.reset(kPathCnt);
         fPaths1.reset(kPathCnt);
         for (int i = 0; i < kPathCnt; ++i) {
             this->makePath(&fPaths0[i]);
             this->makePath(&fPaths1[i]);
         }
         this->finishedMakingPaths();
     }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         switch (fType) {
             case kAdd_AddType:
                 for (int i = 0; i < loops; ++i) {
                     int idx = i & (kPathCnt - 1);
                     SkPath result = fPaths0[idx];
                     result.addPath(fPaths1[idx]);
                 }
                 break;
             case kAddTrans_AddType:
                 for (int i = 0; i < loops; ++i) {
@@ skipping 47 matching lines @@
 public:
     CirclesBench(Flags flags) : fFlags(flags) {
         fName.printf("circles_%s", fFlags & kStroke_Flag ? "stroke" : "fill");
     }
 
 protected:
     const char* onGetName() override {
         return fName.c_str();
     }
 
-    void onDraw(const int loops, SkCanvas* canvas) override {
+    void onDraw(int loops, SkCanvas* canvas) override {
         SkPaint paint;
 
         paint.setColor(SK_ColorBLACK);
         paint.setAntiAlias(true);
         if (fFlags & kStroke_Flag) {
             paint.setStyle(SkPaint::kStroke_Style);
         }
 
         SkRandom rand;
 
@@ skipping 85 matching lines @@
         // we are lazy here and use the same x & y for each corner
         add_corner_arc(path, r, xCorner, yCorner, 270);
         add_corner_arc(path, r, xCorner, yCorner, 0);
         add_corner_arc(path, r, xCorner, yCorner, 90);
         add_corner_arc(path, r, xCorner, yCorner, 180);
         path->close();
 
         SkASSERT(path->isConvex());
     }
 
-    void onDraw(const int loops, SkCanvas* canvas) override {
+    void onDraw(int loops, SkCanvas* canvas) override {
         SkRandom rand;
         SkRect r;
 
         for (int i = 0; i < loops; ++i) {
             SkPaint paint;
             paint.setColor(0xff000000 | rand.nextU());
             paint.setAntiAlias(true);
 
             SkScalar size = rand.nextUScalar1() * 30;
             if (size < SK_Scalar1) {
@@ skipping 53 matching lines @@
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
 private:
     const char* onGetName() override {
         return fName.c_str();
     }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         for (int i = 0; i < loops; ++i) {
             const SkRect& rect = fQueryRects[i % kQueryRectCnt];
             fParity = fParity != fPath.conservativelyContainsRect(rect);
         }
     }
 
     void onDelayedSetup() override {
         fQueryRects.setCount(kQueryRectCnt);
 
         SkRandom rand;
@@ skipping 42 matching lines @@
         fRQ.fW = SkScalarCos(SK_ScalarPI/4);
     }
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
 private:
     const char* onGetName() override { return fName.c_str(); }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         for (int i = 0; i < loops; ++i) {
             fRQ.chop(fDst);
         }
     }
 
     typedef Benchmark INHERITED;
 };
 DEF_BENCH( return new ConicBench_Chop; )
 
 class ConicBench_EvalPos : public ConicBench_Chop {
     const bool fUseV2;
 public:
     ConicBench_EvalPos(bool useV2) : fUseV2(useV2) {
         fName.printf("conic-eval-pos%d", useV2);
     }
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(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], 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 {
+    void onDraw(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, nullptr, &fDst[0].fPts[0]);
@@ skipping 43 matching lines @@
 
 class ConicBench_ComputeError : public ConicBench {
 public:
     ConicBench_ComputeError()  {}
 
 protected:
     const char* onGetName() override {
         return "conic-compute-error";
     }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         SkVector err;
         for (int i = 0; i < loops; ++i) {
             for (int j = 0; j < CONICS; ++j) {
                 fConics[j].computeAsQuadError(&err);
             }
         }
     }
 
 private:
     typedef ConicBench INHERITED;
 };
 
 class ConicBench_asQuadTol : public ConicBench {
 public:
     ConicBench_asQuadTol()  {}
 
 protected:
     const char* onGetName() override {
         return "conic-asQuadTol";
     }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         for (int i = 0; i < loops; ++i) {
             for (int j = 0; j < CONICS; ++j) {
                 fConics[j].asQuadTol(SK_ScalarHalf);
             }
         }
     }
 
 private:
     typedef ConicBench INHERITED;
 };
 
 class ConicBench_quadPow2 : public ConicBench {
 public:
     ConicBench_quadPow2()  {}
 
 protected:
     const char* onGetName() override {
         return "conic-quadPow2";
     }
 
-    void onDraw(const int loops, SkCanvas*) override {
+    void onDraw(int loops, SkCanvas*) override {
         for (int i = 0; i < loops; ++i) {
             for (int j = 0; j < CONICS; ++j) {
                 fConics[j].computeQuadPOW2(SK_ScalarHalf);
             }
         }
     }
 
 private:
     typedef ConicBench INHERITED;
 };
@@ skipping 55 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() )
 */