use override to make the new xcode happier

bench/RectBench.cpp

 
 /*
  * Copyright 2011 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 "SkCommandLineFlags.h"
@@ skipping 28 matching lines @@
         return fName.c_str();
     }
 
     bool isVisual() override { return true; }
 
 protected:
     virtual void drawThisRect(SkCanvas* c, const SkRect& r, const SkPaint& p) {
         c->drawRect(r, p);
     }
 
-    virtual const char* onGetName() { return computeName("rects"); }
+    const char* onGetName() override { return computeName("rects"); }
 
-    virtual void onPreDraw() {
+    void onPreDraw() override {
         SkRandom rand;
         const SkScalar offset = SK_Scalar1/3;
         for (int i = 0; i < N; i++) {
             int x = rand.nextU() % W;
             int y = rand.nextU() % H;
             int w = rand.nextU() % W;
             int h = rand.nextU() % H;
             w >>= fShift;
             h >>= fShift;
             x -= w/2;
             y -= h/2;
             fRects[i].set(SkIntToScalar(x), SkIntToScalar(y),
                           SkIntToScalar(x+w), SkIntToScalar(y+h));
             fRects[i].offset(offset, offset);
             fColors[i] = rand.nextU() | 0xFF808080;
         }
     }
 
-    virtual void onDraw(const int loops, SkCanvas* canvas) {
+    void onDraw(const int loops, SkCanvas* canvas) override {
         SkPaint paint;
         if (fStroke > 0) {
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setStrokeWidth(SkIntToScalar(fStroke));
         }
         for (int i = 0; i < loops; i++) {
             paint.setColor(fColors[i % N]);
             this->setupPaint(&paint);
             this->drawThisRect(canvas, fRects[i % N], paint);
         }
@@ skipping 54 matching lines @@
     SkString fName;
 
     typedef RectBench INHERITED;
 };
 
 
 class OvalBench : public RectBench {
 public:
     OvalBench(int shift, int stroke = 0) : RectBench(shift, stroke) {}
 protected:
-    virtual void drawThisRect(SkCanvas* c, const SkRect& r, const SkPaint& p) {
+    void drawThisRect(SkCanvas* c, const SkRect& r, const SkPaint& p) override {
         c->drawOval(r, p);
     }
-    virtual const char* onGetName() { return computeName("ovals"); }
+    const char* onGetName() override { return computeName("ovals"); }
 };
 
 class RRectBench : public RectBench {
 public:
     RRectBench(int shift, int stroke = 0) : RectBench(shift, stroke) {}
 protected:
-    virtual void drawThisRect(SkCanvas* c, const SkRect& r, const SkPaint& p) {
+    void drawThisRect(SkCanvas* c, const SkRect& r, const SkPaint& p) override {
         c->drawRoundRect(r, r.width() / 4, r.height() / 4, p);
     }
-    virtual const char* onGetName() { return computeName("rrects"); }
+    const char* onGetName() override { return computeName("rrects"); }
 };
 
 class PointsBench : public RectBench {
 public:
     SkCanvas::PointMode fMode;
     const char* fName;
 
     PointsBench(SkCanvas::PointMode mode, const char* name)
         : RectBench(2)
         , fMode(mode) {
         fName = name;
     }
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas* canvas) {
+    void onDraw(const int loops, SkCanvas* canvas) override {
         SkScalar gSizes[] = {
             SkIntToScalar(7), 0
         };
         size_t sizes = SK_ARRAY_COUNT(gSizes);
 
         if (FLAGS_strokeWidth >= 0) {
             gSizes[0] = (SkScalar)FLAGS_strokeWidth;
             sizes = 1;
         }
 
         SkPaint paint;
         paint.setStrokeCap(SkPaint::kRound_Cap);
 
         for (int loop = 0; loop < loops; loop++) {
             for (size_t i = 0; i < sizes; i++) {
                 paint.setStrokeWidth(gSizes[i]);
                 this->setupPaint(&paint);
                 canvas->drawPoints(fMode, N * 2, SkTCast<SkPoint*>(fRects), paint);
                 paint.setColor(fColors[i % N]);
             }
         }
     }
-    virtual const char* onGetName() { return fName; }
+    const char* onGetName() override { return fName; }
 };
 
 /*******************************************************************************
  * to bench BlitMask [Opaque, Black, color, shader]
  *******************************************************************************/
 
 class BlitMaskBench : public RectBench {
 public:
     enum kMaskType {
         kMaskOpaque = 0,
         kMaskBlack,
         kMaskColor,
         KMaskShader
     };
     SkCanvas::PointMode fMode;
     const char* fName;
 
     BlitMaskBench(SkCanvas::PointMode mode,
                   BlitMaskBench::kMaskType type, const char* name) :
         RectBench(2), fMode(mode), _type(type) {
         fName = name;
     }
 
 protected:
-    virtual void onDraw(const int loops, SkCanvas* canvas) {
+    void onDraw(const int loops, SkCanvas* canvas) override {
         SkScalar gSizes[] = {
             SkIntToScalar(13), SkIntToScalar(24)
         };
         size_t sizes = SK_ARRAY_COUNT(gSizes);
 
         if (FLAGS_strokeWidth >= 0) {
             gSizes[0] = (SkScalar)FLAGS_strokeWidth;
             sizes = 1;
         }
         SkRandom rand;
@@ skipping 30 matching lines @@
                         break;
                 }
                 paint.setStrokeWidth(gSizes[i]);
                 this->setupPaint(&paint);
                 paint.setColor(color);
                 paint.setAlpha(alpha);
                 canvas->drawPoints(fMode, N * 2, SkTCast<SkPoint*>(fRects), paint);
            }
         }
     }
-    virtual const char* onGetName() { return fName; }
+    const char* onGetName() override { return fName; }
 private:
     typedef RectBench INHERITED;
     kMaskType _type;
 };
 
 DEF_BENCH(return new RectBench(1);)
 DEF_BENCH(return new RectBench(1, 4);)
 DEF_BENCH(return new RectBench(3);)
 DEF_BENCH(return new RectBench(3, 4);)
 DEF_BENCH(return new OvalBench(1);)
@@ skipping 19 matching lines @@
                                    "maskopaque");)
 DEF_BENCH(return new BlitMaskBench(SkCanvas::kPoints_PointMode,
                                    BlitMaskBench::kMaskBlack,
                                    "maskblack");)
 DEF_BENCH(return new BlitMaskBench(SkCanvas::kPoints_PointMode,
                                    BlitMaskBench::kMaskColor,
                                    "maskcolor");)
 DEF_BENCH(return new BlitMaskBench(SkCanvas::kPoints_PointMode,
                                    BlitMaskBench::KMaskShader,
                                    "maskshader");)