C++11 override should now be supported by all of {bots,Chrome,Android,Mozilla}

bench/HairlinePathBench.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 "Benchmark.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
@@ skipping 24 matching lines @@
 public:
     HairlinePathBench(Flags flags) : fFlags(flags) {
         fPaint.setStyle(SkPaint::kStroke_Style);
         fPaint.setStrokeWidth(SkIntToScalar(0));
     }
 
     virtual void appendName(SkString*) = 0;
     virtual void makePath(SkPath*) = 0;
 
 protected:
-    const char* onGetName() SK_OVERRIDE {
+    const char* onGetName() override {
         fName.printf("path_hairline_%s_%s_",
                      fFlags & kBig_Flag ? "big" : "small",
                      fFlags & kAA_Flag ? "AA" : "noAA");
         this->appendName(&fName);
         return fName.c_str();
     }
 
-    void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+    void onDraw(const int loops, SkCanvas* canvas) override {
         SkPaint paint(fPaint);
         this->setupPaint(&paint);
 
         paint.setAntiAlias(fFlags & kAA_Flag ? true : false);
 
         SkPath path;
         this->makePath(&path);
         if (fFlags & kBig_Flag) {
             SkMatrix m;
             m.setScale(SkIntToScalar(3), SkIntToScalar(3));
             path.transform(m);
         }
 
         for (int i = 0; i < loops; i++) {
             canvas->drawPath(path, paint);
         }
     }
 
 private:
     SkPaint     fPaint;
     SkString    fName;
     Flags       fFlags;
     typedef Benchmark INHERITED;
 };
 
 class LinePathBench : public HairlinePathBench {
 public:
     LinePathBench(Flags flags) : INHERITED(flags) {}
 
-    void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) override {
         name->append("line");
     }
-    void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) override {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
             int yTrans = 0;
             if (i > kMaxPathSize/2 - 1) {
                 yTrans = 40;
             }
             int base1 = 2 * rand.nextULessThan(hSize);
             int base2 = 2 * rand.nextULessThan(hSize);
             int base3 = 2 * rand.nextULessThan(hSize);
             path->moveTo(SkIntToScalar(points[base1] + xTrans),
                          SkIntToScalar(points[base1+1] + yTrans));
             path->lineTo(SkIntToScalar(points[base2] + xTrans),
                          SkIntToScalar(points[base2+1] + yTrans));
             path->lineTo(SkIntToScalar(points[base3] + xTrans),
                          SkIntToScalar(points[base3+1] + yTrans));
         }
     }
 private:
     typedef HairlinePathBench INHERITED;
 };
 
 class QuadPathBench : public HairlinePathBench {
 public:
     QuadPathBench(Flags flags) : INHERITED(flags) {}
 
-    void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) override {
         name->append("quad");
     }
-    void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) override {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
             int yTrans = 0;
             if (i > kMaxPathSize/2 - 1) {
                 yTrans = 40;
             }
             int base1 = 2 * rand.nextULessThan(hSize);
             int base2 = 2 * rand.nextULessThan(hSize);
             int base3 = 2 * rand.nextULessThan(hSize);
             path->moveTo(SkIntToScalar(points[base1] + xTrans),
                          SkIntToScalar(points[base1+1] + yTrans));
             path->quadTo(SkIntToScalar(points[base2] + xTrans),
                          SkIntToScalar(points[base2+1] + yTrans),
                          SkIntToScalar(points[base3] + xTrans),
                          SkIntToScalar(points[base3+1] + yTrans));
         }
     }
 private:
     typedef HairlinePathBench INHERITED;
 };
 
 class ConicPathBench : public HairlinePathBench {
 public:
     ConicPathBench(Flags flags) : INHERITED(flags) {}
 
-    void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) override {
         name->append("conic");
     }
-    void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) override {
         SkRandom rand;
         SkRandom randWeight;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
             int yTrans = 0;
             if (i > kMaxPathSize/2 - 1) {
                 yTrans = 40;
             }
@@ skipping 12 matching lines @@
     }
 
 private:
     typedef HairlinePathBench INHERITED;
 };
 
 class CubicPathBench : public HairlinePathBench {
 public:
     CubicPathBench(Flags flags) : INHERITED(flags) {}
 
-    void appendName(SkString* name) SK_OVERRIDE {
+    void appendName(SkString* name) override {
         name->append("cubic");
     }
-    void makePath(SkPath* path) SK_OVERRIDE {
+    void makePath(SkPath* path) override {
         SkRandom rand;
         int size = SK_ARRAY_COUNT(points);
         int hSize = size / 2;
         for (int i = 0; i < kMaxPathSize; ++i) {
             int xTrans = 10 + 40 * (i%(kMaxPathSize/2));
             int yTrans = 0;
             if (i > kMaxPathSize/2 - 1) {
                 yTrans = 40;
             }
             int base1 = 2 * rand.nextULessThan(hSize);
@@ skipping 32 matching lines @@
 // Don't have default path renderer for conics yet on GPU, so must use AA
 // DEF_BENCH( return new ConicPathBench(FLAGS00); )
 // DEF_BENCH( return new ConicPathBench(FLAGS01); )
 DEF_BENCH( return new ConicPathBench(FLAGS10); )
 DEF_BENCH( return new ConicPathBench(FLAGS11); )
 
 DEF_BENCH( return new CubicPathBench(FLAGS00); )
 DEF_BENCH( return new CubicPathBench(FLAGS01); )
 DEF_BENCH( return new CubicPathBench(FLAGS10); )
 DEF_BENCH( return new CubicPathBench(FLAGS11); )