Fix up -Winconsistent-missing-override

bench/MathBench.cpp

+/*
+ * Copyright 2015 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 "SkColorPriv.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkString.h"
 
 static float sk_fsel(float pred, float result_ge, float result_lt) {
     return pred >= 0 ? result_ge : result_lt;
 }
@@ skipping 24 matching lines @@
         return backend == kNonRendering_Backend;
     }
 
     virtual void performTest(float* SK_RESTRICT dst,
                               const float* SK_RESTRICT src,
                               int count) = 0;
 
 protected:
     virtual int mulLoopCount() const { return 1; }
 
-    virtual const char* onGetName() {
+    const char* onGetName() override {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) {
+    void onDraw(const int loops, SkCanvas*) override {
         int n = loops * this->mulLoopCount();
         for (int i = 0; i < n; i++) {
             this->performTest(fDst, fSrc, kBuffer);
         }
     }
 
 private:
     typedef Benchmark INHERITED;
 };
 
 class MathBenchU32 : public MathBench {
 public:
     MathBenchU32(const char name[]) : INHERITED(name) {}
 
 protected:
     virtual void performITest(uint32_t* SK_RESTRICT dst,
                               const uint32_t* SK_RESTRICT src,
                               int count) = 0;
 
-    virtual void performTest(float* SK_RESTRICT dst,
-                             const float* SK_RESTRICT src,
-                             int count) override {
+    void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override {
         uint32_t* d = SkTCast<uint32_t*>(dst);
         const uint32_t* s = SkTCast<const uint32_t*>(src);
         this->performITest(d, s, count);
     }
 private:
     typedef MathBench INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class NoOpMathBench : public MathBench {
 public:
     NoOpMathBench() : INHERITED("noOp") {}
 protected:
-    virtual void performTest(float* SK_RESTRICT dst,
-                              const float* SK_RESTRICT src,
-                              int count) {
+    void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[i] + 1;
         }
     }
 private:
     typedef MathBench INHERITED;
 };
 
 class SkRSqrtMathBench : public MathBench {
 public:
     SkRSqrtMathBench() : INHERITED("sk_float_rsqrt") {}
 protected:
-    virtual void performTest(float* SK_RESTRICT dst,
-                              const float* SK_RESTRICT src,
-                              int count) {
+    void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override {
         for (int i = 0; i < count; ++i) {
             dst[i] = sk_float_rsqrt(src[i]);
         }
     }
 private:
     typedef MathBench INHERITED;
 };
 
 
 class SlowISqrtMathBench : public MathBench {
 public:
     SlowISqrtMathBench() : INHERITED("slowIsqrt") {}
 protected:
-    virtual void performTest(float* SK_RESTRICT dst,
-                              const float* SK_RESTRICT src,
-                              int count) {
+    void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override {
         for (int i = 0; i < count; ++i) {
             dst[i] = 1.0f / sk_float_sqrt(src[i]);
         }
     }
 private:
     typedef MathBench INHERITED;
 };
 
 static inline float SkFastInvSqrt(float x) {
     float xhalf = 0.5f*x;
     int i = *SkTCast<int*>(&x);
     i = 0x5f3759df - (i>>1);
     x = *SkTCast<float*>(&i);
     x = x*(1.5f-xhalf*x*x);
 //    x = x*(1.5f-xhalf*x*x); // this line takes err from 10^-3 to 10^-6
     return x;
 }
 
 class FastISqrtMathBench : public MathBench {
 public:
     FastISqrtMathBench() : INHERITED("fastIsqrt") {}
 protected:
-    virtual void performTest(float* SK_RESTRICT dst,
-                              const float* SK_RESTRICT src,
-                              int count) {
+    void performTest(float* SK_RESTRICT dst, const float* SK_RESTRICT src, int count) override {
         for (int i = 0; i < count; ++i) {
             dst[i] = SkFastInvSqrt(src[i]);
         }
     }
 private:
     typedef MathBench INHERITED;
 };
 
 static inline uint32_t QMul64(uint32_t value, U8CPU alpha) {
     SkASSERT((uint8_t)alpha == alpha);
     const uint32_t mask = 0xFF00FF;
 
     uint64_t tmp = value;
     tmp = (tmp & mask) | ((tmp & ~mask) << 24);
     tmp *= alpha;
     return (uint32_t) (((tmp >> 8) & mask) | ((tmp >> 32) & ~mask));
 }
 
 class QMul64Bench : public MathBenchU32 {
 public:
     QMul64Bench() : INHERITED("qmul64") {}
 protected:
-    virtual void performITest(uint32_t* SK_RESTRICT dst,
-                              const uint32_t* SK_RESTRICT src,
-                              int count) override {
+    void performITest(uint32_t* SK_RESTRICT dst,
+                      const uint32_t* SK_RESTRICT src,
+                      int count) override {
         for (int i = 0; i < count; ++i) {
             dst[i] = QMul64(src[i], (uint8_t)i);
         }
     }
 private:
     typedef MathBenchU32 INHERITED;
 };
 
 class QMul32Bench : public MathBenchU32 {
 public:
     QMul32Bench() : INHERITED("qmul32") {}
 protected:
-    virtual void performITest(uint32_t* SK_RESTRICT dst,
-                              const uint32_t* SK_RESTRICT src,
-                              int count) override {
+    void performITest(uint32_t* SK_RESTRICT dst,
+                      const uint32_t* SK_RESTRICT src,
+                      int count) override {
         for (int i = 0; i < count; ++i) {
             dst[i] = SkAlphaMulQ(src[i], (uint8_t)i);
         }
     }
 private:
     typedef MathBenchU32 INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 88 matching lines @@
             fProc = gRec[index].fProc;
             fName = gRec[index].fName;
         }
     }
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas*) {
+    void onDraw(const int loops, SkCanvas*) override {
         IsFiniteProc proc = fProc;
         const float* data = fData;
         // do this so the compiler won't throw away the function call
         int counter = 0;
 
         if (proc) {
             for (int j = 0; j < loops; ++j) {
                 for (int i = 0; i < N - 4; ++i) {
                     counter += proc(&data[i]);
                 }
             }
         } else {
             for (int j = 0; j < loops; ++j) {
                 for (int i = 0; i < N - 4; ++i) {
                     const SkRect* r = reinterpret_cast<const SkRect*>(&data[i]);
                     if (false) { // avoid bit rot, suppress warning
                         isFinite(*r);
                     }
                     counter += r->isFinite();
                 }
             }
         }
 
         SkPaint paint;
         if (paint.getAlpha() == 0) {
             SkDebugf("%d\n", counter);
         }
     }
 
-    virtual const char* onGetName() {
+    const char* onGetName() override {
         return fName;
     }
 
 private:
     IsFiniteProc    fProc;
     const char*     fName;
 
     typedef Benchmark INHERITED;
 };
 
@@ skipping 19 matching lines @@
         }
     }
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
     virtual void process(float) {}
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas*) {
+    void onDraw(const int loops, SkCanvas*) override {
         SkRandom rand;
         float accum = 0;
         const float* data = fData;
 
         if (fFast) {
             for (int j = 0; j < loops; ++j) {
                 for (int i = 0; i < ARRAY; ++i) {
                     accum += fast_floor(data[i]);
                 }
                 this->process(accum);
             }
         } else {
             for (int j = 0; j < loops; ++j) {
                 for (int i = 0; i < ARRAY; ++i) {
                     accum += sk_float_floor(data[i]);
                 }
                 this->process(accum);
             }
         }
     }
 
-    virtual const char* onGetName() {
+    const char* onGetName() override {
         return fName;
     }
 
 private:
     const char*     fName;
 
     typedef Benchmark INHERITED;
 };
 
 class CLZBench : public Benchmark {
@@ skipping 19 matching lines @@
     }
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
     // just so the compiler doesn't remove our loops
     virtual void process(int) {}
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas*) {
+    void onDraw(const int loops, SkCanvas*) override {
         int accum = 0;
 
         if (fUsePortable) {
             for (int j = 0; j < loops; ++j) {
                 for (int i = 0; i < ARRAY; ++i) {
                     accum += SkCLZ_portable(fData[i]);
                 }
                 this->process(accum);
             }
         } else {
             for (int j = 0; j < loops; ++j) {
                 for (int i = 0; i < ARRAY; ++i) {
                     accum += SkCLZ(fData[i]);
                 }
                 this->process(accum);
             }
         }
     }
 
-    virtual const char* onGetName() {
+    const char* onGetName() override {
         return fName;
     }
 
 private:
     const char* fName;
 
     typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 15 matching lines @@
     }
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
     // just so the compiler doesn't remove our loops
     virtual void process(int) {}
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas*) {
+    void onDraw(const int loops, SkCanvas*) override {
         int accum = 0;
 
         for (int j = 0; j < loops; ++j) {
             for (int i = 0; i < ARRAY; ++i) {
                 accum += fVec[i].normalize();
             }
             this->process(accum);
         }
     }
 
-    virtual const char* onGetName() {
+    const char* onGetName() override {
         return fName;
     }
 
 private:
     const char* fName;
 
     typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 12 matching lines @@
             fData[i] = rand.nextSScalar1();
         }
 
     }
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas*) {
+    void onDraw(const int loops, SkCanvas*) override {
         for (int j = 0; j < loops; ++j) {
             for (int i = 0; i < N - 4; ++i) {
                 fResult[i] = SkFloatToFixed(fData[i]);
             }
         }
 
         SkPaint paint;
         if (paint.getAlpha() == 0) {
             SkDebugf("%d\n", fResult[0]);
         }
     }
 
-    virtual const char* onGetName() {
+    const char* onGetName() override {
         return "float_to_fixed";
     }
 
 private:
     typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
 class DivModBench : public Benchmark {
     SkString fName;
 public:
     explicit DivModBench(const char* name) {
         fName.printf("divmod_%s", name);
     }
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() {
+    const char* onGetName() override {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) {
+    void onDraw(const int loops, SkCanvas*) override {
         volatile T a = 0, b = 0;
         T div = 0, mod = 0;
         for (int i = 0; i < loops; i++) {
             if ((T)i == 0) continue;  // Small T will wrap around.
             SkTDivMod((T)(i+1), (T)i, &div, &mod);
             a ^= div;
             b ^= mod;
         }
     }
 };
@@ skipping 26 matching lines @@
 
 DEF_BENCH( return new FloorBench(false); )
 DEF_BENCH( return new FloorBench(true); )
 
 DEF_BENCH( return new CLZBench(false); )
 DEF_BENCH( return new CLZBench(true); )
 
 DEF_BENCH( return new NormalizeBench(); )
 
 DEF_BENCH( return new FixedMathBench(); )