Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / skia / 72c9faab45124e08c85f70ca38536914862d947c^! / . / bench
commit72c9faab45124e08c85f70ca38536914862d947c[log] [tgz]
authormtklein <mtklein@chromium.org>Fri Jan 09 10:06:39 2015 -0800
committerCommit bot <commit-bot@chromium.org>Fri Jan 09 10:06:40 2015 -0800
tree611893b84bb33b1592d058ee0f2382f7f86601b8
parent4490da227f1475fb66af20532c14d6d9febd18b6 [diff]
Fix up all the easy virtual ... SK_OVERRIDE cases.

This fixes every case where virtual and SK_OVERRIDE were on the same line,
which should be the bulk of cases.  We'll have to manually clean up the rest
over time unless I level up in regexes.

for f in (find . -type f); perl -p -i -e 's/virtual (.*)SK_OVERRIDE/\1SK_OVERRIDE/g' $f; end

BUG=skia:

Review URL: https://codereview.chromium.org/806653007

diff --git a/bench/AlternatingColorPatternBench.cpp b/bench/AlternatingColorPatternBench.cpp
index b497979..fccc494 100644
--- a/bench/AlternatingColorPatternBench.cpp
+++ b/bench/AlternatingColorPatternBench.cpp

@@ -108,7 +108,7 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
@@ -146,7 +146,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         paint.setAntiAlias(false);
         paint.setFilterLevel(SkPaint::kLow_FilterLevel);

diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp
index da2e829..c5efe9e 100644
--- a/bench/BitmapBench.cpp
+++ b/bench/BitmapBench.cpp

@@ -247,7 +247,7 @@
         INHERITED::onDraw(loops, canvas);
     }
 
