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

src/gpu/GrAADistanceFieldPathRenderer.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 "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 125 matching lines @@
         bool fAntiAlias;
         PathData* fPathData;
     };
 
     static GrBatch* Create(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
                            GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
         return SkNEW_ARGS(AADistanceFieldPathBatch, (geometry, color, viewMatrix,
                                                      atlas, pathCache, pathList));
     }
 
-    const char* name() const SK_OVERRIDE { return "AADistanceFieldPathBatch"; }
+    const char* name() const override { return "AADistanceFieldPathBatch"; }
 
-    void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+    void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         out->setKnownFourComponents(fBatch.fColor);
     }
 
-    void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+    void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         out->setUnknownSingleComponent();
     }
 
-    void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+    void initBatchTracker(const GrPipelineInfo& init) override {
         // Handle any color overrides
         if (init.fColorIgnored) {
             fBatch.fColor = GrColor_ILLEGAL;
         } else if (GrColor_ILLEGAL != init.fOverrideColor) {
             fBatch.fColor = init.fOverrideColor;
         }
 
         // setup batch properties
         fBatch.fColorIgnored = init.fColorIgnored;
         fBatch.fUsesLocalCoords = init.fUsesLocalCoords;
         fBatch.fCoverageIgnored = init.fCoverageIgnored;
     }
 
-    void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+    void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         int instanceCount = fGeoData.count();
 
         SkMatrix invert;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
             SkDebugf("Could not invert viewmatrix\n");
             return;
         }
 
         uint32_t flags = 0;
         flags |= this->viewMatrix().isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
@@ skipping 349 matching lines @@
 
             drawInfo->setStartVertex(drawInfo->startVertex() + drawInfo->vertexCount());
             instanceCount -= drawInfo->instanceCount();
        }
     }
 
     GrColor color() const { return fBatch.fColor; }
     const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
 
-    bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+    bool onCombineIfPossible(GrBatch* t) override {
         AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
 
         // TODO we could actually probably do a bunch of this work on the CPU, ie map viewMatrix,
         // maybe upload color via attribute
         if (this->color() != that->color()) {
             return false;
         }
 
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
@@ skipping 60 matching lines @@
     SkAutoTUnref<GrBatch> batch(AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                                                  fAtlas, &fPathCache, &fPathList));
 
     SkRect bounds = path.getBounds();
     viewMatrix.mapRect(&bounds);
     target->drawBatch(pipelineBuilder, batch, &bounds);
 
     return true;
 }