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

gm/blurrect.cpp

 /*
 * Copyright 2012 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "gm.h"
 #include "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
@@ skipping 75 matching lines @@
       SkAutoTUnref<SkMaskFilter> fMaskFilters[kLastEnum_SkBlurStyle + 1];
       SkString  fName;
       SkAlpha   fAlpha;
 public:
     BlurRectGM(const char name[], U8CPU alpha)
         : fName(name)
         , fAlpha(SkToU8(alpha)) {
     }
 
 protected:
-    virtual void onOnceBeforeDraw() SK_OVERRIDE {
+    void onOnceBeforeDraw() SK_OVERRIDE {
         for (int i = 0; i <= kLastEnum_SkBlurStyle; ++i) {
             fMaskFilters[i].reset(SkBlurMaskFilter::Create((SkBlurStyle)i,
                                   SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(STROKE_WIDTH/2)),
                                   SkBlurMaskFilter::kHighQuality_BlurFlag));
         }
     }
 
-    virtual SkString onShortName() SK_OVERRIDE {
+    SkString onShortName() SK_OVERRIDE {
         return fName;
     }
 
-    virtual SkISize onISize() SK_OVERRIDE {
+    SkISize onISize() SK_OVERRIDE {
         return SkISize::Make(860, 820);
     }
 
-    virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         canvas->translate(STROKE_WIDTH*3/2, STROKE_WIDTH*3/2);
 
         SkRect  r = { 0, 0, 100, 50 };
         SkScalar scales[] = { SK_Scalar1, 0.6f };
 
         for (size_t s = 0; s < SK_ARRAY_COUNT(scales); ++s) {
             canvas->save();
             for (size_t f = 0; f < SK_ARRAY_COUNT(fMaskFilters); ++f) {
                 SkPaint paint;
                 paint.setMaskFilter(fMaskFilters[f]);
@@ skipping 17 matching lines @@
                 this->drawProcs(canvas, r, paintWithRadial, true, procs, SK_ARRAY_COUNT(procs));
                 canvas->restore();
 
                 canvas->translate(0, SK_ARRAY_COUNT(procs) * r.height() * 4/3 * scales[s]);
             }
             canvas->restore();
             canvas->translate(4 * r.width() * 4/3 * scales[s], 0);
         }
     }
 
-    virtual uint32_t onGetFlags() const SK_OVERRIDE { return kSkipPipe_Flag | kSkipTiled_Flag; }
+    uint32_t onGetFlags() const SK_OVERRIDE { return kSkipPipe_Flag | kSkipTiled_Flag; }
 
 private:
     void drawProcs(SkCanvas* canvas, const SkRect& r, const SkPaint& paint,
                    bool doClip, const Proc procs[], size_t procsCount) {
         SkAutoCanvasRestore acr(canvas, true);
         for (size_t i = 0; i < procsCount; ++i) {
             if (doClip) {
                 SkRect clipRect(r);
                 clipRect.inset(STROKE_WIDTH/2, STROKE_WIDTH/2);
                 canvas->save();
@@ skipping 167 matching lines @@
 
 class BlurRectFastGM: public BlurRectCompareGM {
 public:
     BlurRectFastGM(const char name[], unsigned int rectWidth,
                    unsigned int rectHeight, float blurRadius,
                    SkBlurStyle style) :
         INHERITED(name, rectWidth, rectHeight, blurRadius, style) {
         }
 
 protected:
-    virtual bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
+    bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
         return SkBlurMask::BlurRect(SkBlurMask::ConvertRadiusToSigma(this->radius()),
                                     m, r, this->style());
     }
 private:
     typedef BlurRectCompareGM INHERITED;
 };
 
 class BlurRectSlowGM: public BlurRectCompareGM {
 public:
     BlurRectSlowGM(const char name[], unsigned int rectWidth, unsigned int rectHeight,
                    float blurRadius, SkBlurStyle style)
         : INHERITED(name, rectWidth, rectHeight, blurRadius, style) {
         }
 
 protected:
-    virtual bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
+    bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
         SkMask src;
         r.roundOut(&src.fBounds);
         src.fBounds.offset(-src.fBounds.fLeft, -src.fBounds.fTop);  // move to origin
         src.fFormat = SkMask::kA8_Format;
         src.fRowBytes = src.fBounds.width();
         src.fImage = SkMask::AllocImage(src.computeTotalImageSize());
         SkAutoMaskFreeImage amfi(src.fImage);
 
         memset(src.fImage, 0xff, src.computeTotalImageSize());
 
@@ skipping 10 matching lines @@
 };
 
 class BlurRectSlowLowGM: public BlurRectSlowGM {
 public:
     BlurRectSlowLowGM(const char name[], unsigned int rectWidth, unsigned int rectHeight,
                       float blurRadius, SkBlurStyle style)
         : INHERITED(name, rectWidth, rectHeight, blurRadius, style) {
         }
 
 protected:
-    virtual SkBlurQuality getQuality() SK_OVERRIDE {
+    SkBlurQuality getQuality() SK_OVERRIDE {
         return kLow_SkBlurQuality;
     }
 private:
     typedef BlurRectSlowGM INHERITED;
 };
 
 class BlurRectGroundTruthGM: public BlurRectCompareGM {
 public:
     BlurRectGroundTruthGM(const char name[], unsigned int rectWidth, unsigned int rectHeight,
                           float blurRadius, SkBlurStyle style)
         : INHERITED(name, rectWidth, rectHeight, blurRadius, style) {
         }
 
 protected:
-    virtual bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
+    bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
         SkMask src;
         r.roundOut(&src.fBounds);
         src.fBounds.offset(-src.fBounds.fLeft, -src.fBounds.fTop);  // move to origin
         src.fFormat = SkMask::kA8_Format;
         src.fRowBytes = src.fBounds.width();
         src.fImage = SkMask::AllocImage(src.computeTotalImageSize());
         SkAutoMaskFreeImage amfi(src.fImage);
 
         memset(src.fImage, 0xff, src.computeTotalImageSize());
 
         return SkBlurMask::BlurGroundTruth(SkBlurMask::ConvertRadiusToSigma(this->radius()),
                                            m, src, this->style());
     }
 
     virtual SkBlurQuality getQuality() {
         return kHigh_SkBlurQuality;
     }
 private:
     typedef BlurRectCompareGM INHERITED;
 };
 
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new BlurRectGM("blurrects", 0xFF);)
 DEF_GM(return new BlurRectDirectGM("blurrect_gallery");)