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

This fixes every case where virtual and SK_OVERRIDE were on the same line,
which should be the bulk of cases.  We'll have to manually clean up the rest
over time unless I level up in regexes.

for f in (find . -type f); perl -p -i -e 's/virtual (.*)SK_OVERRIDE/\1SK_OVERRIDE/g' $f; end

BUG=skia:

Review URL: https://codereview.chromium.org/806653007

27 files changed, 69 insertions, 69 deletions

diff --git a/tests/BitmapHeapTest.cpp b/tests/BitmapHeapTest.cpp
index c7d097278b..21ce2f39e8 100644
--- a/tests/BitmapHeapTest.cpp
+++ b/tests/BitmapHeapTest.cpp
@@ -18,11 +18,11 @@
 struct SimpleFlatController : public SkFlatController {
     SimpleFlatController() : SkFlatController() {}
     ~SimpleFlatController() { fAllocations.freeAll(); }
-    virtual void* allocThrow(size_t bytes) SK_OVERRIDE {
+    void* allocThrow(size_t bytes) SK_OVERRIDE {
         fAllocations.push(sk_malloc_throw(bytes));
         return fAllocations.top();
     }
-    virtual void unalloc(void*) SK_OVERRIDE { }
+    void unalloc(void*) SK_OVERRIDE { }
     void setBitmapStorage(SkBitmapHeap* h) { this->setBitmapHeap(h); }
 private:
     SkTDArray<void*> fAllocations;
diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp
index 48100e714b..e8fea2fdf2 100644
--- a/tests/CachedDecodingPixelRefTest.cpp
+++ b/tests/CachedDecodingPixelRefTest.cpp
@@ -178,7 +178,7 @@ public:
     virtual ~TestImageGenerator() { }
 
 protected:
-    virtual bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+    bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
         REPORTER_ASSERT(fReporter, info);
         if ((NULL == info) || (kFailGetInfo_TestType == fType)) {
             return false;
diff --git a/tests/CanvasStateTest.cpp b/tests/CanvasStateTest.cpp
index 8364a4b414..8f77fb4d49 100644
--- a/tests/CanvasStateTest.cpp
+++ b/tests/CanvasStateTest.cpp
@@ -254,7 +254,7 @@ DEF_TEST(CanvasState_test_complex_clips, reporter) {
 
 class TestDrawFilter : public SkDrawFilter {
 public:
-    virtual bool filter(SkPaint*, Type) SK_OVERRIDE { return true; }
+    bool filter(SkPaint*, Type) SK_OVERRIDE { return true; }
 };
 
 DEF_TEST(CanvasState_test_draw_filters, reporter) {
diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index b55f833a52..e95c4ace81 100644
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -192,13 +192,13 @@ class Canvas2CanvasClipVisitor : public SkCanvas::ClipVisitor {
 public:
     Canvas2CanvasClipVisitor(SkCanvas* target) : fTarget(target) {}
 
-    virtual void clipRect(const SkRect& r, SkRegion::Op op, bool aa) SK_OVERRIDE {
+    void clipRect(const SkRect& r, SkRegion::Op op, bool aa) SK_OVERRIDE {
         fTarget->clipRect(r, op, aa);
     }
-    virtual void clipRRect(const SkRRect& r, SkRegion::Op op, bool aa) SK_OVERRIDE {
+    void clipRRect(const SkRRect& r, SkRegion::Op op, bool aa) SK_OVERRIDE {
         fTarget->clipRRect(r, op, aa);
     }
-    virtual void clipPath(const SkPath& p, SkRegion::Op op, bool aa) SK_OVERRIDE {
+    void clipPath(const SkPath& p, SkRegion::Op op, bool aa) SK_OVERRIDE {
         fTarget->clipPath(p, op, aa);
     }
 
diff --git a/tests/DeferredCanvasTest.cpp b/tests/DeferredCanvasTest.cpp
index 1c1970a03f..4ec67ae1ba 100644
--- a/tests/DeferredCanvasTest.cpp
+++ b/tests/DeferredCanvasTest.cpp
@@ -56,19 +56,19 @@ public:
         fBitmap.allocN32Pixels(width, height);
     }
 
-    virtual SkCanvas* onNewCanvas() SK_OVERRIDE {
+    SkCanvas* onNewCanvas() SK_OVERRIDE {
         return SkNEW_ARGS(SkCanvas, (fBitmap));
     }
 
-    virtual SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE {
+    SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE {
         return NULL;
     }
 
-    virtual SkImage* onNewImageSnapshot() SK_OVERRIDE {
+    SkImage* onNewImageSnapshot() SK_OVERRIDE {
         return SkNewImageFromBitmap(fBitmap, true, &this->props());
     }
 
-    virtual void onCopyOnWrite(ContentChangeMode mode) SK_OVERRIDE {
+    void onCopyOnWrite(ContentChangeMode mode) SK_OVERRIDE {
         if (mode == SkSurface::kDiscard_ContentChangeMode) {
             fDiscardCount++;
         } else {
@@ -426,16 +426,16 @@ public:
             fFlushedDrawCommandsCount = fSkippedPendingDrawCommandsCount = 0;
     }
 
-    virtual void prepareForDraw() SK_OVERRIDE {
+    void prepareForDraw() SK_OVERRIDE {
         fPrepareForDrawCount++;
     }
-    virtual void storageAllocatedForRecordingChanged(size_t) SK_OVERRIDE {
+    void storageAllocatedForRecordingChanged(size_t) SK_OVERRIDE {
         fStorageAllocatedChangedCount++;
     }
-    virtual void flushedDrawCommands() SK_OVERRIDE {
+    void flushedDrawCommands() SK_OVERRIDE {
         fFlushedDrawCommandsCount++;
     }
-    virtual void skippedPendingDrawCommands() SK_OVERRIDE {
+    void skippedPendingDrawCommands() SK_OVERRIDE {
         fSkippedPendingDrawCommandsCount++;
     }
 
diff --git a/tests/DrawBitmapRectTest.cpp b/tests/DrawBitmapRectTest.cpp
index c1e34a2612..1ecc590e53 100644
--- a/tests/DrawBitmapRectTest.cpp
+++ b/tests/DrawBitmapRectTest.cpp
@@ -24,7 +24,7 @@ public:
     virtual ~FailureImageGenerator() { }
 
 protected:
-    virtual bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+    bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
         *info = SkImageInfo::MakeN32Premul(100, 100);
         return true;
     }
diff --git a/tests/FrontBufferedStreamTest.cpp b/tests/FrontBufferedStreamTest.cpp
index e8c2c6a678..167d1a20e8 100644
--- a/tests/FrontBufferedStreamTest.cpp
+++ b/tests/FrontBufferedStreamTest.cpp
@@ -172,19 +172,19 @@ public:
         , fHasPosition(hasPosition)
     {}
 
-    virtual bool hasLength() const SK_OVERRIDE {
+    bool hasLength() const SK_OVERRIDE {
         return fHasLength;
     }
 
-    virtual bool hasPosition() const SK_OVERRIDE {
+    bool hasPosition() const SK_OVERRIDE {
         return fHasPosition;
     }
 
-    virtual size_t read(void*, size_t) SK_OVERRIDE {
+    size_t read(void*, size_t) SK_OVERRIDE {
         return 0;
     }
 
-    virtual bool isAtEnd() const SK_OVERRIDE {
+    bool isAtEnd() const SK_OVERRIDE {
         return true;
     }
 
@@ -261,7 +261,7 @@ public:
     : fAtEnd(false)
     , fReadAfterEnd(false)
     {}
-    virtual size_t read(void* buffer, size_t size) SK_OVERRIDE {
+    size_t read(void* buffer, size_t size) SK_OVERRIDE {
         if (fAtEnd) {
             fReadAfterEnd = true;
         } else {
@@ -270,7 +270,7 @@ public:
         return 0;
     }
 
-    virtual bool isAtEnd() const SK_OVERRIDE {
+    bool isAtEnd() const SK_OVERRIDE {
         return fAtEnd;
     }
 
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 087b819fc1..3b75b0f8d2 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -60,14 +60,14 @@ public:
         return SkRef(gBigKeyProcessor);
     }
 
-    virtual const char* name() const SK_OVERRIDE { return "Big Ole Key"; }
+    const char* name() const SK_OVERRIDE { return "Big Ole Key"; }
 
     virtual void getGLProcessorKey(const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLBigKeyProcessor::GenKey(*this, caps, b);
     }
 
-    virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+    GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
         return SkNEW_ARGS(GLBigKeyProcessor, (*this));
     }
 
@@ -75,8 +75,8 @@ private:
     BigKeyProcessor() {
         this->initClassID<BigKeyProcessor>();
     }
-    virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
-    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE { }
+    bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE { }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
diff --git a/tests/ImageCacheTest.cpp b/tests/ImageCacheTest.cpp
index c34f9d97e9..a4cfa73989 100644
--- a/tests/ImageCacheTest.cpp
+++ b/tests/ImageCacheTest.cpp
@@ -24,8 +24,8 @@ struct TestingRec : public SkResourceCache::Rec {
     TestingKey  fKey;
     intptr_t    fValue;
 
-    virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
-    virtual size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
+    const Key& getKey() const SK_OVERRIDE { return fKey; }
+    size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
 
     static bool Visitor(const SkResourceCache::Rec& baseRec, void* context) {
         const TestingRec& rec = static_cast<const TestingRec&>(baseRec);
diff --git a/tests/ImageDecodingTest.cpp b/tests/ImageDecodingTest.cpp
index 528c295d93..78d6b6c35f 100644
--- a/tests/ImageDecodingTest.cpp
+++ b/tests/ImageDecodingTest.cpp
@@ -760,7 +760,7 @@ public:
     SingleAllocator(void* p, size_t s) : fPixels(p), fSize(s) { }
     ~SingleAllocator() {}
     // If the pixels in fPixels are big enough, use them.
-    virtual bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) SK_OVERRIDE {
+    bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) SK_OVERRIDE {
         SkASSERT(bm);
         if (bm->info().getSafeSize(bm->rowBytes()) <= fSize) {
             bm->setPixels(fPixels, ct);
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index add9e23bba..4ffcc11209 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -59,7 +59,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
 
 protected:
-    virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+    void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
         this->INHERITED::flatten(buffer);
         buffer.writeFunctionPtr(fReporter);
         buffer.writeMatrix(fExpectedMatrix);
diff --git a/tests/LazyPtrTest.cpp b/tests/LazyPtrTest.cpp
index 799f705085..8bded1e9df 100644
--- a/tests/LazyPtrTest.cpp
+++ b/tests/LazyPtrTest.cpp
@@ -49,7 +49,7 @@ namespace {
 struct Racer : public SkRunnable {
     Racer() : fLazy(NULL), fSeen(NULL) {}
 
-    virtual void run() SK_OVERRIDE { fSeen = fLazy->get(); }
+    void run() SK_OVERRIDE { fSeen = fLazy->get(); }
 
     SkLazyPtr<int>* fLazy;
     int* fSeen;
diff --git a/tests/OnceTest.cpp b/tests/OnceTest.cpp
index da901f41c4..6ab9cd27ac 100644
--- a/tests/OnceTest.cpp
+++ b/tests/OnceTest.cpp
@@ -39,7 +39,7 @@ public:
     SkOnceFlag* once;
     int* ptr;
 
-    virtual void run() SK_OVERRIDE {
+    void run() SK_OVERRIDE {
         SkOnce(once, add_six, ptr);
     }
 };
diff --git a/tests/PDFInvalidBitmapTest.cpp b/tests/PDFInvalidBitmapTest.cpp
index 2f4753e4a4..bc7143a159 100644
--- a/tests/PDFInvalidBitmapTest.cpp
+++ b/tests/PDFInvalidBitmapTest.cpp
@@ -23,8 +23,8 @@ class InvalidPixelRef : public SkPixelRef {
 public:
     InvalidPixelRef(const SkImageInfo& info) : SkPixelRef(info) {}
 private:
-    virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE { return false; }
-    virtual void onUnlockPixels() SK_OVERRIDE {
+    bool onNewLockPixels(LockRec*) SK_OVERRIDE { return false; }
+    void onUnlockPixels() SK_OVERRIDE {
         SkDEBUGFAIL("InvalidPixelRef can't be locked");
     }
 };
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
index 3f539e3843..2ff98607fb 100644
--- a/tests/PDFPrimitivesTest.cpp
+++ b/tests/PDFPrimitivesTest.cpp
@@ -435,7 +435,7 @@ namespace {
 class DummyImageFilter : public SkImageFilter {
 public:
     DummyImageFilter(bool visited = false) : SkImageFilter(0, NULL), fVisited(visited) {}
-    virtual ~DummyImageFilter() SK_OVERRIDE {}
+    ~DummyImageFilter() SK_OVERRIDE {}
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
                                SkBitmap* result, SkIPoint* offset) const {
         fVisited = true;
diff --git a/tests/PathOpsSkpClipTest.cpp b/tests/PathOpsSkpClipTest.cpp
index ad0a95f22b..99a5030b56 100755
--- a/tests/PathOpsSkpClipTest.cpp
+++ b/tests/PathOpsSkpClipTest.cpp
@@ -253,7 +253,7 @@ struct TestRunner {
 
 class TestRunnable : public SkRunnable {
 public:
-    virtual void run() SK_OVERRIDE {
+    void run() SK_OVERRIDE {
         SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024);
         (*fTestFun)(&fState);
     }
@@ -819,10 +819,10 @@ typedef SkTRegistry<Test*(*)(void*)> TestRegistry;
     public:                                                             \
         static Test* Factory(void*) { return SkNEW(name##Class); }      \
     protected:                                                          \
-        virtual void onGetName(SkString* name) SK_OVERRIDE {            \
+        void onGetName(SkString* name) SK_OVERRIDE {            \
             name->set(#name);                                           \
         }                                                               \
-        virtual void onRun() SK_OVERRIDE { test_##name(); } \
+        void onRun() SK_OVERRIDE { test_##name(); } \
     };                                                                  \
     static TestRegistry gReg_##name##Class(name##Class::Factory);       \
     static void test_##name()
diff --git a/tests/PathOpsThreadedCommon.h b/tests/PathOpsThreadedCommon.h
index 124921e389..e43afe1ac0 100644
--- a/tests/PathOpsThreadedCommon.h
+++ b/tests/PathOpsThreadedCommon.h
@@ -73,7 +73,7 @@ public:
         fTestFun = testFun;
     }
 
-    virtual void run() SK_OVERRIDE {
+    void run() SK_OVERRIDE {
         SkBitmap bitmap;
         fState.fBitmap = &bitmap;
         char pathStr[PATH_STR_SIZE];
diff --git a/tests/PictureBBHTest.cpp b/tests/PictureBBHTest.cpp
index e647c77dce..771aa1261d 100644
--- a/tests/PictureBBHTest.cpp
+++ b/tests/PictureBBHTest.cpp
@@ -62,7 +62,7 @@ public:
         : PictureBBHTestBase(2, 2, 1, 1) { }
     virtual ~DrawEmptyPictureBBHTest() { }
 
-    virtual void doTest(SkCanvas&, SkCanvas&) SK_OVERRIDE { }
+    void doTest(SkCanvas&, SkCanvas&) SK_OVERRIDE { }
 };
 
 // Test to verify the playback of a picture into a canvas that has
@@ -73,7 +73,7 @@ public:
     EmptyClipPictureBBHTest()
         : PictureBBHTestBase(2, 2, 3, 3) { }
 
-    virtual void doTest(SkCanvas& playbackCanvas, SkCanvas& recordingCanvas) SK_OVERRIDE {
+    void doTest(SkCanvas& playbackCanvas, SkCanvas& recordingCanvas) SK_OVERRIDE {
         // intersect with out of bounds rect -> empty clip.
         playbackCanvas.clipRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
             SkIntToScalar(1), SkIntToScalar(1)), SkRegion::kIntersect_Op);
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index c2e1bb103c..d69de45fd4 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -1165,12 +1165,12 @@ public:
         return this->INHERITED::willSaveLayer(bounds, paint, flags);
     }
 
-    virtual void willSave() SK_OVERRIDE {
+    void willSave() SK_OVERRIDE {
         ++fSaveCount;
         this->INHERITED::willSave();
     }
 
-    virtual void willRestore() SK_OVERRIDE {
+    void willRestore() SK_OVERRIDE {
         ++fRestoreCount;
         this->INHERITED::willRestore();
     }
@@ -1637,7 +1637,7 @@ public:
         this->INHERITED::onClipPath(path, op, edgeStyle);
     }
 
-    virtual void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) SK_OVERRIDE {
+    void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) SK_OVERRIDE {
         fClipCount += 1;
         this->INHERITED::onClipRegion(deviceRgn, op);
     }
@@ -1866,11 +1866,11 @@ struct CountingBBH : public SkBBoxHierarchy {
 
     CountingBBH() : searchCalls(0) {}
 
-    virtual void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE {
+    void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE {
         this->searchCalls++;
     }
 
-    virtual void insert(SkAutoTMalloc<SkRect>*, int) SK_OVERRIDE {}
+    void insert(SkAutoTMalloc<SkRect>*, int) SK_OVERRIDE {}
     virtual size_t bytesUsed() const { return 0; }
 };
 
diff --git a/tests/PixelRefTest.cpp b/tests/PixelRefTest.cpp
index d1d3026f8d..b9a28244ec 100644
--- a/tests/PixelRefTest.cpp
+++ b/tests/PixelRefTest.cpp
@@ -6,7 +6,7 @@
 class TestListener : public SkPixelRef::GenIDChangeListener {
 public:
     explicit TestListener(int* ptr) : fPtr(ptr) {}
-    virtual void onChange() SK_OVERRIDE { (*fPtr)++; }
+    void onChange() SK_OVERRIDE { (*fPtr)++; }
 private:
     int* fPtr;
 };
diff --git a/tests/QuickRejectTest.cpp b/tests/QuickRejectTest.cpp
index 77bcd3c9b1..cefde12354 100644
--- a/tests/QuickRejectTest.cpp
+++ b/tests/QuickRejectTest.cpp
@@ -16,14 +16,14 @@
 class TestLooper : public SkDrawLooper {
 public:
 
-    virtual SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const SK_OVERRIDE {
+    SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const SK_OVERRIDE {
         return SkNEW_PLACEMENT(storage, TestDrawLooperContext);
     }
 
-    virtual size_t contextSize() const SK_OVERRIDE { return sizeof(TestDrawLooperContext); }
+    size_t contextSize() const SK_OVERRIDE { return sizeof(TestDrawLooperContext); }
 
 #ifndef SK_IGNORE_TO_STRING
-    virtual void toString(SkString* str) const SK_OVERRIDE {
+    void toString(SkString* str) const SK_OVERRIDE {
         str->append("TestLooper:");
     }
 #endif
@@ -36,7 +36,7 @@ private:
         TestDrawLooperContext() : fOnce(true) {}
         virtual ~TestDrawLooperContext() {}
 
-        virtual bool next(SkCanvas* canvas, SkPaint*) SK_OVERRIDE {
+        bool next(SkCanvas* canvas, SkPaint*) SK_OVERRIDE {
             if (fOnce) {
                 fOnce = false;
                 canvas->translate(SkIntToScalar(10), 0);
diff --git a/tests/RecordDrawTest.cpp b/tests/RecordDrawTest.cpp
index 5f0195d0c2..4e1ad15bf4 100644
--- a/tests/RecordDrawTest.cpp
+++ b/tests/RecordDrawTest.cpp
@@ -24,7 +24,7 @@ class JustOneDraw : public SkPicture::AbortCallback {
 public:
     JustOneDraw() : fCalls(0) {}
 
-    virtual bool abort() SK_OVERRIDE { return fCalls++ > 0; }
+    bool abort() SK_OVERRIDE { return fCalls++ > 0; }
 private:
     int fCalls;
 };
@@ -123,7 +123,7 @@ DEF_TEST(RecordDraw_SetMatrixClobber, r) {
 }
 
 struct TestBBH : public SkBBoxHierarchy {
-    virtual void insert(SkAutoTMalloc<SkRect>* boundsArray, int N) SK_OVERRIDE {
+    void insert(SkAutoTMalloc<SkRect>* boundsArray, int N) SK_OVERRIDE {
         fEntries.setCount(N);
         for (int i = 0; i < N; i++) {
             Entry e = { (unsigned)i, (*boundsArray)[i] };
@@ -131,8 +131,8 @@ struct TestBBH : public SkBBoxHierarchy {
         }
     }
 
-    virtual void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE {}
-    virtual size_t bytesUsed() const SK_OVERRIDE { return 0; }
+    void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE {}
+    size_t bytesUsed() const SK_OVERRIDE { return 0; }
 
     struct Entry {
         unsigned opIndex;
diff --git a/tests/RecordReplaceDrawTest.cpp b/tests/RecordReplaceDrawTest.cpp
index 9136ffce7b..bbf01686d0 100644
--- a/tests/RecordReplaceDrawTest.cpp
+++ b/tests/RecordReplaceDrawTest.cpp
@@ -26,7 +26,7 @@ class JustOneDraw : public SkPicture::AbortCallback {
 public:
     JustOneDraw() : fCalls(0) {}
 
-    virtual bool abort() SK_OVERRIDE { return fCalls++ > 0; }
+    bool abort() SK_OVERRIDE { return fCalls++ > 0; }
 private:
     int fCalls;
 };
diff --git a/tests/SkpSkGrTest.cpp b/tests/SkpSkGrTest.cpp
index c882654650..c2f1a798d6 100644
--- a/tests/SkpSkGrTest.cpp
+++ b/tests/SkpSkGrTest.cpp
@@ -146,7 +146,7 @@ public:
         fTestFun = testFun;
     }
 
-    virtual void run() SK_OVERRIDE {
+    void run() SK_OVERRIDE {
         SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024);
         (*fTestFun)(&fState);
     }
diff --git a/tests/Test.cpp b/tests/Test.cpp
index acbc332936..cf068690a6 100644
--- a/tests/Test.cpp
+++ b/tests/Test.cpp
@@ -66,20 +66,20 @@ public:
     const skiatest::Failure& failure(int i) const { return fFailures[i]; }
 
 protected:
-    virtual void onReportFailed(const Failure& failure) SK_OVERRIDE {
+    void onReportFailed(const Failure& failure) SK_OVERRIDE {
         fFailures.push_back(failure);
     }
 
     // Proxy down to fReporter.  We assume these calls are threadsafe.
-    virtual bool allowExtendedTest() const SK_OVERRIDE {
+    bool allowExtendedTest() const SK_OVERRIDE {
         return fReporter->allowExtendedTest();
     }
 
-    virtual void bumpTestCount() SK_OVERRIDE {
+    void bumpTestCount() SK_OVERRIDE {
         fReporter->bumpTestCount();
     }
 
-    virtual bool verbose() const SK_OVERRIDE {
+    bool verbose() const SK_OVERRIDE {
         return fReporter->verbose();
     }
 
diff --git a/tests/Test.h b/tests/Test.h
index 90cd25998f..4f838f501c 100644
--- a/tests/Test.h
+++ b/tests/Test.h
@@ -178,10 +178,10 @@ namespace skiatest {
     public:                                                             \
         static Test* Factory(void*) { return SkNEW(name##Class); }      \
     protected:                                                          \
-        virtual void onGetName(SkString* name) SK_OVERRIDE {            \
+        void onGetName(SkString* name) SK_OVERRIDE {            \
             name->set(#name);                                           \
         }                                                               \
-        virtual void onRun(Reporter* r) SK_OVERRIDE { test_##name(r); } \
+        void onRun(Reporter* r) SK_OVERRIDE { test_##name(r); } \
     };                                                                  \
     static TestRegistry gReg_##name##Class(name##Class::Factory);       \
     }                                                                   \
@@ -194,10 +194,10 @@ namespace skiatest {
     public:                                                           \
         static Test* Factory(void*) { return SkNEW(name##Class); }    \
     protected:                                                        \
-        virtual void onGetName(SkString* name) SK_OVERRIDE {          \
+        void onGetName(SkString* name) SK_OVERRIDE {          \
             name->set(#name);                                         \
         }                                                             \
-        virtual void onRun(Reporter* r) SK_OVERRIDE {                 \
+        void onRun(Reporter* r) SK_OVERRIDE {                 \
             test_##name(r, fGrContextFactory);                        \
         }                                                             \
     };                                                                \
diff --git a/tests/skia_test.cpp b/tests/skia_test.cpp
index 1b5584b6a6..cf446d2105 100644
--- a/tests/skia_test.cpp
+++ b/tests/skia_test.cpp
@@ -54,17 +54,17 @@ class DebugfReporter : public Reporter {
 public:
     explicit DebugfReporter(int total) : fDone(0), fTotal(total) {}
 
-    virtual bool allowExtendedTest() const SK_OVERRIDE { return FLAGS_extendedTest; }
-    virtual bool verbose()           const SK_OVERRIDE { return FLAGS_veryVerbose; }
+    bool allowExtendedTest() const SK_OVERRIDE { return FLAGS_extendedTest; }
+    bool verbose()           const SK_OVERRIDE { return FLAGS_veryVerbose; }
 
 protected:
-    virtual void onReportFailed(const skiatest::Failure& failure) SK_OVERRIDE {
+    void onReportFailed(const skiatest::Failure& failure) SK_OVERRIDE {
         SkString desc;
         failure.getFailureString(&desc);
         SkDebugf("\nFAILED: %s", desc.c_str());
     }
 
-    virtual void onEnd(Test* test) SK_OVERRIDE {
+    void onEnd(Test* test) SK_OVERRIDE {
         const int done = 1 + sk_atomic_inc(&fDone);
 
         if (!test->passed()) {