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

src/gpu/GrInOrderDrawBuffer.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 "GrInOrderDrawBuffer.h"
 
 #include "GrDefaultGeoProcFactory.h"
@@ skipping 52 matching lines @@
         bool fHasLocalRect;
         bool fHasLocalMatrix;
         SkRect fLocalRect;
         SkMatrix fLocalMatrix;
     };
 
     static GrBatch* Create(const Geometry& geometry) {
         return SkNEW_ARGS(RectBatch, (geometry));
     }
 
-    const char* name() const SK_OVERRIDE { return "RectBatch"; }
+    const char* name() const override { return "RectBatch"; }
 
-    void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+    void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
         out->setKnownFourComponents(fGeoData[0].fColor);
     }
 
-    void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+    void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         out->setKnownSingleComponent(0xff);
     }
 
-    void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+    void initBatchTracker(const GrPipelineInfo& init) override {
         // Handle any color overrides
         if (init.fColorIgnored) {
             fGeoData[0].fColor = GrColor_ILLEGAL;
         } else if (GrColor_ILLEGAL != init.fOverrideColor) {
             fGeoData[0].fColor = init.fOverrideColor;
         }
 
         // setup batch properties
         fBatch.fColorIgnored = init.fColorIgnored;
         fBatch.fColor = fGeoData[0].fColor;
         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 {
         // Go to device coords to allow batching across matrix changes
         SkMatrix invert = SkMatrix::I();
 
         // if we have a local rect, then we apply the localMatrix directly to the localRect to
         // generate vertex local coords
         bool hasExplicitLocalCoords = this->hasLocalRect();
         if (!hasExplicitLocalCoords) {
             if (!this->viewMatrix().isIdentity() && !this->viewMatrix().invert(&invert)) {
                 SkDebugf("Could not invert\n");
                 return;
@@ skipping 105 matching lines @@
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     const SkMatrix& localMatrix() const { return fGeoData[0].fLocalMatrix; }
     bool hasLocalRect() const { return fGeoData[0].fHasLocalRect; }
     bool hasLocalMatrix() const { return fGeoData[0].fHasLocalMatrix; }
 
-    bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+    bool onCombineIfPossible(GrBatch* t) override {
         RectBatch* that = t->cast<RectBatch>();
 
         if (this->hasLocalRect() != that->hasLocalRect()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (!this->hasLocalRect() && this->usesLocalCoords()) {
             if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
                 return false;
@@ skipping 172 matching lines @@
     }
 }
 
 void GrInOrderDrawBuffer::willReserveVertexAndIndexSpace(int vertexCount,
                                                          size_t vertexStride,
                                                          int indexCount) {
     fCommands.closeBatch();
 
     this->INHERITED::willReserveVertexAndIndexSpace(vertexCount, vertexStride, indexCount);
 }