-    virtual void setupPaint(SkPaint* paint) SK_OVERRIDE {
+    void setupPaint(SkPaint* paint) SK_OVERRIDE {
         this->INHERITED::setupPaint(paint);
 
         int index = 0;
@@ -303,7 +303,7 @@
         return fFullName.c_str();
     }
 
-    virtual void onDrawIntoBitmap(const SkBitmap& bm) SK_OVERRIDE {
+    void onDrawIntoBitmap(const SkBitmap& bm) SK_OVERRIDE {
         const int w = bm.width();
         const int h = bm.height();
 

diff --git a/bench/BitmapRectBench.cpp b/bench/BitmapRectBench.cpp
index 2ad7bdf..fb3ebda 100644
--- a/bench/BitmapRectBench.cpp
+++ b/bench/BitmapRectBench.cpp

@@ -59,7 +59,7 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         fName.printf("bitmaprect_%02X_%sfilter_%s",
                      fAlpha,
                      SkPaint::kNone_FilterLevel == fFilterLevel ? "no" : "",
@@ -67,7 +67,7 @@
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         fBitmap.allocPixels();
         fBitmap.setAlphaType(kOpaque_SkAlphaType);
         fBitmap.eraseColor(SK_ColorBLACK);
@@ -87,7 +87,7 @@
     }
 
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRandom rand;
 
         SkPaint paint;

diff --git a/bench/BitmapScaleBench.cpp b/bench/BitmapScaleBench.cpp
index 665e294..e5cd587 100644
--- a/bench/BitmapScaleBench.cpp
+++ b/bench/BitmapScaleBench.cpp

@@ -88,7 +88,7 @@
         setName( "filter" );
     }
 protected:
-    virtual void doScaleImage() SK_OVERRIDE {
+    void doScaleImage() SK_OVERRIDE {
         SkCanvas canvas( fOutputBitmap );
         SkPaint paint;
 

diff --git a/bench/BlurImageFilterBench.cpp b/bench/BlurImageFilterBench.cpp
index 9021d1b..68d0e6c 100644
--- a/bench/BlurImageFilterBench.cpp
+++ b/bench/BlurImageFilterBench.cpp

@@ -31,18 +31,18 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         if (!fInitialized) {
             make_checkerboard();
             fInitialized = true;
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         paint.setImageFilter(SkBlurImageFilter::Create(fSigmaX, fSigmaY))->unref();
 

diff --git a/bench/BlurRectBench.cpp b/bench/BlurRectBench.cpp
index cdcdfe5..66aff22 100644
--- a/bench/BlurRectBench.cpp
+++ b/bench/BlurRectBench.cpp

@@ -88,7 +88,7 @@
         this->setName(name);
     }
 protected:
-    virtual void makeBlurryRect(const SkRect& r) SK_OVERRIDE {
+    void makeBlurryRect(const SkRect& r) SK_OVERRIDE {
         SkMask mask;
         SkBlurMask::BlurRect(SkBlurMask::ConvertRadiusToSigma(this->radius()),
                              &mask, r, kNormal_SkBlurStyle);
@@ -110,7 +110,7 @@
     }
 
 protected:
-    virtual void preBenchSetup(const SkRect& r) SK_OVERRIDE {
+    void preBenchSetup(const SkRect& r) SK_OVERRIDE {
         SkMask::FreeImage(fSrcMask.fImage);
 
         r.roundOut(&fSrcMask.fBounds);
@@ -142,7 +142,7 @@
 
 protected:
 
-    virtual void makeBlurryRect(const SkRect&) SK_OVERRIDE {
+    void makeBlurryRect(const SkRect&) SK_OVERRIDE {
         SkMask mask;
         mask.fImage = NULL;
         SkBlurMask::BoxBlur(&mask, fSrcMask, SkBlurMask::ConvertRadiusToSigma(this->radius()),
@@ -169,7 +169,7 @@
 
 protected:
 
-    virtual void makeBlurryRect(const SkRect&) SK_OVERRIDE {
+    void makeBlurryRect(const SkRect&) SK_OVERRIDE {
         SkMask mask;
         mask.fImage = NULL;
         SkBlurMask::BlurGroundTruth(SkBlurMask::ConvertRadiusToSigma(this->radius()),

diff --git a/bench/BlurRectsBench.cpp b/bench/BlurRectsBench.cpp
index 7b98e00..553cf6b 100644
--- a/bench/BlurRectsBench.cpp
+++ b/bench/BlurRectsBench.cpp

@@ -21,7 +21,7 @@
         fInner = inner;
     }
 
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
@@ -29,7 +29,7 @@
         fName = name;
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         paint.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle, fRadius))->unref();
 

diff --git a/bench/BlurRoundRectBench.cpp b/bench/BlurRoundRectBench.cpp
index 52de22a..7ec89b8 100644
--- a/bench/BlurRoundRectBench.cpp
+++ b/bench/BlurRoundRectBench.cpp

@@ -30,16 +30,16 @@
         fRRect.setRectXY(r, SkIntToScalar(cornerRadius), SkIntToScalar(cornerRadius));
     }
 
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual SkIPoint onGetSize() SK_OVERRIDE {
+    SkIPoint onGetSize() SK_OVERRIDE {
         return SkIPoint::Make(SkScalarCeilToInt(fRRect.rect().width()),
                               SkScalarCeilToInt(fRRect.rect().height()));
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkLayerDrawLooper::Builder looperBuilder;
         {
             SkLayerDrawLooper::LayerInfo info;

diff --git a/bench/ChartBench.cpp b/bench/ChartBench.cpp
index 8d05ef1..175e1dd 100644
--- a/bench/ChartBench.cpp
+++ b/bench/ChartBench.cpp

@@ -94,7 +94,7 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         if (fAA) {
             return "chart_aa";
         } else {
@@ -102,7 +102,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         bool sizeChanged = false;
         if (canvas->getDeviceSize() != fSize) {
             fSize = canvas->getDeviceSize();

diff --git a/bench/ChecksumBench.cpp b/bench/ChecksumBench.cpp
index 7d3ec9f..661f9e6 100644
--- a/bench/ChecksumBench.cpp
+++ b/bench/ChecksumBench.cpp

@@ -35,7 +35,7 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 

diff --git a/bench/CmapBench.cpp b/bench/CmapBench.cpp
index db4ed74..ca0b25d 100644
--- a/bench/CmapBench.cpp
+++ b/bench/CmapBench.cpp

@@ -81,11 +81,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         fProc(loops, fPaint, fText, sizeof(fText), NGLYPHS);
     }
 

diff --git a/bench/ColorCubeBench.cpp b/bench/ColorCubeBench.cpp
index 141edf6..0d1e589 100644
--- a/bench/ColorCubeBench.cpp
+++ b/bench/ColorCubeBench.cpp

@@ -27,22 +27,22 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "colorcube";
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         if (!SkToBool(fCubeData)) {
             this->makeCubeData();
             this->make_bitmap();
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         this->test(loops, canvas);
     }
 
-    virtual SkIPoint onGetSize() SK_OVERRIDE {
+    SkIPoint onGetSize() SK_OVERRIDE {
         return SkIPoint::Make(fSize.width(), fSize.height());
     }
 

diff --git a/bench/ColorFilterBench.cpp b/bench/ColorFilterBench.cpp
index 7eae21a..b8cfbc3 100644
--- a/bench/ColorFilterBench.cpp
+++ b/bench/ColorFilterBench.cpp

@@ -68,11 +68,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "colorfilter_dim_bright_small" : "colorfilter_dim_bright_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -98,11 +98,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "colorfilter_bright_gray_small" : "colorfilter_bright_gray_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -125,11 +125,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "colorfilter_gray_bright_small" : "colorfilter_gray_bright_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -152,11 +152,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "colorfilter_blue_bright_small" : "colorfilter_blue_bright_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -179,11 +179,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "colorfilter_bright_blue_small" : "colorfilter_bright_blue_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -206,11 +206,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "colorfilter_bright_small" : "colorfilter_bright_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -232,11 +232,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "colorfilter_blue_small" : "colorfilter_blue_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -258,11 +258,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "colorfilter_gray_small" : "colorfilter_gray_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -284,11 +284,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "table_colorfilter_small" : "table_colorfilter_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);
@@ -322,11 +322,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "luma_colorfilter_small" : "luma_colorfilter_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = getFilterRect();
         SkPaint paint;
         paint.setColor(SK_ColorRED);

diff --git a/bench/ColorPrivBench.cpp b/bench/ColorPrivBench.cpp
index 01810ed..4d04e89 100644
--- a/bench/ColorPrivBench.cpp
+++ b/bench/ColorPrivBench.cpp

@@ -12,13 +12,13 @@
         fName.append(kScale ? "_255" : "_256");
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
-    virtual const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+    const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         // A handful of random srcs and dsts.
         SkRandom rand;
         for (int i = 0; i < kInputs; i++) {
@@ -33,7 +33,7 @@
         if (kScale) fScales[256] = 255;  // We'll just do 255 twice if we're limited to [0,255].
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         // We xor results of FourByteInterp into junk to make sure the function runs.
         volatile SkPMColor junk = 0;
 

diff --git a/bench/CoverageBench.cpp b/bench/CoverageBench.cpp
index ecb0ee6..097a9e1 100644
--- a/bench/CoverageBench.cpp
+++ b/bench/CoverageBench.cpp

@@ -44,11 +44,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         if (fDrawCoverage) {
             for (int i = 0; i < loops; ++i) {
                 fDraw.drawPathCoverage(fPath, fPaint);

diff --git a/bench/DashBench.cpp b/bench/DashBench.cpp
index f4d09c6..5f20969 100644
--- a/bench/DashBench.cpp
+++ b/bench/DashBench.cpp

@@ -57,11 +57,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         this->setupPaint(&paint);
         paint.setStyle(SkPaint::kStroke_Style);
@@ -190,11 +190,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         SkPath dst;
         for (int i = 0; i < loops; ++i) {
             SkStrokeRec rec(SkStrokeRec::kHairline_InitStyle);
@@ -228,11 +228,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         this->setupPaint(&paint);
         paint.setStrokeWidth(fStrokeWidth);
@@ -267,11 +267,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint p;
         this->setupPaint(&p);
         p.setColor(SK_ColorBLACK);
@@ -353,11 +353,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint p;
         this->setupPaint(&p);
         p.setStyle(SkPaint::kStroke_Style);
@@ -393,11 +393,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint p;
         this->setupPaint(&p);
         p.setColor(SK_ColorBLACK);

diff --git a/bench/DecodeBench.cpp b/bench/DecodeBench.cpp
index b03f898..507a7d8 100644
--- a/bench/DecodeBench.cpp
+++ b/bench/DecodeBench.cpp

@@ -24,7 +24,7 @@
         fName.printf("decode_%s_%s", sk_tool_utils::colortype_name(ct), fname.c_str());
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 

diff --git a/bench/DeferredSurfaceCopyBench.cpp b/bench/DeferredSurfaceCopyBench.cpp
index e1c3e3b..e0bf8e7 100644
--- a/bench/DeferredSurfaceCopyBench.cpp
+++ b/bench/DeferredSurfaceCopyBench.cpp

@@ -26,12 +26,12 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fDiscardableContents ? "DeferredSurfaceCopy_discardable" :
             "DeferredSurfaceCopy_nonDiscardable";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         // The canvas is not actually used for this test except to provide
         // configuration information: gpu, multisampling, size, etc?
         SkImageInfo info = SkImageInfo::MakeN32Premul(kSurfaceWidth, kSurfaceHeight);

diff --git a/bench/DisplacementBench.cpp b/bench/DisplacementBench.cpp
index 2a0f7c0..2f9a69e 100644
--- a/bench/DisplacementBench.cpp
+++ b/bench/DisplacementBench.cpp

@@ -22,7 +22,7 @@
     }
 
 protected:
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         if (!fInitialized) {
             this->makeBitmap();
             this->makeCheckerboard();
@@ -91,11 +91,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return this->isSmall() ? "displacement_zero_small" : "displacement_zero_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
         // No displacement effect
@@ -118,11 +118,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "displacement_alpha_small" : "displacement_alpha_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
         // Displacement, with 1 alpha component (which isn't pre-multiplied)
@@ -144,11 +144,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return isSmall() ? "displacement_full_small" : "displacement_full_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
         // Displacement, with 2 non-alpha components

diff --git a/bench/ETCBitmapBench.cpp b/bench/ETCBitmapBench.cpp
index 4255923..351b0ea 100644
--- a/bench/ETCBitmapBench.cpp
+++ b/bench/ETCBitmapBench.cpp

@@ -122,12 +122,12 @@
     ETCBitmapBench(bool decompress, Backend backend)
         : fDecompress(decompress), fBackend(backend) { }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == this->fBackend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         if (kGPU_Backend == this->fBackend) {
             if (this->fDecompress) {
                 return "etc1bitmap_render_gpu_decompressed";
@@ -144,7 +144,7 @@
         }
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         if (NULL == fPKMData) {
             SkDebugf("Failed to load PKM data!\n");
             return;
@@ -162,7 +162,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             canvas->drawBitmap(this->fBitmap, 0, 0, NULL);
         }
@@ -187,7 +187,7 @@
         : ETCBitmapBench(decompress, backend) { }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         if (kGPU_Backend == this->backend()) {
             if (this->decompress()) {
                 return "etc1bitmap_upload_gpu_decompressed";
@@ -204,7 +204,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPixelRef* pr = fBitmap.pixelRef();
         for (int i = 0; i < loops; ++i) {
             if (pr) {

diff --git a/bench/FSRectBench.cpp b/bench/FSRectBench.cpp
index 3c53042..af99015 100644
--- a/bench/FSRectBench.cpp
+++ b/bench/FSRectBench.cpp

@@ -20,9 +20,9 @@
     FSRectBench() : fInit(false) { }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE { return "fullscreen_rects"; }
+    const char* onGetName() SK_OVERRIDE { return "fullscreen_rects"; }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         if (!fInit) {
             SkRandom rand;
             static const SkScalar kMinOffset = 0;
@@ -39,7 +39,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         for (int i = 0; i < loops; ++i) {
             paint.setColor(fColors[i % N]);

diff --git a/bench/FontCacheBench.cpp b/bench/FontCacheBench.cpp
index dbf6b16..3bff063 100644
--- a/bench/FontCacheBench.cpp
+++ b/bench/FontCacheBench.cpp

@@ -28,11 +28,11 @@
     FontCacheBench()  {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "fontcache";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         this->setupPaint(&paint);
         paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
@@ -104,11 +104,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "fontefficiency";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         static bool gDone;
         if (gDone) {
             return;

diff --git a/bench/GMBench.h b/bench/GMBench.h
index e224052..43ca981 100644
--- a/bench/GMBench.h
+++ b/bench/GMBench.h

@@ -21,10 +21,10 @@
     virtual ~GMBench();
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE;
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE;
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE;
-    virtual SkIPoint onGetSize() SK_OVERRIDE;
+    const char* onGetName() SK_OVERRIDE;
+    bool isSuitableFor(Backend backend) SK_OVERRIDE;
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE;
+    SkIPoint onGetSize() SK_OVERRIDE;
 
 private:
     skiagm::GM* fGM;

diff --git a/bench/GameBench.cpp b/bench/GameBench.cpp
index c37f46d..bf70b5c 100644
--- a/bench/GameBench.cpp
+++ b/bench/GameBench.cpp

@@ -74,11 +74,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         if (!fInitialized) {
             this->makeCheckerboard();
             this->makeAtlas();
@@ -86,7 +86,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRandom scaleRand;
         SkRandom transRand;
         SkRandom rotRand;

diff --git a/bench/GeometryBench.cpp b/bench/GeometryBench.cpp
index a5c4643..fd86eff 100644
--- a/bench/GeometryBench.cpp
+++ b/bench/GeometryBench.cpp

@@ -16,11 +16,11 @@
         fName.printf("geo_%s", suffix);
     }
 
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return kNonRendering_Backend == backend;
     }
 
@@ -65,7 +65,7 @@
     GeoRectBench_intersect() : GeoRectBench("rect_intersect") {}
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int outer = 0; outer < loops; ++outer) {
             int count = 0;
             for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
@@ -82,7 +82,7 @@
     GeoRectBench_intersect_rect() : GeoRectBench("rect_intersect_rect") {}
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int outer = 0; outer < loops; ++outer) {
             int count = 0;
             SkRect r;
@@ -99,7 +99,7 @@
     GeoRectBench_Intersects() : GeoRectBench("rect_Intersects") {}
     
 protected:
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int outer = 0; outer < loops; ++outer) {
             int count = 0;
             for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
@@ -115,7 +115,7 @@
     GeoRectBench_sort() : GeoRectBench("rect_sort") {}
     
 protected:
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int outer = 0; outer < loops; ++outer) {
             for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
                 fRects[i].sort();

diff --git a/bench/GrMemoryPoolBench.cpp b/bench/GrMemoryPoolBench.cpp
index 6e6a37e..320ff00 100644
--- a/bench/GrMemoryPoolBench.cpp
+++ b/bench/GrMemoryPoolBench.cpp

@@ -32,7 +32,7 @@
  */
 class GrMemoryPoolBenchStack : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -94,7 +94,7 @@
  */
 class GrMemoryPoolBenchRandom : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -142,7 +142,7 @@
         M = 4 * (1 << 10),
     };
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 

diff --git a/bench/GrOrderedSetBench.cpp b/bench/GrOrderedSetBench.cpp
index dde1c4a..280ed2c 100644
--- a/bench/GrOrderedSetBench.cpp
+++ b/bench/GrOrderedSetBench.cpp

@@ -21,25 +21,25 @@
         fName.append("ordered_set_build");
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return kNonRendering_Backend == backend;
     }
 
     virtual ~GrOrderedSetBuildBench() {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkRandom rand;
         for (int j = 0; j < NUM_ELEMENTS; ++j) {
             fData[j] = rand.nextU() % NUM_ELEMENTS;
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             GrOrderedSet<int> set;
             for (int j = 0; j < NUM_ELEMENTS; ++j) {
@@ -62,18 +62,18 @@
         fName.append("ordered_set_find");
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return kNonRendering_Backend == backend;
     }
 
     virtual ~GrOrderedSetFindBench() {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkRandom rand;
         for (int j = 0; j < NUM_ELEMENTS; ++j) {
             fData[j] = rand.nextU() % 1500;
@@ -81,7 +81,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             for (int j = 0; j < NUM_ELEMENTS; ++j) {
                 fSet.find(fData[j]);
@@ -103,25 +103,25 @@
         fName.append("ordered_set_remove");
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return kNonRendering_Backend == backend;
     }
 
     virtual ~GrOrderedSetRemoveBench() {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkRandom rand;
         for (int j = 0; j < NUM_ELEMENTS; ++j) {
             fSet.insert(rand.nextU() % NUM_ELEMENTS);
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         typedef GrOrderedSet<int>::Iter SetIter;
         for (int i = 0; i < loops; ++i) {
             GrOrderedSet<int> testSet;

diff --git a/bench/HairlinePathBench.cpp b/bench/HairlinePathBench.cpp
index 37fc57d..f52fc3b 100644
--- a/bench/HairlinePathBench.cpp
+++ b/bench/HairlinePathBench.cpp

@@ -42,7 +42,7 @@
     virtual void makePath(SkPath*) = 0;
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         fName.printf("path_hairline_%s_%s_",
                      fFlags & kBig_Flag ? "big" : "small",
                      fFlags & kAA_Flag ? "AA" : "noAA");
@@ -50,7 +50,7 @@
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint(fPaint);
         this->setupPaint(&paint);
 
@@ -80,10 +80,10 @@
 public:
     LinePathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("line");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
@@ -112,10 +112,10 @@
 public:
     QuadPathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("quad");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
@@ -144,10 +144,10 @@
 public:
     ConicPathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("conic");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         SkRandom randWeight;
         int size = SK_ARRAY_COUNT(points);
@@ -180,10 +180,10 @@
 public:
     CubicPathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("cubic");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;

diff --git a/bench/ImageCacheBench.cpp b/bench/ImageCacheBench.cpp
index b8f40c8..1160f93 100644
--- a/bench/ImageCacheBench.cpp
+++ b/bench/ImageCacheBench.cpp

@@ -24,8 +24,8 @@
 
     TestRec(const TestKey& key, intptr_t value) : fKey(key), fValue(value) {}
 
-    virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
-    virtual size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
+    const Key& getKey() const SK_OVERRIDE { return fKey; }
+    size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
 
     static bool Visitor(const SkResourceCache::Rec&, void*) {
         return true;
@@ -49,11 +49,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "imagecache";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         if (fCache.getTotalBytesUsed() == 0) {
             this->populateCache();
         }

diff --git a/bench/ImageDecodeBench.cpp b/bench/ImageDecodeBench.cpp
index 3ce2fb0..55dffe9 100644
--- a/bench/ImageDecodeBench.cpp
+++ b/bench/ImageDecodeBench.cpp

@@ -28,16 +28,16 @@
         fName.append(SkOSPath::Basename(filename));
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkFILEStream fileStream(fFilename.c_str());
         fValid = fileStream.isValid() && fileStream.getLength() > 0;
         if (fValid) {
@@ -52,7 +52,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
 #ifdef SK_DEBUG
         if (!fValid) {
             SkDebugf("stream was invalid: %s\n", fName.c_str());

diff --git a/bench/ImageFilterDAGBench.cpp b/bench/ImageFilterDAGBench.cpp
index 680628e..0e5d4d1 100644
--- a/bench/ImageFilterDAGBench.cpp
+++ b/bench/ImageFilterDAGBench.cpp

@@ -21,11 +21,11 @@
     ImageFilterDAGBench() {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "image_filter_dag";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int j = 0; j < loops; j++) {
             SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(20.0f, 20.0f));
             SkImageFilter* inputs[kNumInputs];

diff --git a/bench/InterpBench.cpp b/bench/InterpBench.cpp
index b19af8f..c03da4b 100644
--- a/bench/InterpBench.cpp
+++ b/bench/InterpBench.cpp

@@ -22,7 +22,7 @@
         fDx = 0.1257f;
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -51,7 +51,7 @@
     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) {
@@ -70,7 +70,7 @@
     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;
@@ -101,7 +101,7 @@
     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;
@@ -121,7 +121,7 @@
     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;
@@ -139,7 +139,7 @@
     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;

diff --git a/bench/LightingBench.cpp b/bench/LightingBench.cpp
index 4d234b9..ed0c985 100644
--- a/bench/LightingBench.cpp
+++ b/bench/LightingBench.cpp

@@ -101,11 +101,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fIsSmall ? "lightingpointlitdiffuse_small" : "lightingpointlitdiffuse_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         draw(loops, canvas, SkLightingImageFilter::CreatePointLitDiffuse(getPointLocation(),
                                                                          getWhite(),
                                                                          getSurfaceScale(),
@@ -122,11 +122,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fIsSmall ? "lightingdistantlitdiffuse_small" : "lightingdistantlitdiffuse_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         draw(loops, canvas, SkLightingImageFilter::CreateDistantLitDiffuse(getDistantDirection(),
                                                                            getWhite(),
                                                                            getSurfaceScale(),
@@ -143,11 +143,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fIsSmall ? "lightingspotlitdiffuse_small" : "lightingspotlitdiffuse_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         draw(loops, canvas, SkLightingImageFilter::CreateSpotLitDiffuse(getSpotLocation(),
                                                                         getSpotTarget(),
                                                                         getSpotExponent(),
@@ -167,11 +167,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fIsSmall ? "lightingpointlitspecular_small" : "lightingpointlitspecular_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         draw(loops, canvas, SkLightingImageFilter::CreatePointLitSpecular(getPointLocation(),
                                                                           getWhite(),
                                                                           getSurfaceScale(),
@@ -189,11 +189,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fIsSmall ? "lightingdistantlitspecular_small" : "lightingdistantlitspecular_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         draw(loops, canvas, SkLightingImageFilter::CreateDistantLitSpecular(getDistantDirection(),
                                                                             getWhite(),
                                                                             getSurfaceScale(),
@@ -211,11 +211,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fIsSmall ? "lightingspotlitspecular_small" : "lightingspotlitspecular_large";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         draw(loops, canvas, SkLightingImageFilter::CreateSpotLitSpecular(getSpotLocation(),
                                                                          getSpotTarget(),
                                                                          getSpotExponent(),

diff --git a/bench/LineBench.cpp b/bench/LineBench.cpp
index bb6215b..e5065d2 100644
--- a/bench/LineBench.cpp
+++ b/bench/LineBench.cpp

@@ -38,11 +38,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         this->setupPaint(&paint);
 

diff --git a/bench/MagnifierBench.cpp b/bench/MagnifierBench.cpp
index c47dcdc..39bec98 100644
--- a/bench/MagnifierBench.cpp
+++ b/bench/MagnifierBench.cpp

@@ -22,18 +22,18 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fIsSmall ? "magnifier_small" : "magnifier_large";
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         if (!fInitialized) {
             make_checkerboard();
             fInitialized = true;
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
         const int h = fIsSmall ? FILTER_HEIGHT_SMALL : FILTER_HEIGHT_LARGE;
         SkPaint paint;

diff --git a/bench/MathBench.cpp b/bench/MathBench.cpp
index dbd661f..5b46d1c 100644
--- a/bench/MathBench.cpp
+++ b/bench/MathBench.cpp

@@ -31,7 +31,7 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -285,7 +285,7 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -353,7 +353,7 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -414,7 +414,7 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -470,7 +470,7 @@
         fName = "point_normalize";
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -517,7 +517,7 @@
 
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -553,7 +553,7 @@
         fName.printf("divmod_%s", name);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 

diff --git a/bench/Matrix44Bench.cpp b/bench/Matrix44Bench.cpp
index 8a7c50e..3739458 100644
--- a/bench/Matrix44Bench.cpp
+++ b/bench/Matrix44Bench.cpp

@@ -17,7 +17,7 @@
         fName.printf("matrix44_%s", name);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 

diff --git a/bench/MatrixBench.cpp b/bench/MatrixBench.cpp
index 78482d9..1a35c2e 100644
--- a/bench/MatrixBench.cpp
+++ b/bench/MatrixBench.cpp

@@ -18,7 +18,7 @@
         fName.printf("matrix_%s", name);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 

diff --git a/bench/MemcpyBench.cpp b/bench/MemcpyBench.cpp
index 567320b..4778d54 100644
--- a/bench/MemcpyBench.cpp
+++ b/bench/MemcpyBench.cpp

@@ -18,15 +18,15 @@
         , fMemcpy32(memcpy32)
         , fName(SkStringPrintf("%s_%d", name, count)) {}
 
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         fDst.reset(fCount);
         fSrc.reset(fCount);
 
@@ -36,7 +36,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < loops; i++) {
             fMemcpy32(fDst, fSrc, fCount);
         }

diff --git a/bench/MemoryBench.cpp b/bench/MemoryBench.cpp
index 05ec83b..c2c9a1a 100644
--- a/bench/MemoryBench.cpp
+++ b/bench/MemoryBench.cpp

@@ -21,16 +21,16 @@
         fName.printf("chunkalloc_" SK_SIZE_T_SPECIFIER, minSize);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         size_t inc = fMinSize >> 4;
         SkASSERT(inc > 0);
         size_t total = fMinSize * 64;

diff --git a/bench/MemsetBench.cpp b/bench/MemsetBench.cpp
index 3e0e8cd..41b802c 100644
--- a/bench/MemsetBench.cpp
+++ b/bench/MemsetBench.cpp

@@ -35,18 +35,18 @@
         fName.printf("memset%d_%d_%d", type, minSize, maxSize);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
     virtual void performTest() = 0;
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             this->performTest();
         }
@@ -63,7 +63,7 @@
         : INHERITED(MEMSET32, minSize, maxSize) {}
 
 protected:
-    virtual void performTest() SK_OVERRIDE {
+    void performTest() SK_OVERRIDE {
         for(int j = fMinSize; j < fMaxSize; ++j){
             sk_memset32(kBuffer, VALUE32, j);
             sk_memset32(kBuffer + 1, VALUE32, j);
@@ -82,7 +82,7 @@
         : INHERITED(MEMSET16, minSize, maxSize) {}
 
 protected:
-    virtual void performTest() SK_OVERRIDE {
+    void performTest() SK_OVERRIDE {
         for(int j = fMinSize; j < fMaxSize; ++j){
             sk_memset16(kBuffer, VALUE16, j);
             sk_memset16(kBuffer + 1, VALUE16, j);

diff --git a/bench/MergeBench.cpp b/bench/MergeBench.cpp
index 2e1ca32..1e8069e 100644
--- a/bench/MergeBench.cpp
+++ b/bench/MergeBench.cpp

@@ -20,11 +20,11 @@
     MergeBench(bool small) : fIsSmall(small), fInitialized(false) { }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fIsSmall ? "merge_small" : "merge_large";
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         if (!fInitialized) {
             make_bitmap();
             make_checkerboard();
@@ -32,7 +32,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMALL) :
                               SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARGE);
         SkPaint paint;

diff --git a/bench/MutexBench.cpp b/bench/MutexBench.cpp
index 59f054c..b9d54f1 100644
--- a/bench/MutexBench.cpp
+++ b/bench/MutexBench.cpp

@@ -9,7 +9,7 @@
 
 class MutexBench : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 

diff --git a/bench/PatchBench.cpp b/bench/PatchBench.cpp
index 744141a..cc9cb84 100644
--- a/bench/PatchBench.cpp
+++ b/bench/PatchBench.cpp

@@ -82,7 +82,7 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         SkString vertexMode;
         switch (fVertexMode) {
             case kNone_VertexMode:
@@ -107,7 +107,7 @@
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         this->setCubics();
         this->setColors();
         this->setTexCoords();
@@ -123,7 +123,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         canvas->scale(fScale.x(), fScale.y());
         for (int i = 0; i < loops; i++) {
             switch (fVertexMode) {
@@ -161,11 +161,11 @@
     SquarePatchBench(SkPoint scale, VertexMode vertexMode)
     : INHERITED(scale, vertexMode) { }
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("square");
     }
 
-    virtual void setCubics() SK_OVERRIDE {
+    void setCubics() SK_OVERRIDE {
         const SkPoint points[SkPatchUtils::kNumCtrlPts] = {
             //top points
             {100,100},{150,100},{250,100}, {300,100},
@@ -187,11 +187,11 @@
     LODDiffPatchBench(SkPoint scale, VertexMode vertexMode)
     : INHERITED(scale, vertexMode) { }
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("LOD_Diff");
     }
 
-    virtual void setCubics() SK_OVERRIDE {
+    void setCubics() SK_OVERRIDE {
         const SkPoint points[SkPatchUtils::kNumCtrlPts] = {
             //top points
             {100,175},{150,100},{250,100}, {300,0},
@@ -213,11 +213,11 @@
     LoopPatchBench(SkPoint scale, VertexMode vertexMode)
     : INHERITED(scale, vertexMode) { }
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("loop");
     }
 
-    virtual void setCubics() SK_OVERRIDE {
+    void setCubics() SK_OVERRIDE {
         const SkPoint points[SkPatchUtils::kNumCtrlPts] = {
             //top points
             {100,100},{300,200},{100,200}, {300,100},

diff --git a/bench/PatchGridBench.cpp b/bench/PatchGridBench.cpp
index c250781..0fe12e2 100644
--- a/bench/PatchGridBench.cpp
+++ b/bench/PatchGridBench.cpp

@@ -163,7 +163,7 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         SkString vertexMode;
         switch (fVertexMode) {
             case kNone_VertexMode:
@@ -200,7 +200,7 @@
         return fName.c_str();
     }
     
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         this->setGrid();
         switch (fVertexMode) {
             case kTexCoords_VertexMode:
@@ -214,7 +214,7 @@
         this->setupPaint(&fPaint);
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         this->setScale(canvas);
         for (int i = 0; i < loops; i++) {
             fGrid.draw(canvas, fPaint);

diff --git a/bench/PathBench.cpp b/bench/PathBench.cpp
index 297d36d..b597f91 100644
--- a/bench/PathBench.cpp
+++ b/bench/PathBench.cpp

@@ -42,7 +42,7 @@
     virtual int complexity() { return 0; }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         fName.printf("path_%s_%s_",
                      fFlags & kStroke_Flag ? "stroke" : "fill",
                      fFlags & kBig_Flag ? "big" : "small");
@@ -50,7 +50,7 @@
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint(fPaint);
         this->setupPaint(&paint);
 
@@ -81,10 +81,10 @@
 public:
     TrianglePathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("triangle");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         static const int gCoord[] = {
             10, 10, 15, 5, 20, 20
         };
@@ -101,10 +101,10 @@
 public:
     RectPathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("rect");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         SkRect r = { 10, 10, 20, 20 };
         path->addRect(r);
     }
@@ -116,10 +116,10 @@
 public:
     OvalPathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("oval");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         SkRect r = { 10, 10, 23, 20 };
         path->addOval(r);
     }
@@ -131,10 +131,10 @@
 public:
     CirclePathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("circle");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         path->addCircle(SkIntToScalar(20), SkIntToScalar(20),
                         SkIntToScalar(10));
     }
@@ -146,7 +146,7 @@
 public:
     SawToothPathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("sawtooth");
     }
     virtual void makePath(SkPath* path) {
@@ -167,7 +167,7 @@
         path->lineTo(x0, y + 2 * dy);
         path->close();
     }
-    virtual int complexity() SK_OVERRIDE { return 1; }
+    int complexity() SK_OVERRIDE { return 1; }
 private:
     typedef PathBench INHERITED;
 };
@@ -176,10 +176,10 @@
 public:
     LongCurvedPathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("long_curved");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand (12);
         int i;
         for (i = 0; i < 100; i++) {
@@ -190,7 +190,7 @@
         }
         path->close();
     }
-    virtual int complexity() SK_OVERRIDE { return 2; }
+    int complexity() SK_OVERRIDE { return 2; }
 private:
     typedef PathBench INHERITED;
 };
@@ -199,24 +199,24 @@
 public:
     LongLinePathBench(Flags flags) : INHERITED(flags) {}
 
-    virtual void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) SK_OVERRIDE {
         name->append("long_line");
     }
-    virtual void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) SK_OVERRIDE {
         SkRandom rand;
         path->moveTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
         for (size_t i = 1; i < 100; i++) {
             path->lineTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
         }
     }
-    virtual int complexity() SK_OVERRIDE { return 2; }
+    int complexity() SK_OVERRIDE { return 2; }
 private:
     typedef PathBench INHERITED;
 };
 
 class RandomPathBench : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -321,15 +321,15 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "path_create";
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         this->createData(10, 100);
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             if (i % 1000 == 0) {
                 fPath.reset();  // PathRef memory can grow without bound otherwise.
@@ -351,10 +351,10 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "path_copy";
     }
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
         fCopies.reset(kPathCnt);
@@ -363,7 +363,7 @@
         }
         this->finishedMakingPaths();
     }
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             int idx = i & (kPathCnt - 1);
             fCopies[idx] = fPaths[idx];
@@ -386,11 +386,11 @@
     PathTransformBench(bool inPlace) : fInPlace(inPlace) {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fInPlace ? "path_transform_in_place" : "path_transform_copy";
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         fMatrix.setScale(5 * SK_Scalar1, 6 * SK_Scalar1);
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
@@ -403,7 +403,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         if (fInPlace) {
             for (int i = 0; i < loops; ++i) {
                 fPaths[i & (kPathCnt - 1)].transform(fMatrix);
@@ -434,11 +434,11 @@
     PathEqualityBench() { }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "path_equality_50%";
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         fParity = 0;
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
@@ -450,7 +450,7 @@
         this->finishedMakingPaths();
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             int idx = i & (kPathCnt - 1);
             fParity ^= (fPaths[idx] == fCopies[idx & ~0x1]);
@@ -483,7 +483,7 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         switch (fType) {
             case kAdd_AddType:
                 return "path_add_path";
@@ -501,7 +501,7 @@
         }
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         // reversePathTo assumes a single contour path.
         bool allowMoves = kReversePathTo_AddType != fType;
         this->createData(10, 100, allowMoves);
@@ -514,7 +514,7 @@
         this->finishedMakingPaths();
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         switch (fType) {
             case kAdd_AddType:
                 for (int i = 0; i < loops; ++i) {
@@ -578,11 +578,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
 
         paint.setColor(SK_ColorBLACK);
@@ -642,7 +642,7 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
@@ -688,7 +688,7 @@
         SkASSERT(path->isConvex());
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRandom rand;
         SkRect r;
 
@@ -753,23 +753,23 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 private:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             const SkRect& rect = fQueryRects[i % kQueryRectCnt];
             fParity = fParity != fPath.conservativelyContainsRect(rect);
         }
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         fQueryRects.setCount(kQueryRectCnt);
 
         SkRandom rand;
@@ -817,11 +817,11 @@
     }
 
 private:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "ratquad-chop-0.5";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         SkConic dst[2];
         for (int i = 0; i < loops; ++i) {
             fRQ.chopAt(0.5f, dst);
@@ -842,11 +842,11 @@
     }
 
 private:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "ratquad-chop-half";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         SkConic dst[2];
         for (int i = 0; i < loops; ++i) {
             fRQ.chop(dst);
@@ -878,7 +878,7 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -897,11 +897,11 @@
     ConicBench_ComputeError()  {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "conic-compute-error";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         SkVector err;
         for (int i = 0; i < loops; ++i) {
             for (int j = 0; j < CONICS; ++j) {
@@ -919,11 +919,11 @@
     ConicBench_asQuadTol()  {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "conic-asQuadTol";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             for (int j = 0; j < CONICS; ++j) {
                 fConics[j].asQuadTol(SK_ScalarHalf);
@@ -940,11 +940,11 @@
     ConicBench_quadPow2()  {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "conic-quadPow2";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             for (int j = 0; j < CONICS; ++j) {
                 fConics[j].computeQuadPOW2(SK_ScalarHalf);

diff --git a/bench/PathIterBench.cpp b/bench/PathIterBench.cpp
index b82146d..c7a04bd 100644
--- a/bench/PathIterBench.cpp
+++ b/bench/PathIterBench.cpp

@@ -56,16 +56,16 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         if (fRaw) {
             for (int i = 0; i < loops; ++i) {
                 SkPath::RawIter iter(fPath);

diff --git a/bench/PerlinNoiseBench.cpp b/bench/PerlinNoiseBench.cpp
index 560628f..17260a9 100644
--- a/bench/PerlinNoiseBench.cpp
+++ b/bench/PerlinNoiseBench.cpp

@@ -17,11 +17,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "perlinnoise";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         this->test(loops, canvas, 0, 0, SkPerlinNoiseShader::kFractalNoise_Type,
                    0.1f, 0.1f, 3, 0, false);
     }

diff --git a/bench/PictureNestingBench.cpp b/bench/PictureNestingBench.cpp
index a3193e6..b2220b7 100644
--- a/bench/PictureNestingBench.cpp
+++ b/bench/PictureNestingBench.cpp

@@ -26,7 +26,7 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
@@ -139,7 +139,7 @@
         : INHERITED("playback", maxLevel, maxPictureLevel) {
     }
 protected:
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         this->INHERITED::onPreDraw();
 
         SkIPoint canvasSize = onGetSize();

diff --git a/bench/PicturePlaybackBench.cpp b/bench/PicturePlaybackBench.cpp
index 1701d14..67945ce 100644
--- a/bench/PicturePlaybackBench.cpp
+++ b/bench/PicturePlaybackBench.cpp

@@ -72,7 +72,7 @@
 public:
     TextPlaybackBench() : INHERITED("drawText") { }
 protected:
-    virtual void recordCanvas(SkCanvas* canvas) SK_OVERRIDE {
+    void recordCanvas(SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         paint.setTextSize(fTextSize);
         paint.setColor(SK_ColorBLACK);
@@ -97,7 +97,7 @@
         : INHERITED(drawPosH ? "drawPosTextH" : "drawPosText")
         , fDrawPosH(drawPosH) { }
 protected:
-    virtual void recordCanvas(SkCanvas* canvas) SK_OVERRIDE {
+    void recordCanvas(SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         paint.setTextSize(fTextSize);
         paint.setColor(SK_ColorBLACK);
@@ -159,10 +159,10 @@
         }
     }
 
-    virtual const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
-    virtual SkIPoint onGetSize() SK_OVERRIDE { return SkIPoint::Make(1024,1024); }
+    const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+    SkIPoint onGetSize() SK_OVERRIDE { return SkIPoint::Make(1024,1024); }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkAutoTDelete<SkBBHFactory> factory;
         switch (fBBH) {
             case kNone:                                                 break;
@@ -185,7 +185,7 @@
         fPic.reset(recorder.endRecording());
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int i = 0; i < loops; i++) {
             // This inner loop guarantees we make the same choices for all bench variants.
             SkRandom rand;

diff --git a/bench/PremulAndUnpremulAlphaOpsBench.cpp b/bench/PremulAndUnpremulAlphaOpsBench.cpp
index 32f749c..4d9dbcd 100644
--- a/bench/PremulAndUnpremulAlphaOpsBench.cpp
+++ b/bench/PremulAndUnpremulAlphaOpsBench.cpp

@@ -25,11 +25,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkImageInfo info = SkImageInfo::Make(W, H, fColorType, kUnpremul_SkAlphaType);
         fBmp1.allocPixels(info);   // used in writePixels
 
@@ -43,7 +43,7 @@
         fBmp2.allocPixels(info);    // used in readPixels()
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         canvas->clear(SK_ColorBLACK);
 
         for (int loop = 0; loop < loops; ++loop) {

diff --git a/bench/RTreeBench.cpp b/bench/RTreeBench.cpp
index 93576a7..39c2aa1 100644
--- a/bench/RTreeBench.cpp
+++ b/bench/RTreeBench.cpp

@@ -26,15 +26,15 @@
         fName.printf("rtree_%s_build", name);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRandom rand;
         SkAutoTMalloc<SkRect> rects(NUM_BUILD_RECTS);
         for (int i = 0; i < NUM_BUILD_RECTS; ++i) {
@@ -60,14 +60,14 @@
         fName.printf("rtree_%s_query", name);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkRandom rand;
         SkAutoTMalloc<SkRect> rects(NUM_QUERY_RECTS);
         for (int i = 0; i < NUM_QUERY_RECTS; ++i) {
@@ -76,7 +76,7 @@
         fTree.insert(&rects, NUM_QUERY_RECTS);
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRandom rand;
         for (int i = 0; i < loops; ++i) {
             SkTDArray<unsigned> hits;

diff --git a/bench/ReadPixBench.cpp b/bench/ReadPixBench.cpp
index 7848ebc..f019401 100644
--- a/bench/ReadPixBench.cpp
+++ b/bench/ReadPixBench.cpp

@@ -20,11 +20,11 @@
     ReadPixBench() {}
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "readpix";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         canvas->clear(SK_ColorBLACK);
 
         SkISize size = canvas->getDeviceSize();

diff --git a/bench/RecordingBench.h b/bench/RecordingBench.h
index 4c03401..783596d 100644
--- a/bench/RecordingBench.h
+++ b/bench/RecordingBench.h

@@ -16,10 +16,10 @@
     RecordingBench(const char* name, const SkPicture*, bool useBBH);
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE;
-    virtual bool isSuitableFor(Backend) SK_OVERRIDE;
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE;
-    virtual SkIPoint onGetSize() SK_OVERRIDE;
+    const char* onGetName() SK_OVERRIDE;
+    bool isSuitableFor(Backend) SK_OVERRIDE;
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE;
+    SkIPoint onGetSize() SK_OVERRIDE;
 
 private:
     SkAutoTUnref<const SkPicture> fSrc;

diff --git a/bench/RectBench.cpp b/bench/RectBench.cpp
index c0201dc..6228e00 100644
--- a/bench/RectBench.cpp
+++ b/bench/RectBench.cpp

@@ -92,14 +92,14 @@
     }
 
 protected:
-    virtual void setupPaint(SkPaint* paint) SK_OVERRIDE {
+    void setupPaint(SkPaint* paint) SK_OVERRIDE {
         this->INHERITED::setupPaint(paint);
         // srcmode is most interesting when we're not opaque
         paint->setAlpha(0x80);
         paint->setXfermode(fMode);
     }
 
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         fName.set(this->INHERITED::onGetName());
         fName.prepend("srcmode_");
         return fName.c_str();

diff --git a/bench/RectanizerBench.cpp b/bench/RectanizerBench.cpp
index 286b681..a5fad06 100644
--- a/bench/RectanizerBench.cpp
+++ b/bench/RectanizerBench.cpp

@@ -64,15 +64,15 @@
     }
 
 protected:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return kNonRendering_Backend == backend;
     }
 
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkASSERT(NULL == fRectanizer.get());
 
         if (kPow2_RectanizerType == fRectanizerType) {
@@ -83,7 +83,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRandom rand;
         SkIPoint16 loc;
         SkISize size;

diff --git a/bench/RectoriBench.cpp b/bench/RectoriBench.cpp
index ab9bdd5..de725a7 100644
--- a/bench/RectoriBench.cpp
+++ b/bench/RectoriBench.cpp

@@ -20,11 +20,11 @@
 
 protected:
 
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "rectori";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRandom Random;
 
         for (int i = 0; i < loops; i++) {

diff --git a/bench/RefCntBench.cpp b/bench/RefCntBench.cpp
index d440d99..7aa5746 100644
--- a/bench/RefCntBench.cpp
+++ b/bench/RefCntBench.cpp

@@ -18,7 +18,7 @@
 public:
     AtomicInc32() : fX(0) {}
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -42,7 +42,7 @@
 public:
     AtomicInc64() : fX(0) {}
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -64,7 +64,7 @@
 
 class RefCntBench_Stack : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -100,7 +100,7 @@
 
 class RefCntBench_Heap : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -127,7 +127,7 @@
 
 class RefCntBench_New : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -155,7 +155,7 @@
 
 class WeakRefCntBench_Stack : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -186,16 +186,16 @@
 
 class WeakRefCntBench_Heap : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "ref_cnt_heap_weak";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         char memory[sizeof(PlacedWeakRefCnt)];
         for (int i = 0; i < loops; ++i) {
             PlacedWeakRefCnt* ref = new (memory) PlacedWeakRefCnt();
@@ -213,16 +213,16 @@
 
 class WeakRefCntBench_New : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "ref_cnt_new_weak";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         for (int i = 0; i < loops; ++i) {
             SkWeakRefCnt* ref = new SkWeakRefCnt();
             for (int j = 0; j < M; ++j) {

diff --git a/bench/RegionBench.cpp b/bench/RegionBench.cpp
index 91ab286..5cd6779 100644
--- a/bench/RegionBench.cpp
+++ b/bench/RegionBench.cpp

@@ -99,7 +99,7 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 

diff --git a/bench/RegionContainBench.cpp b/bench/RegionContainBench.cpp
index f6d8142..3a09809 100644
--- a/bench/RegionContainBench.cpp
+++ b/bench/RegionContainBench.cpp

@@ -45,14 +45,14 @@
         fB.setRect(0, 0, H, W);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+    const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         Proc proc = fProc;
 
         for (int i = 0; i < loops; ++i) {

diff --git a/bench/RepeatTileBench.cpp b/bench/RepeatTileBench.cpp
index cf147d8..0e63336 100644
--- a/bench/RepeatTileBench.cpp
+++ b/bench/RepeatTileBench.cpp

@@ -104,11 +104,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         fBitmap.allocPixels();
         fBitmap.eraseColor(kOpaque_SkAlphaType == fAlphaType ? SK_ColorWHITE : 0);
 
@@ -127,7 +127,7 @@
     }
 
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint(fPaint);
         this->setupPaint(&paint);
 

diff --git a/bench/RotatedRectBench.cpp b/bench/RotatedRectBench.cpp
index ea8654a..87b4ec8 100644
--- a/bench/RotatedRectBench.cpp
+++ b/bench/RotatedRectBench.cpp

@@ -75,9 +75,9 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+    const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
         paint.setAntiAlias(fAA);
         paint.setXfermodeMode(fMode);

diff --git a/bench/ScalarBench.cpp b/bench/ScalarBench.cpp
index 9260812..21f9264 100644
--- a/bench/ScalarBench.cpp
+++ b/bench/ScalarBench.cpp

@@ -18,7 +18,7 @@
         fName.printf("scalar_%s", name);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
@@ -27,11 +27,11 @@
 protected:
     virtual int mulLoopCount() const { return 1; }
 
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int i = 0; i < loops; i++) {
             this->performTest();
         }
@@ -101,8 +101,8 @@
         }
     }
 protected:
-    virtual int mulLoopCount() const SK_OVERRIDE { return 1; }
-    virtual void performTest() SK_OVERRIDE {
+    int mulLoopCount() const SK_OVERRIDE { return 1; }
+    void performTest() SK_OVERRIDE {
         int sum = 0;
         for (size_t i = 0; i < ARRAY_N; ++i) {
             // We pass -fArray[i], so the compiler can't cheat and treat the
@@ -140,16 +140,16 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "rect_bounds";
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkRect r;
         for (int i = 0; i < loops; ++i) {
             r.set(fPts, PTS);

diff --git a/bench/SkipZeroesBench.cpp b/bench/SkipZeroesBench.cpp
index 5d18264..1587e01 100644
--- a/bench/SkipZeroesBench.cpp
+++ b/bench/SkipZeroesBench.cpp

@@ -36,16 +36,16 @@
         }
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         SkString resourcePath = GetResourcePath();
         if (resourcePath.isEmpty()) {
             fValid = false;
@@ -73,7 +73,7 @@
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         if (!fValid) {
 #ifdef SK_DEBUG
             SkDebugf("stream was invalid: %s\n", fFilename.c_str());

diff --git a/bench/SortBench.cpp b/bench/SortBench.cpp
index a7e8c2c..b46b805 100644
--- a/bench/SortBench.cpp
+++ b/bench/SortBench.cpp

@@ -107,22 +107,22 @@
         fName.printf("sort_%s_%s", gSorts[s].fName, gRec[t].fName);
     }
 
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
     // Delayed initialization only done if onDraw will be called.
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         fUnsorted.reset(N);
         gRec[fType].fProc(fUnsorted.get());
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         SkAutoTMalloc<int> sorted(N);
         for (int i = 0; i < loops; i++) {
             memcpy(sorted.get(), fUnsorted.get(), N*sizeof(int));

diff --git a/bench/WritePixelsBench.cpp b/bench/WritePixelsBench.cpp
index 88b2e62..3353ba2 100644
--- a/bench/WritePixelsBench.cpp
+++ b/bench/WritePixelsBench.cpp

@@ -41,11 +41,11 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkISize size = canvas->getDeviceSize();
 
         canvas->clear(0xFFFF0000);

diff --git a/bench/WriterBench.cpp b/bench/WriterBench.cpp
index 906a9d2..4dcd3a3 100644
--- a/bench/WriterBench.cpp
+++ b/bench/WriterBench.cpp

@@ -12,16 +12,16 @@
 
 class WriterBench : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         return "writer";
     }
 
-    virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
         static const char gStr[] = "abcdefghimjklmnopqrstuvwxyz";
         static const size_t gLen = strlen(gStr);
         SkWriter32 writer;

diff --git a/bench/XfermodeBench.cpp b/bench/XfermodeBench.cpp
index 54272da..4afd06b 100644
--- a/bench/XfermodeBench.cpp
+++ b/bench/XfermodeBench.cpp

@@ -29,9 +29,9 @@
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+    const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         SkISize size = canvas->getDeviceSize();
         SkRandom random;
         for (int i = 0; i < loops; ++i) {
@@ -63,14 +63,14 @@
 
 class XferCreateBench : public Benchmark {
 public:
-    virtual bool isSuitableFor(Backend backend) SK_OVERRIDE {
+    bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE { return "xfermode_create"; }
+    const char* onGetName() SK_OVERRIDE { return "xfermode_create"; }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         for (int outer = 0; outer < loops * 10; ++outer) {
             for (int i = 0; i <= SkXfermode::kLastMode; ++i) {
                 SkXfermode* xfer = SkXfermode::Create(SkXfermode::Mode(i));