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

src/core/SkStream.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkStream.h"
@@ skipping 656 matching lines @@
 class SkBlockMemoryStream : public SkStreamAsset {
 public:
     SkBlockMemoryStream(SkDynamicMemoryWStream::Block* head, size_t size)
         : fBlockMemory(SkNEW_ARGS(SkBlockMemoryRefCnt, (head))), fCurrent(head)
         , fSize(size) , fOffset(0), fCurrentOffset(0) { }
 
     SkBlockMemoryStream(SkBlockMemoryRefCnt* headRef, size_t size)
         : fBlockMemory(SkRef(headRef)), fCurrent(fBlockMemory->fHead)
         , fSize(size) , fOffset(0), fCurrentOffset(0) { }
 
-    virtual size_t read(void* buffer, size_t rawCount) SK_OVERRIDE {
+    size_t read(void* buffer, size_t rawCount) SK_OVERRIDE {
         size_t count = rawCount;
         if (fOffset + count > fSize) {
             count = fSize - fOffset;
         }
         size_t bytesLeftToRead = count;
         while (fCurrent != NULL) {
             size_t bytesLeftInCurrent = fCurrent->written() - fCurrentOffset;
             size_t bytesFromCurrent = SkTMin(bytesLeftToRead, bytesLeftInCurrent);
             if (buffer) {
                 memcpy(buffer, fCurrent->start() + fCurrentOffset, bytesFromCurrent);
                 buffer = SkTAddOffset<void>(buffer, bytesFromCurrent);
             }
             if (bytesLeftToRead <= bytesFromCurrent) {
                 fCurrentOffset += bytesFromCurrent;
                 fOffset += count;
                 return count;
             }
             bytesLeftToRead -= bytesFromCurrent;
             fCurrent = fCurrent->fNext;
             fCurrentOffset = 0;
         }
         SkASSERT(false);
         return 0;
     }
 
-    virtual bool isAtEnd() const SK_OVERRIDE {
+    bool isAtEnd() const SK_OVERRIDE {
         return fOffset == fSize;
     }
 
-    virtual bool rewind() SK_OVERRIDE {
+    bool rewind() SK_OVERRIDE {
         fCurrent = fBlockMemory->fHead;
         fOffset = 0;
         fCurrentOffset = 0;
         return true;
     }
 
-    virtual SkBlockMemoryStream* duplicate() const SK_OVERRIDE {
+    SkBlockMemoryStream* duplicate() const SK_OVERRIDE {
         return SkNEW_ARGS(SkBlockMemoryStream, (fBlockMemory.get(), fSize));
     }
 
-    virtual size_t getPosition() const SK_OVERRIDE {
+    size_t getPosition() const SK_OVERRIDE {
         return fOffset;
     }
 
-    virtual bool seek(size_t position) SK_OVERRIDE {
+    bool seek(size_t position) SK_OVERRIDE {
         // If possible, skip forward.
         if (position >= fOffset) {
             size_t skipAmount = position - fOffset;
             return this->skip(skipAmount) == skipAmount;
         }
         // If possible, move backward within the current block.
         size_t moveBackAmount = fOffset - position;
         if (moveBackAmount <= fCurrentOffset) {
             fCurrentOffset -= moveBackAmount;
             fOffset -= moveBackAmount;
             return true;
         }
         // Otherwise rewind and move forward.
         return this->rewind() && this->skip(position) == position;
     }
 
-    virtual bool move(long offset) SK_OVERRIDE {
+    bool move(long offset) SK_OVERRIDE {
         return seek(fOffset + offset);
     }
 
-    virtual SkBlockMemoryStream* fork() const SK_OVERRIDE {
+    SkBlockMemoryStream* fork() const SK_OVERRIDE {
         SkAutoTUnref<SkBlockMemoryStream> that(this->duplicate());
         that->fCurrent = this->fCurrent;
         that->fOffset = this->fOffset;
         that->fCurrentOffset = this->fCurrentOffset;
         return that.detach();
     }
 
-    virtual size_t getLength() const SK_OVERRIDE {
+    size_t getLength() const SK_OVERRIDE {
         return fSize;
     }
 
-    virtual const void* getMemoryBase() SK_OVERRIDE {
+    const void* getMemoryBase() SK_OVERRIDE {
         if (NULL == fBlockMemory->fHead->fNext) {
             return fBlockMemory->fHead->start();
         }
         return NULL;
     }
 
 private:
     SkAutoTUnref<SkBlockMemoryRefCnt> const fBlockMemory;
     SkDynamicMemoryWStream::Block const * fCurrent;
     size_t const fSize;
@@ skipping 136 matching lines @@
     SkDynamicMemoryWStream tempStream;
     const size_t bufferSize = 4096;
     char buffer[bufferSize];
     do {
         size_t bytesRead = stream->read(buffer, bufferSize);
         tempStream.write(buffer, bytesRead);
     } while (!stream->isAtEnd());
     return tempStream.detachAsStream();  // returns a SkBlockMemoryStream,
                                          // cheaper than copying to SkData
 }