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

bench/PatchBench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Benchmark.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
 #include "SkPaint.h"
@@ skipping 64 matching lines @@
             SK_ColorMAGENTA, SK_ColorBLUE, SK_ColorYELLOW,
         };
         const SkPoint pts[] = { { 200.f / 4.f, 0.f }, { 3.f * 200.f / 4, 200.f } };
 
         return SkGradientShader::CreateLinear(pts, colors, NULL,
                                               SK_ARRAY_COUNT(colors),
                                               SkShader::kMirror_TileMode);
     }
 
 protected:
-    virtual const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() SK_OVERRIDE {
         SkString vertexMode;
         switch (fVertexMode) {
             case kNone_VertexMode:
                 vertexMode.set("meshlines");
                 break;
             case kColors_VertexMode:
                 vertexMode.set("colors");
                 break;
             case kTexCoords_VertexMode:
                 vertexMode.set("texs");
                 break;
             case kBoth_VertexMode:
                 vertexMode.set("colors_texs");
                 break;
             default:
                 break;
         }
         SkString type;
         this->appendName(&type);
         fName.printf("patch_%s_%s_[%f,%f]", type.c_str(), vertexMode.c_str(),
                     fScale.x(), fScale.y());
         return fName.c_str();
     }
 
-    virtual void onPreDraw() SK_OVERRIDE {
+    void onPreDraw() SK_OVERRIDE {
         this->setCubics();
         this->setColors();
         this->setTexCoords();
         this->setupPaint(&fPaint);
         switch (fVertexMode) {
             case kTexCoords_VertexMode:
             case kBoth_VertexMode:
                 fPaint.setShader(this->createShader())->unref();
                 break;
             default:
                 fPaint.setShader(NULL);
                 break;
         }
     }
 
-    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) {
                 case kNone_VertexMode:
                     canvas->drawPatch(fCubics, NULL, NULL, NULL, fPaint);
                     break;
                 case kColors_VertexMode:
                     canvas->drawPatch(fCubics, fColors, NULL, NULL, fPaint);
                     break;
                 case kTexCoords_VertexMode:
@@ skipping 17 matching lines @@
     VertexMode  fVertexMode;
 
     typedef Benchmark INHERITED;
 };
 
 class SquarePatchBench : public PatchBench {
 public:
     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},
             //right points
             {300, 150},{300,250},
             //bottom points
             {300,300},{250,300},{150,300},{100,300},
             //left points
             {100,250},{100,150}
         };
         memcpy(fCubics, points, SkPatchUtils::kNumCtrlPts * sizeof(SkPoint));
     }
 private:
     typedef PatchBench INHERITED;
 };
 
 class LODDiffPatchBench : public PatchBench {
 public:
     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},
             //right points
             {300, 150},{300,250},
             //bottom points
             {300,400},{250,300},{150,300},{100,225},
             //left points
             {100,215},{100,185}
         };
         memcpy(fCubics, points, SkPatchUtils::kNumCtrlPts * sizeof(SkPoint));
     }
 private:
     typedef PatchBench INHERITED;
 };
 
 class LoopPatchBench : public PatchBench {
 public:
     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},
             //right points
             {380, 400},{380,0},
             //bottom points
             {300,300},{250,250},{30,200},{100,300},
             //left points
             {140,325},{150,150}
         };
@@ skipping 85 matching lines @@
 DEF_BENCH( return new LoopPatchBench(SkVector::Make(1.0f, 1.0f),
                                         PatchBench::kBoth_VertexMode); )
 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f),
                                         PatchBench::kNone_VertexMode); )
 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f),
                                         PatchBench::kColors_VertexMode); )
 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f),
                                         PatchBench::kTexCoords_VertexMode); )
 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f),
                                         PatchBench::kBoth_VertexMode); )