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

NOPRESUBMIT=true

BUG=skia:
DOCS_PREVIEW= https://skia.org/?cl=1037793002

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

27 files changed, 81 insertions, 81 deletions

diff --git a/tests/BitmapHeapTest.cpp b/tests/BitmapHeapTest.cpp
index 21ce2f39e8..eb86283618 100644
--- a/tests/BitmapHeapTest.cpp
+++ b/tests/BitmapHeapTest.cpp
@@ -18,11 +18,11 @@
 struct SimpleFlatController : public SkFlatController {
     SimpleFlatController() : SkFlatController() {}
     ~SimpleFlatController() { fAllocations.freeAll(); }
-    void* allocThrow(size_t bytes) SK_OVERRIDE {
+    void* allocThrow(size_t bytes) override {
         fAllocations.push(sk_malloc_throw(bytes));
         return fAllocations.top();
     }
-    void unalloc(void*) SK_OVERRIDE { }
+    void unalloc(void*) override { }
     void setBitmapStorage(SkBitmapHeap* h) { this->setBitmapHeap(h); }
 private:
     SkTDArray<void*> fAllocations;
diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp
index ddc0994e56..fc56edd823 100644
--- a/tests/CachedDecodingPixelRefTest.cpp
+++ b/tests/CachedDecodingPixelRefTest.cpp
@@ -183,7 +183,7 @@ protected:
     }
 
 #ifdef SK_SUPPORT_LEGACY_BOOL_ONGETINFO
-    bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+    bool onGetInfo(SkImageInfo* info) override {
         REPORTER_ASSERT(fReporter, info);
         *info = GetMyInfo();
         return true;
@@ -192,7 +192,7 @@ protected:
 
     virtual Result onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
                                const Options&,
-                               SkPMColor ctable[], int* ctableCount) SK_OVERRIDE {
+                               SkPMColor ctable[], int* ctableCount) override {
         REPORTER_ASSERT(fReporter, pixels != NULL);
         REPORTER_ASSERT(fReporter, rowBytes >= info.minRowBytes());
         if (fType != kSucceedGetPixels_TestType) {
diff --git a/tests/CanvasStateTest.cpp b/tests/CanvasStateTest.cpp
index 8f77fb4d49..f4db1a53d7 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:
-    bool filter(SkPaint*, Type) SK_OVERRIDE { return true; }
+    bool filter(SkPaint*, Type) override { return true; }
 };
 
 DEF_TEST(CanvasState_test_draw_filters, reporter) {
diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index 23d49834c2..d709a935a6 100644
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -190,13 +190,13 @@ class Canvas2CanvasClipVisitor : public SkCanvas::ClipVisitor {
 public:
     Canvas2CanvasClipVisitor(SkCanvas* target) : fTarget(target) {}
 
-    void clipRect(const SkRect& r, SkRegion::Op op, bool aa) SK_OVERRIDE {
+    void clipRect(const SkRect& r, SkRegion::Op op, bool aa) override {
         fTarget->clipRect(r, op, aa);
     }
-    void clipRRect(const SkRRect& r, SkRegion::Op op, bool aa) SK_OVERRIDE {
+    void clipRRect(const SkRRect& r, SkRegion::Op op, bool aa) override {
         fTarget->clipRRect(r, op, aa);
     }
-    void clipPath(const SkPath& p, SkRegion::Op op, bool aa) SK_OVERRIDE {
+    void clipPath(const SkPath& p, SkRegion::Op op, bool aa) override {
         fTarget->clipPath(p, op, aa);
     }
 
diff --git a/tests/DeferredCanvasTest.cpp b/tests/DeferredCanvasTest.cpp
index e83bc8106b..56b1bea93f 100644
--- a/tests/DeferredCanvasTest.cpp
+++ b/tests/DeferredCanvasTest.cpp
@@ -56,19 +56,19 @@ public:
         fBitmap.allocN32Pixels(width, height);
     }
 
-    SkCanvas* onNewCanvas() SK_OVERRIDE {
+    SkCanvas* onNewCanvas() override {
         return SkNEW_ARGS(SkCanvas, (fBitmap));
     }
 
-    SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE {
+    SkSurface* onNewSurface(const SkImageInfo&) override {
         return NULL;
     }
 
-    SkImage* onNewImageSnapshot(Budgeted) SK_OVERRIDE {
+    SkImage* onNewImageSnapshot(Budgeted) override {
         return SkNewImageFromBitmap(fBitmap, true, &this->props());
     }
 
-    void onCopyOnWrite(ContentChangeMode mode) SK_OVERRIDE {
+    void onCopyOnWrite(ContentChangeMode mode) override {
         if (mode == SkSurface::kDiscard_ContentChangeMode) {
             fCOWDiscardCount++;
         } else {
@@ -76,7 +76,7 @@ public:
         }
     }
 
-    void onDiscard() SK_OVERRIDE {
+    void onDiscard() override {
         fDiscardCount++;
     }
 
@@ -446,7 +446,7 @@ public:
         fDrawBitmapCallCount = 0;
     }
     virtual void drawBitmap(const SkDraw&, const SkBitmap&,
-                            const SkMatrix&, const SkPaint&) SK_OVERRIDE {
+                            const SkMatrix&, const SkPaint&) override {
         fDrawBitmapCallCount++;
     }
 
@@ -460,16 +460,16 @@ public:
             fFlushedDrawCommandsCount = fSkippedPendingDrawCommandsCount = 0;
     }
 
-    void prepareForDraw() SK_OVERRIDE {
+    void prepareForDraw() override {
         fPrepareForDrawCount++;
     }
-    void storageAllocatedForRecordingChanged(size_t) SK_OVERRIDE {
+    void storageAllocatedForRecordingChanged(size_t) override {
         fStorageAllocatedChangedCount++;
     }
-    void flushedDrawCommands() SK_OVERRIDE {
+    void flushedDrawCommands() override {
         fFlushedDrawCommandsCount++;
     }
-    void skippedPendingDrawCommands() SK_OVERRIDE {
+    void skippedPendingDrawCommands() override {
         fSkippedPendingDrawCommandsCount++;
     }
 
diff --git a/tests/DrawBitmapRectTest.cpp b/tests/DrawBitmapRectTest.cpp
index bde0095df9..060e08b3a7 100644
--- a/tests/DrawBitmapRectTest.cpp
+++ b/tests/DrawBitmapRectTest.cpp
@@ -23,7 +23,7 @@ public:
     FailureImageGenerator() : SkImageGenerator(SkImageInfo::MakeN32Premul(100, 100)) {}
 protected:
 #ifdef SK_SUPPORT_LEGACY_BOOL_ONGETINFO
-    bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+    bool onGetInfo(SkImageInfo* info) override {
         *info = SkImageInfo::MakeN32Premul(100, 100);
         return true;
     }
diff --git a/tests/FrontBufferedStreamTest.cpp b/tests/FrontBufferedStreamTest.cpp
index 69dade04b9..f3ef47db59 100644
--- a/tests/FrontBufferedStreamTest.cpp
+++ b/tests/FrontBufferedStreamTest.cpp
@@ -131,7 +131,7 @@ public:
         : INHERITED(data, size, ownMemory)
         , fIsAtEnd(false) {}
 
-    size_t read(void* dst, size_t requested) SK_OVERRIDE {
+    size_t read(void* dst, size_t requested) override {
         size_t bytesRead = this->INHERITED::read(dst, requested);
         if (bytesRead < requested) {
             fIsAtEnd = true;
@@ -139,7 +139,7 @@ public:
         return bytesRead;
     }
 
-    bool isAtEnd() const SK_OVERRIDE {
+    bool isAtEnd() const override {
         return fIsAtEnd;
     }
 
@@ -175,19 +175,19 @@ public:
         , fHasPosition(hasPosition)
     {}
 
-    bool hasLength() const SK_OVERRIDE {
+    bool hasLength() const override {
         return fHasLength;
     }
 
-    bool hasPosition() const SK_OVERRIDE {
+    bool hasPosition() const override {
         return fHasPosition;
     }
 
-    size_t read(void*, size_t) SK_OVERRIDE {
+    size_t read(void*, size_t) override {
         return 0;
     }
 
-    bool isAtEnd() const SK_OVERRIDE {
+    bool isAtEnd() const override {
         return true;
     }
 
@@ -264,7 +264,7 @@ public:
     : fAtEnd(false)
     , fReadAfterEnd(false)
     {}
-    size_t read(void* buffer, size_t size) SK_OVERRIDE {
+    size_t read(void* buffer, size_t size) override {
         if (fAtEnd) {
             fReadAfterEnd = true;
         } else {
@@ -273,7 +273,7 @@ public:
         return 0;
     }
 
-    bool isAtEnd() const SK_OVERRIDE {
+    bool isAtEnd() const override {
         return fAtEnd;
     }
 
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index b2204b4b2b..ed74ae8f6a 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -61,14 +61,14 @@ public:
         return SkRef(gBigKeyProcessor);
     }
 
-    const char* name() const SK_OVERRIDE { return "Big Ole Key"; }
+    const char* name() const override { return "Big Ole Key"; }
 
     virtual void getGLProcessorKey(const GrGLCaps& caps,
-                                   GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+                                   GrProcessorKeyBuilder* b) const override {
         GLBigKeyProcessor::GenKey(*this, caps, b);
     }
 
-    GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+    GrGLFragmentProcessor* createGLInstance() const override {
         return SkNEW_ARGS(GLBigKeyProcessor, (*this));
     }
 
@@ -76,8 +76,8 @@ private:
     BigKeyProcessor() {
         this->initClassID<BigKeyProcessor>();
     }
-    bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
-    void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE { }
+    bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const override { }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
diff --git a/tests/ImageCacheTest.cpp b/tests/ImageCacheTest.cpp
index 45dee92a2f..2244bb0a53 100644
--- a/tests/ImageCacheTest.cpp
+++ b/tests/ImageCacheTest.cpp
@@ -24,8 +24,8 @@ struct TestingRec : public SkResourceCache::Rec {
     TestingKey  fKey;
     intptr_t    fValue;
 
-    const Key& getKey() const SK_OVERRIDE { return fKey; }
-    size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
+    const Key& getKey() const override { return fKey; }
+    size_t bytesUsed() const 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 b94e29c11d..3c78e0f407 100644
--- a/tests/ImageDecodingTest.cpp
+++ b/tests/ImageDecodingTest.cpp
@@ -696,7 +696,7 @@ public:
     SingleAllocator(void* p, size_t s) : fPixels(p), fSize(s) { }
     ~SingleAllocator() {}
     // If the pixels in fPixels are big enough, use them.
-    bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) SK_OVERRIDE {
+    bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) 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 87aabd1c8d..1fe9228fe4 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -50,7 +50,7 @@ public:
     }
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context& ctx,
-                               SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
+                               SkBitmap* result, SkIPoint* offset) const override {
         REPORTER_ASSERT(fReporter, ctx.ctm() == fExpectedMatrix);
         return true;
     }
@@ -59,7 +59,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
 
 protected:
-    void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+    void flatten(SkWriteBuffer& buffer) const override {
         this->INHERITED::flatten(buffer);
         buffer.writeFunctionPtr(fReporter);
         buffer.writeMatrix(fExpectedMatrix);
diff --git a/tests/LayerDrawLooperTest.cpp b/tests/LayerDrawLooperTest.cpp
index bc76a02a4b..2c9b525aa2 100644
--- a/tests/LayerDrawLooperTest.cpp
+++ b/tests/LayerDrawLooperTest.cpp
@@ -30,7 +30,7 @@ public:
     FakeDevice() : SkBitmapDevice(make_bm(100, 100)) { }
 
     virtual void drawRect(const SkDraw& draw, const SkRect& r,
-                          const SkPaint& paint) SK_OVERRIDE {
+                          const SkPaint& paint) override {
         fLastMatrix = *draw.fMatrix;
         this->INHERITED::drawRect(draw, r, paint);
     }
diff --git a/tests/LazyPtrTest.cpp b/tests/LazyPtrTest.cpp
index 8bded1e9df..1b845bc502 100644
--- a/tests/LazyPtrTest.cpp
+++ b/tests/LazyPtrTest.cpp
@@ -49,7 +49,7 @@ namespace {
 struct Racer : public SkRunnable {
     Racer() : fLazy(NULL), fSeen(NULL) {}
 
-    void run() SK_OVERRIDE { fSeen = fLazy->get(); }
+    void run() override { fSeen = fLazy->get(); }
 
     SkLazyPtr<int>* fLazy;
     int* fSeen;
diff --git a/tests/OnceTest.cpp b/tests/OnceTest.cpp
index 1344cee5c4..034c5d912f 100644
--- a/tests/OnceTest.cpp
+++ b/tests/OnceTest.cpp
@@ -39,7 +39,7 @@ public:
     SkOnceFlag* once;
     int* ptr;
 
-    void run() SK_OVERRIDE {
+    void run() override {
         SkOnce(once, add_six, ptr);
     }
 };
diff --git a/tests/PDFInvalidBitmapTest.cpp b/tests/PDFInvalidBitmapTest.cpp
index bc7143a159..8a9b1fa132 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:
-    bool onNewLockPixels(LockRec*) SK_OVERRIDE { return false; }
-    void onUnlockPixels() SK_OVERRIDE {
+    bool onNewLockPixels(LockRec*) override { return false; }
+    void onUnlockPixels() override {
         SkDEBUGFAIL("InvalidPixelRef can't be locked");
     }
 };
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
index f2bb5f4710..36c803f6d5 100644
--- a/tests/PDFPrimitivesTest.cpp
+++ b/tests/PDFPrimitivesTest.cpp
@@ -298,9 +298,9 @@ namespace {
 class DummyImageFilter : public SkImageFilter {
 public:
     DummyImageFilter(bool visited = false) : SkImageFilter(0, NULL), fVisited(visited) {}
-    ~DummyImageFilter() SK_OVERRIDE {}
+    ~DummyImageFilter() override {}
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
+                               SkBitmap* result, SkIPoint* offset) const override {
         fVisited = true;
         offset->fX = offset->fY = 0;
         *result = src;
diff --git a/tests/PathOpsSkpClipTest.cpp b/tests/PathOpsSkpClipTest.cpp
index 3cc788f13c..9a23eaa377 100755
--- a/tests/PathOpsSkpClipTest.cpp
+++ b/tests/PathOpsSkpClipTest.cpp
@@ -253,7 +253,7 @@ struct TestRunner {
 
 class TestRunnable : public SkRunnable {
 public:
-    void run() SK_OVERRIDE {
+    void run() 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:                                                          \
-        void onGetName(SkString* name) SK_OVERRIDE {            \
+        void onGetName(SkString* name) override {            \
             name->set(#name);                                           \
         }                                                               \
-        void onRun() SK_OVERRIDE { test_##name(); } \
+        void onRun() 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 e43afe1ac0..5bf5da2682 100644
--- a/tests/PathOpsThreadedCommon.h
+++ b/tests/PathOpsThreadedCommon.h
@@ -73,7 +73,7 @@ public:
         fTestFun = testFun;
     }
 
-    void run() SK_OVERRIDE {
+    void run() override {
         SkBitmap bitmap;
         fState.fBitmap = &bitmap;
         char pathStr[PATH_STR_SIZE];
diff --git a/tests/PictureBBHTest.cpp b/tests/PictureBBHTest.cpp
index 771aa1261d..d09403ff14 100644
--- a/tests/PictureBBHTest.cpp
+++ b/tests/PictureBBHTest.cpp
@@ -62,7 +62,7 @@ public:
         : PictureBBHTestBase(2, 2, 1, 1) { }
     virtual ~DrawEmptyPictureBBHTest() { }
 
-    void doTest(SkCanvas&, SkCanvas&) SK_OVERRIDE { }
+    void doTest(SkCanvas&, SkCanvas&) 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) { }
 
-    void doTest(SkCanvas& playbackCanvas, SkCanvas& recordingCanvas) SK_OVERRIDE {
+    void doTest(SkCanvas& playbackCanvas, SkCanvas& recordingCanvas) 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 12d9b1559b..14e703fce4 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -548,17 +548,17 @@ public:
     }
 
     virtual SaveLayerStrategy willSaveLayer(const SkRect* bounds, const SkPaint* paint,
-                                            SaveFlags flags) SK_OVERRIDE {
+                                            SaveFlags flags) override {
         ++fSaveLayerCount;
         return this->INHERITED::willSaveLayer(bounds, paint, flags);
     }
 
-    void willSave() SK_OVERRIDE {
+    void willSave() override {
         ++fSaveCount;
         this->INHERITED::willSave();
     }
 
-    void willRestore() SK_OVERRIDE {
+    void willRestore() override {
         ++fRestoreCount;
         this->INHERITED::willRestore();
     }
@@ -994,26 +994,26 @@ public:
 
     virtual void onClipRect(const SkRect& r,
                             SkRegion::Op op,
-                            ClipEdgeStyle edgeStyle) SK_OVERRIDE {
+                            ClipEdgeStyle edgeStyle) override {
         fClipCount += 1;
         this->INHERITED::onClipRect(r, op, edgeStyle);
     }
 
     virtual void onClipRRect(const SkRRect& rrect,
                              SkRegion::Op op,
-                             ClipEdgeStyle edgeStyle)SK_OVERRIDE {
+                             ClipEdgeStyle edgeStyle)override {
         fClipCount += 1;
         this->INHERITED::onClipRRect(rrect, op, edgeStyle);
     }
 
     virtual void onClipPath(const SkPath& path,
                             SkRegion::Op op,
-                            ClipEdgeStyle edgeStyle) SK_OVERRIDE {
+                            ClipEdgeStyle edgeStyle) override {
         fClipCount += 1;
         this->INHERITED::onClipPath(path, op, edgeStyle);
     }
 
-    void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) SK_OVERRIDE {
+    void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) override {
         fClipCount += 1;
         this->INHERITED::onClipRegion(deviceRgn, op);
     }
@@ -1241,19 +1241,19 @@ struct CountingBBH : public SkBBoxHierarchy {
 
     CountingBBH(const SkRect& bound) : searchCalls(0), rootBound(bound) {}
 
-    void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE {
+    void search(const SkRect& query, SkTDArray<unsigned>* results) const override {
         this->searchCalls++;
     }
 
-    void insert(const SkRect[], int) SK_OVERRIDE {}
-    virtual size_t bytesUsed() const SK_OVERRIDE { return 0; }
-    SkRect getRootBound() const SK_OVERRIDE { return rootBound; }
+    void insert(const SkRect[], int) override {}
+    virtual size_t bytesUsed() const override { return 0; }
+    SkRect getRootBound() const override { return rootBound; }
 };
 
 class SpoonFedBBHFactory : public SkBBHFactory {
 public:
     explicit SpoonFedBBHFactory(SkBBoxHierarchy* bbh) : fBBH(bbh) {}
-    SkBBoxHierarchy* operator()(const SkRect&) const SK_OVERRIDE {
+    SkBBoxHierarchy* operator()(const SkRect&) const override {
         return SkRef(fBBH);
     }
 private:
diff --git a/tests/PixelRefTest.cpp b/tests/PixelRefTest.cpp
index b9a28244ec..e13d0e07e5 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) {}
-    void onChange() SK_OVERRIDE { (*fPtr)++; }
+    void onChange() override { (*fPtr)++; }
 private:
     int* fPtr;
 };
diff --git a/tests/QuickRejectTest.cpp b/tests/QuickRejectTest.cpp
index 447d81615b..e5dea247fb 100644
--- a/tests/QuickRejectTest.cpp
+++ b/tests/QuickRejectTest.cpp
@@ -16,14 +16,14 @@
 class TestLooper : public SkDrawLooper {
 public:
 
-    SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const SK_OVERRIDE {
+    SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const override {
         return SkNEW_PLACEMENT(storage, TestDrawLooperContext);
     }
 
-    size_t contextSize() const SK_OVERRIDE { return sizeof(TestDrawLooperContext); }
+    size_t contextSize() const override { return sizeof(TestDrawLooperContext); }
 
 #ifndef SK_IGNORE_TO_STRING
-    void toString(SkString* str) const SK_OVERRIDE {
+    void toString(SkString* str) const override {
         str->append("TestLooper:");
     }
 #endif
@@ -36,7 +36,7 @@ private:
         TestDrawLooperContext() : fOnce(true) {}
         virtual ~TestDrawLooperContext() {}
 
-        bool next(SkCanvas* canvas, SkPaint*) SK_OVERRIDE {
+        bool next(SkCanvas* canvas, SkPaint*) override {
             if (fOnce) {
                 fOnce = false;
                 canvas->translate(SkIntToScalar(10), 0);
diff --git a/tests/RecordDrawTest.cpp b/tests/RecordDrawTest.cpp
index baee712b37..1e365bce30 100644
--- a/tests/RecordDrawTest.cpp
+++ b/tests/RecordDrawTest.cpp
@@ -24,7 +24,7 @@ class JustOneDraw : public SkPicture::AbortCallback {
 public:
     JustOneDraw() : fCalls(0) {}
 
-    bool abort() SK_OVERRIDE { return fCalls++ > 0; }
+    bool abort() override { return fCalls++ > 0; }
 private:
     int fCalls;
 };
@@ -123,7 +123,7 @@ DEF_TEST(RecordDraw_SetMatrixClobber, r) {
 }
 
 struct TestBBH : public SkBBoxHierarchy {
-    void insert(const SkRect boundsArray[], int N) SK_OVERRIDE {
+    void insert(const SkRect boundsArray[], int N) override {
         fEntries.setCount(N);
         for (int i = 0; i < N; i++) {
             Entry e = { (unsigned)i, boundsArray[i] };
@@ -131,9 +131,9 @@ struct TestBBH : public SkBBoxHierarchy {
         }
     }
 
-    void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE {}
-    size_t bytesUsed() const SK_OVERRIDE { return 0; }
-    SkRect getRootBound() const SK_OVERRIDE { return SkRect::MakeEmpty(); }
+    void search(const SkRect& query, SkTDArray<unsigned>* results) const override {}
+    size_t bytesUsed() const override { return 0; }
+    SkRect getRootBound() const override { return SkRect::MakeEmpty(); }
 
     struct Entry {
         unsigned opIndex;
@@ -290,12 +290,12 @@ DEF_TEST(RecordDraw_drawImage, r){
         }
 
         void onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
-                         const SkPaint* paint) SK_OVERRIDE {
+                         const SkPaint* paint) override {
             fDrawImageCalled = true;
         }
 
         void onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
-                             const SkPaint* paint) SK_OVERRIDE {
+                             const SkPaint* paint) override {
             fDrawImageRectCalled = true;
         }
 
diff --git a/tests/RecordReplaceDrawTest.cpp b/tests/RecordReplaceDrawTest.cpp
index 55f47cee6c..41da9a1b5c 100644
--- a/tests/RecordReplaceDrawTest.cpp
+++ b/tests/RecordReplaceDrawTest.cpp
@@ -26,7 +26,7 @@ class JustOneDraw : public SkPicture::AbortCallback {
 public:
     JustOneDraw() : fCalls(0) {}
 
-    bool abort() SK_OVERRIDE { return fCalls++ > 0; }
+    bool abort() override { return fCalls++ > 0; }
 private:
     int fCalls;
 };
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index b6e1eb7c89..737d7432b1 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -248,7 +248,7 @@ private:
         this->registerWithCache();
     }
 
-    size_t onGpuMemorySize() const SK_OVERRIDE { return fSize; }
+    size_t onGpuMemorySize() const override { return fSize; }
 
     TestResource* fToDelete;
     size_t fSize;
diff --git a/tests/SkpSkGrTest.cpp b/tests/SkpSkGrTest.cpp
index c2f1a798d6..2c3c5b7fbf 100644
--- a/tests/SkpSkGrTest.cpp
+++ b/tests/SkpSkGrTest.cpp
@@ -146,7 +146,7 @@ public:
         fTestFun = testFun;
     }
 
-    void run() SK_OVERRIDE {
+    void run() override {
         SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024);
         (*fTestFun)(&fState);
     }
diff --git a/tests/skia_test.cpp b/tests/skia_test.cpp
index 74029d457b..1b92290808 100644
--- a/tests/skia_test.cpp
+++ b/tests/skia_test.cpp
@@ -84,12 +84,12 @@ public:
       struct TestReporter : public skiatest::Reporter {
       public:
           TestReporter() : fError(false), fTestCount(0) {}
-          void bumpTestCount() SK_OVERRIDE { ++fTestCount; }
-          bool allowExtendedTest() const SK_OVERRIDE {
+          void bumpTestCount() override { ++fTestCount; }
+          bool allowExtendedTest() const override {
               return FLAGS_extendedTest;
           }
-          bool verbose() const SK_OVERRIDE { return FLAGS_veryVerbose; }
-          void reportFailed(const skiatest::Failure& failure) SK_OVERRIDE {
+          bool verbose() const override { return FLAGS_veryVerbose; }
+          void reportFailed(const skiatest::Failure& failure) override {
               SkDebugf("\nFAILED: %s", failure.toString().c_str());
               fError = true;
           }