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

tests/FrontBufferedStreamTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkFrontBufferedStream.h"
 #include "SkImageDecoder.h"
@@ skipping 154 matching lines @@
 
 // Dummy stream that optionally has a length and/or position. Tests that FrontBufferedStream's
 // length depends on the stream it's buffering having a length and position.
 class LengthOptionalStream : public SkStream {
 public:
     LengthOptionalStream(bool hasLength, bool hasPosition)
         : fHasLength(hasLength)
         , 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;
     }
 
 private:
     const bool fHasLength;
     const bool fHasPosition;
 };
 
 // Test all possible combinations of the wrapped stream having a length and a position.
 static void test_length_combos(skiatest::Reporter* reporter, size_t bufferSize) {
@@ skipping 56 matching lines @@
 
 // Test that a FrontBufferedStream does not allow reading after the end of a stream.
 // This class is a dummy SkStream which reports that it is at the end on the first
 // read (simulating a failure). Then it tracks whether someone calls read() again.
 class FailingStream : public SkStream {
 public:
     FailingStream()
     : 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 {
             fAtEnd = true;
         }
         return 0;
     }
 
-    virtual bool isAtEnd() const SK_OVERRIDE {
+    bool isAtEnd() const SK_OVERRIDE {
         return fAtEnd;
     }
 
     bool readAfterEnd() const {
         return fReadAfterEnd;
     }
 private:
     bool fAtEnd;
     bool fReadAfterEnd;
 };
 
 DEF_TEST(ShortFrontBufferedStream, reporter) {
     FailingStream failingStream;
     SkAutoTUnref<SkStreamRewindable> stream(SkFrontBufferedStream::Create(&failingStream, 64));
     SkBitmap bm;
     // The return value of DecodeStream is not important. We are just using DecodeStream because
     // it simulates a bug. DecodeStream will read the stream, then rewind, then attempt to read
     // again. FrontBufferedStream::read should not continue to read its underlying stream beyond
     // its end.
     SkImageDecoder::DecodeStream(stream, &bm);
     REPORTER_ASSERT(reporter, !failingStream.readAfterEnd());
 }