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

gm/polygons.cpp

 /*
  * Copyright 2013 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 "SkCanvas.h"
 #include "SkPath.h"
 #include "SkRandom.h"
 #include "SkScalar.h"
 #include "SkTArray.h"
 
 namespace skiagm {
 
 // This GM tests a grab-bag of convex and concave polygons. They are triangles,
 // trapezoid, diamond, polygons with lots of edges, several concave polygons...
 // But rectangles are excluded.
 class PolygonsGM: public GM {
 public:
     PolygonsGM() {}
 
 protected:
-    virtual uint32_t onGetFlags() const SK_OVERRIDE {
+    uint32_t onGetFlags() const SK_OVERRIDE {
         return kSkipTiled_Flag;
     }
 
-    virtual SkString onShortName() SK_OVERRIDE {
+    SkString onShortName() SK_OVERRIDE {
         return SkString("polygons");
     }
 
-    virtual SkISize onISize() SK_OVERRIDE {
+    SkISize onISize() SK_OVERRIDE {
         int width = kNumPolygons * kCellSize + 40;
         int height = (kNumJoins * kNumStrokeWidths + kNumExtraStyles) * kCellSize + 40;
         return SkISize::Make(width, height);
     }
 
     // Construct all polygons
-    virtual void onOnceBeforeDraw() SK_OVERRIDE {
+    void onOnceBeforeDraw() SK_OVERRIDE {
         SkPoint p0[] = {{0, 0}, {60, 0}, {90, 40}};  // triangle
         SkPoint p1[] = {{0, 0}, {0, 40}, {60, 40}, {40, 0}};  // trapezoid
         SkPoint p2[] = {{0, 0}, {40, 40}, {80, 40}, {40, 0}};  // diamond
         SkPoint p3[] = {{10, 0}, {50, 0}, {60, 10}, {60, 30}, {50, 40},
                         {10, 40}, {0, 30}, {0, 10}};  // octagon
         SkPoint p4[32];  // circle-like polygons with 32-edges.
         SkPoint p5[] = {{0, 0}, {20, 20}, {0, 40}, {60, 20}};  // concave polygon with 4 edges
         SkPoint p6[] = {{0, 40}, {0, 30}, {15, 30}, {15, 20}, {30, 20},
                         {30, 10}, {45, 10}, {45, 0}, {60, 0}, {60, 40}};  // stairs-like polygon
         SkPoint p7[] = {{0, 20}, {20, 20}, {30, 0}, {40, 20}, {60, 20},
@@ skipping 39 matching lines @@
 
     static void SetColorAndAlpha(SkPaint* paint, SkRandom* rand) {
         SkColor color = rand->nextU();
         color |= 0xff000000;
         paint->setColor(color);
         if (40 == paint->getStrokeWidth()) {
             paint->setAlpha(0xA0);
         }
     }
 
-    virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         // Stroke widths are:
         // 0(may use hairline rendering), 10(common case for stroke-style)
         // 40(>= geometry width/height, make the contour filled in fact)
         static const int kStrokeWidths[] = {0, 10, 40};
         SkASSERT(kNumStrokeWidths == SK_ARRAY_COUNT(kStrokeWidths));
 
         static const SkPaint::Join kJoins[] = {
             SkPaint::kMiter_Join, SkPaint::kRound_Join, SkPaint::kBevel_Join
         };
         SkASSERT(kNumJoins == SK_ARRAY_COUNT(kJoins));
@@ skipping 52 matching lines @@
 
     SkTArray<SkPath> fPolygons;
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new PolygonsGM;)
 
 }