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

tools/PictureResultsWriter.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Classes for writing out bench results in various formats.
  */
 
 #ifndef SkPictureResultsWriter_DEFINED
@@ skipping 38 matching lines @@
  * passed to it, so the owner is required to manage any classes
  * passed to PictureResultsMultiWriter */
 class PictureResultsMultiWriter : public PictureResultsWriter {
 public:
     PictureResultsMultiWriter()
         : fWriters() {}
     void add(PictureResultsWriter* newWriter) {
         fWriters.push_back(newWriter);
     }
     virtual ~PictureResultsMultiWriter() {}
-    void bench(const char name[], int32_t x, int32_t y) SK_OVERRIDE {
+    void bench(const char name[], int32_t x, int32_t y) override {
         for(int i=0; i<fWriters.count(); ++i) {
             fWriters[i]->bench(name, x, y);
         }
     }
-    void logRenderer(sk_tools::PictureRenderer *pr) SK_OVERRIDE {
+    void logRenderer(sk_tools::PictureRenderer *pr) override {
         for(int i=0; i<fWriters.count(); ++i) {
             fWriters[i]->logRenderer(pr);
         }
     }
-    void tileMeta(int x, int y, int tx, int ty) SK_OVERRIDE {
+    void tileMeta(int x, int y, int tx, int ty) override {
         for(int i=0; i<fWriters.count(); ++i) {
             fWriters[i]->tileMeta(x, y, tx, ty);
         }
     }
-    void addTileFlag(PictureResultsWriter::TileFlags flag) SK_OVERRIDE {
+    void addTileFlag(PictureResultsWriter::TileFlags flag) override {
         for(int i=0; i<fWriters.count(); ++i) {
             fWriters[i]->addTileFlag(flag);
         }
     }
     virtual void tileData(
             TimerData* data,
             const char format[],
             const TimerData::Result result,
             uint32_t timerTypes,
-            int numInnerLoops = 1) SK_OVERRIDE {
+            int numInnerLoops = 1) override {
         for(int i=0; i<fWriters.count(); ++i) {
             fWriters[i]->tileData(data, format, result, timerTypes,
                                  numInnerLoops);
         }
     }
-   void end() SK_OVERRIDE {
+   void end() override {
         for(int i=0; i<fWriters.count(); ++i) {
             fWriters[i]->end();
         }
    }
 private:
     SkTArray<PictureResultsWriter*> fWriters;
 };
 
 /**
  * Writes to BenchLogger to mimic original behavior
  */
 class PictureResultsLoggerWriter : public PictureResultsWriter {
 private:
     void logProgress(const char str[]) {
         if(fLogger != NULL) {
             fLogger->logProgress(str);
         }
     }
 public:
     PictureResultsLoggerWriter(BenchLogger* log)
           : fLogger(log), fCurrentLine() {}
-    void bench(const char name[], int32_t x, int32_t y) SK_OVERRIDE {
+    void bench(const char name[], int32_t x, int32_t y) override {
         SkString result;
         result.printf("running bench [%i %i] %s ", x, y, name);
         this->logProgress(result.c_str());
     }
-    void logRenderer(sk_tools::PictureRenderer* renderer) SK_OVERRIDE {
+    void logRenderer(sk_tools::PictureRenderer* renderer) override {
         fCurrentLine = renderer->getConfigName();
     }
-    void tileMeta(int x, int y, int tx, int ty) SK_OVERRIDE {
+    void tileMeta(int x, int y, int tx, int ty) override {
         fCurrentLine.appendf(": tile [%i,%i] out of [%i,%i]", x, y, tx, ty);
     }
-    void addTileFlag(PictureResultsWriter::TileFlags flag) SK_OVERRIDE {
+    void addTileFlag(PictureResultsWriter::TileFlags flag) override {
         if(flag == PictureResultsWriter::kPurging) {
             fCurrentLine.append(" <withPurging>");
         } else if(flag == PictureResultsWriter::kAvg) {
             fCurrentLine.append(" <averaged>");
         }
     }
     virtual void tileData(
             TimerData* data,
             const char format[],
             const TimerData::Result result,
             uint32_t timerTypes,
-            int numInnerLoops = 1) SK_OVERRIDE {
+            int numInnerLoops = 1) override {
         SkString results = data->getResult(format, result,
                 fCurrentLine.c_str(), timerTypes, numInnerLoops);
         results.append("\n");
         this->logProgress(results.c_str());
     }
-    void end() SK_OVERRIDE {}
+    void end() override {}
 private:
     BenchLogger* fLogger;
     SkString fCurrentLine;
 };
 
 /**
  * This PictureResultsWriter collects data in a JSON node
  *
  * The format is something like
  * {
@@ skipping 30 matching lines @@
                              int gitNumber)
         : fStream(filename) {
         fBuilderName = SkString(builderName);
         fBuildNumber = buildNumber;
         fTimestamp = timestamp;
         fGitHash = SkString(gitHash);
         fGitNumber = gitNumber;
         fBuilderData = this->makeBuilderJson();
     }
 
-    void bench(const char name[], int32_t x, int32_t y) SK_OVERRIDE {
+    void bench(const char name[], int32_t x, int32_t y) override {
         fBenchName = SkString(name);
     }
-    void logRenderer(sk_tools::PictureRenderer* pr) SK_OVERRIDE {
+    void logRenderer(sk_tools::PictureRenderer* pr) override {
         fParams = pr->getJSONConfig();
         fConfigString = pr->getConfigName();
     }
     // Apparently tiles aren't used, so tileMeta is empty
-    void tileMeta(int x, int y, int tx, int ty) SK_OVERRIDE {}
+    void tileMeta(int x, int y, int tx, int ty) override {}
     // Flags aren't used, so addTileFlag is empty
-    void addTileFlag(PictureResultsWriter::TileFlags flag) SK_OVERRIDE {}
+    void addTileFlag(PictureResultsWriter::TileFlags flag) override {}
     virtual void tileData(
             TimerData* data,
             const char format[],
             const TimerData::Result result,
             uint32_t timerTypes,
-            int numInnerLoops = 1) SK_OVERRIDE {
+            int numInnerLoops = 1) override {
         Json::Value newData = data->getJSON(timerTypes, result, numInnerLoops);
         Json::Value combinedParams(fBuilderData);
         for(Json::ValueIterator iter = fParams.begin(); iter != fParams.end();
                 iter++) {
             combinedParams[iter.key().asString()]= *iter;
         }
         // For each set of timer data
         for(Json::ValueIterator iter = newData.begin(); iter != newData.end();
                 iter++) {
             Json::Value data;
@@ skipping 15 matching lines @@
                     vals++) {
                 times.push_back((*vals).asDouble());
             }
             qsort(static_cast<void*>(times.begin()), times.count(),
                     sizeof(double), PictureJSONResultsWriter::CompareDoubles);
             data["value"] = times[static_cast<int>(times.count() * 0.25f)];
             data["params"]["measurementType"] = iter.key().asString();
             fStream.writeText(Json::FastWriter().write(data).c_str());
         }
     }
-    void end() SK_OVERRIDE {
+    void end() override {
        fStream.flush();
     }
 private:
     Json::Value makeBuilderJson() const {
         static const int kNumKeys = 6;
         static const char* kKeys[kNumKeys] = {
             "role", "os", "model", "gpu", "arch", "configuration"};
         Json::Value builderData;
 
         if (!fBuilderName.isEmpty()) {
@@ skipping 46 matching lines @@
 
     SkString        fConfigString;
     SkString        fBuilderName;
     int             fBuildNumber;
     int             fTimestamp;
     SkString        fGitHash;
     int             fGitNumber;
 };
 
 #endif