Fix up all the easy virtual ... SK_OVERRIDE cases.

src/gpu/GrAAConvexPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexPathRenderer.h"
 
@@ skipping 506 matching lines @@
 
 class QuadEdgeEffect : public GrGeometryProcessor {
 public:
 
     static GrGeometryProcessor* Create(GrColor color, const SkMatrix& localMatrix) {
         return SkNEW_ARGS(QuadEdgeEffect, (color, localMatrix));
     }
 
     virtual ~QuadEdgeEffect() {}
 
-    virtual const char* name() const SK_OVERRIDE { return "QuadEdge"; }
+    const char* name() const SK_OVERRIDE { return "QuadEdge"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inQuadEdge() const { return fInQuadEdge; }
 
     class GLProcessor : public GrGLGeometryProcessor {
     public:
         GLProcessor(const GrGeometryProcessor&,
                     const GrBatchTracker&)
             : fColor(GrColor_ILLEGAL) {}
 
-        virtual void emitCode(const EmitArgs& args) SK_OVERRIDE {
+        void emitCode(const EmitArgs& args) SK_OVERRIDE {
             const QuadEdgeEffect& qe = args.fGP.cast<QuadEdgeEffect>();
             GrGLGPBuilder* pb = args.fPB;
             GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder();
 
             GrGLVertToFrag v(kVec4f_GrSLType);
             args.fPB->addVarying("QuadEdge", &v);
             vsBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.inQuadEdge()->fName);
 
             const BatchTracker& local = args.fBT.cast<BatchTracker>();
 
@@ skipping 66 matching lines @@
 
         typedef GrGLGeometryProcessor INHERITED;
     };
 
     virtual void getGLProcessorKey(const GrBatchTracker& bt,
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLProcessor::GenKey(*this, bt, caps, b);
     }
 
-    virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
+    GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }
 
     void initBatchTracker(GrBatchTracker* bt, const InitBT& init) const SK_OVERRIDE {
         BatchTracker* local = bt->cast<BatchTracker>();
         local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
         local->fUsesLocalCoords = init.fUsesLocalCoords;
     }
 
     bool onCanMakeEqual(const GrBatchTracker& m,
                         const GrGeometryProcessor& that,
                         const GrBatchTracker& t) const SK_OVERRIDE {
         const BatchTracker& mine = m.cast<BatchTracker>();
         const BatchTracker& theirs = t.cast<BatchTracker>();
         return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                        that, theirs.fUsesLocalCoords) &&
                CanCombineOutput(mine.fInputColorType, mine.fColor,
                                 theirs.fInputColorType, theirs.fColor);
     }
 
 private:
     QuadEdgeEffect(GrColor color, const SkMatrix& localMatrix)
         : INHERITED(color, SkMatrix::I(), localMatrix) {
         this->initClassID<QuadEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInQuadEdge = &this->addVertexAttrib(GrAttribute("inQuadEdge", kVec4f_GrVertexAttribType));
     }
 
-    virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
+    bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         return true;
     }
 
-    virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+    void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
         out->setUnknownSingleComponent();
     }
 
     struct BatchTracker {
         GrGPInput fInputColorType;
         GrColor fColor;
         bool fUsesLocalCoords;
     };
 
     const GrAttribute* fInPosition;
@@ skipping 113 matching lines @@
                             vOffset,  // start vertex
                             0,        // start index
                             draw.fVertexCnt,
                             draw.fIndexCnt,
                             &devBounds);
         vOffset += draw.fVertexCnt;
     }
 
     return true;
 }