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

src/gpu/gl/GrGLNameAllocator.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 "GrGLNameAllocator.h"
 
@@ skipping 115 matching lines @@
 class GrGLNameAllocator::SparseNameTree : public SparseNameRange {
 public:
     SparseNameTree(SparseNameRange* left, SparseNameRange* right)
         : fLeft(left),
           fRight(right) {
         SkASSERT(fLeft.get());
         SkASSERT(fRight.get());
         this->updateStats();
     }
 
-    virtual SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) SK_OVERRIDE {
+    SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) SK_OVERRIDE {
         // Try allocating the range inside fLeft's internal gaps.
         fLeft.reset(fLeft->internalAllocate(outName));
         if (0 != *outName) {
             this->updateStats();
             return this->rebalance();
         }
 
         if (fLeft->end() + 1 == fRight->first()) {
             // It closed the gap between fLeft and fRight; merge.
             GrGLuint removedCount;
             fRight.reset(fRight->removeLeftmostContiguousRange(&removedCount));
             *outName = fLeft->appendNames(1 + removedCount);
             if (NULL == fRight.get()) {
                 return fLeft.detach();
             }
             this->updateStats();
             return this->rebalance();
         }
 
         // There is guaranteed to be a gap between fLeft and fRight, and the
         // "size 1" case has already been covered.
         SkASSERT(fLeft->end() + 1 < fRight->first());
         *outName = fLeft->appendNames(1);
         return this->takeRef();
     }
 
-    virtual SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) SK_OVERRIDE {
+    SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) SK_OVERRIDE {
         fLeft.reset(fLeft->removeLeftmostContiguousRange(removedCount));
         if (NULL == fLeft) {
             return fRight.detach();
         }
         this->updateStats();
         return this->rebalance();
     }
 
-    virtual GrGLuint appendNames(GrGLuint count) SK_OVERRIDE {
+    GrGLuint appendNames(GrGLuint count) SK_OVERRIDE {
         SkASSERT(fEnd + count > fEnd); // Check for integer wrap.
         GrGLuint name = fRight->appendNames(count);
         SkASSERT(fRight->end() == fEnd + count);
         this->updateStats();
         return name;
     }
 
-    virtual GrGLuint prependNames(GrGLuint count) SK_OVERRIDE {
+    GrGLuint prependNames(GrGLuint count) SK_OVERRIDE {
         SkASSERT(fFirst > count); // We can't allocate at or below 0.
         GrGLuint name = fLeft->prependNames(count);
         SkASSERT(fLeft->first() == fFirst - count);
         this->updateStats();
         return name;
     }
 
-    virtual SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) SK_OVERRIDE {
+    SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) SK_OVERRIDE {
         if (name < fLeft->end()) {
             fLeft.reset(fLeft->free(name));
             if (NULL == fLeft) {
                 // fLeft became empty after the free.
                 return fRight.detach();
             }
             this->updateStats();
             return this->rebalance();
         } else {
             fRight.reset(fRight->free(name));
@@ skipping 74 matching lines @@
  */
 class GrGLNameAllocator::ContiguousNameRange : public SparseNameRange {
 public:
     ContiguousNameRange(GrGLuint first, GrGLuint end) {
         SkASSERT(first < end);
         fFirst = first;
         fEnd = end;
         fHeight = 0;
     }
 
-    virtual SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) SK_OVERRIDE {
+    SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) SK_OVERRIDE {
         *outName = 0; // No internal gaps, we are contiguous.
         return this->takeRef();
     }
 
-    virtual SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) SK_OVERRIDE {
+    SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) SK_OVERRIDE {
         *removedCount = fEnd - fFirst;
         return NULL;
     }
 
-    virtual GrGLuint appendNames(GrGLuint count) SK_OVERRIDE {
+    GrGLuint appendNames(GrGLuint count) SK_OVERRIDE {
         SkASSERT(fEnd + count > fEnd); // Check for integer wrap.
         GrGLuint name = fEnd;
         fEnd += count;
         return name;
     }
 
-    virtual GrGLuint prependNames(GrGLuint count) SK_OVERRIDE {
+    GrGLuint prependNames(GrGLuint count) SK_OVERRIDE {
         SkASSERT(fFirst > count); // We can't allocate at or below 0.
         fFirst -= count;
         return fFirst;
     }
 
-    virtual SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) SK_OVERRIDE {
+    SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) SK_OVERRIDE {
         if (name < fFirst || name >= fEnd) {
           // Not-allocated names are silently ignored.
           return this->takeRef();
         }
 
         if (fFirst == name) {
             ++fFirst;
             return (fEnd == fFirst) ? NULL : this->takeRef();
         }
 
@@ skipping 44 matching lines @@
 }
 
 void GrGLNameAllocator::free(GrGLuint name) {
     if (!fAllocatedNames.get()) {
       // Not-allocated names are silently ignored.
       return;
     }
 
     fAllocatedNames.reset(fAllocatedNames->free(name));
 }