Fix up all the easy virtual ... SK_OVERRIDE cases.

bench/InterpBench.cpp

 #include "Benchmark.h"
 #include "SkColorPriv.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkString.h"
 
 #define TILE(x, width)  (((x) & 0xFFFF) * width >> 16)
 
 class InterpBench : public Benchmark {
     enum {
         kBuffer = 128,
         kLoop   = 20000
     };
     SkString    fName;
     int16_t     fDst[kBuffer];
     float       fFx, fDx;
 public:
     InterpBench(const char name[])  {
         fName.printf("interp_%s", name);
         fFx = 3.3f;
         fDx = 0.1257f;
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
     virtual void performTest(int16_t dst[], float x, float dx, int count) = 0;
 
 protected:
     virtual int mulLoopCount() const { return 1; }
 
     virtual const char* onGetName() {
         return fName.c_str();
     }
 
     virtual void onDraw(const int loops, SkCanvas*) {
         int n = loops * this->mulLoopCount();
         for (int i = 0; i < n; i++) {
             this->performTest(fDst, fFx, fDx, kBuffer);
         }
     }
 
 private:
     typedef Benchmark INHERITED;
 };
 
 class Fixed16D16Interp : public InterpBench {
 public:
     Fixed16D16Interp() : INHERITED("16.16") {}
 
 protected:
-    virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+    void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
         SkFixed curr = SkFloatToFixed(fx);
         SkFixed step = SkFloatToFixed(dx);
         for (int i = 0; i < count; i += 4) {
             dst[i + 0] = TILE(curr, count); curr += step;
             dst[i + 1] = TILE(curr, count); curr += step;
             dst[i + 2] = TILE(curr, count); curr += step;
             dst[i + 3] = TILE(curr, count); curr += step;
         }
     }
 private:
     typedef InterpBench INHERITED;
 };
 
 class Fixed32D32Interp : public InterpBench {
 public:
     Fixed32D32Interp() : INHERITED("32.32") {}
 
 protected:
-    virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+    void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
         int64_t curr = (int64_t)(fx * 65536 * 655536);
         int64_t step = (int64_t)(dx * 65536 * 655536);
         SkFixed tmp;
         for (int i = 0; i < count; i += 4) {
             tmp = (SkFixed)(curr >> 16);
             dst[i + 0] = TILE(tmp, count);
             curr += step;
 
             tmp = (SkFixed)(curr >> 16);
             dst[i + 1] = TILE(tmp, count);
@@ skipping 10 matching lines @@
     }
 private:
     typedef InterpBench INHERITED;
 };
 
 class Fixed16D48Interp : public InterpBench {
 public:
     Fixed16D48Interp() : INHERITED("16.48") {}
 
 protected:
-    virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+    void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
         int64_t curr = (int64_t)(fx * 65536 * 655536 * 65536);
         int64_t step = (int64_t)(dx * 65536 * 655536 * 65536);
         SkFixed tmp;
         for (int i = 0; i < count; i += 4) {
             tmp = (SkFixed) (curr >> 32); dst[i + 0] = TILE(tmp, count); curr += step;
             tmp = (SkFixed) (curr >> 32); dst[i + 1] = TILE(tmp, count); curr += step;
             tmp = (SkFixed) (curr >> 32); dst[i + 2] = TILE(tmp, count); curr += step;
             tmp = (SkFixed) (curr >> 32); dst[i + 3] = TILE(tmp, count); curr += step;
         }
     }
 private:
     typedef InterpBench INHERITED;
 };
 
 class FloatInterp : public InterpBench {
 public:
     FloatInterp() : INHERITED("float") {}
 
 protected:
-    virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+    void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
         SkFixed tmp;
         for (int i = 0; i < count; i += 4) {
             tmp = SkFloatToFixed(fx); dst[i + 0] = TILE(tmp, count); fx += dx;
             tmp = SkFloatToFixed(fx); dst[i + 1] = TILE(tmp, count); fx += dx;
             tmp = SkFloatToFixed(fx); dst[i + 2] = TILE(tmp, count); fx += dx;
             tmp = SkFloatToFixed(fx); dst[i + 3] = TILE(tmp, count); fx += dx;
         }
     }
 private:
     typedef InterpBench INHERITED;
 };
 
 class DoubleInterp : public InterpBench {
 public:
     DoubleInterp() : INHERITED("double") {}
 
 protected:
-    virtual void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+    void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
         double ffx = fx;
         double ddx = dx;
         SkFixed tmp;
         for (int i = 0; i < count; i += 4) {
             tmp = SkDoubleToFixed(ffx); dst[i + 0] = TILE(tmp, count); ffx += ddx;
             tmp = SkDoubleToFixed(ffx); dst[i + 1] = TILE(tmp, count); ffx += ddx;
             tmp = SkDoubleToFixed(ffx); dst[i + 2] = TILE(tmp, count); ffx += ddx;
             tmp = SkDoubleToFixed(ffx); dst[i + 3] = TILE(tmp, count); ffx += ddx;
         }
     }
 private:
     typedef InterpBench INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DEF_BENCH( return new Fixed16D16Interp(); )
 DEF_BENCH( return new Fixed32D32Interp(); )
 DEF_BENCH( return new Fixed16D48Interp(); )
 DEF_BENCH( return new FloatInterp(); )
 DEF_BENCH( return new DoubleInterp(); )