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

include/core/SkStream.h

 /*
  * 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.
  */
 
 #ifndef SkStream_DEFINED
 #define SkStream_DEFINED
 
@@ skipping 115 matching lines @@
     //TODO: replace with virtual const SkData* getData()
     virtual const void* getMemoryBase() { return NULL; }
 
 private:
     typedef SkRefCnt INHERITED;
 };
 
 /** SkStreamRewindable is a SkStream for which rewind and duplicate are required. */
 class SK_API SkStreamRewindable : public SkStream {
 public:
-    virtual bool rewind() SK_OVERRIDE = 0;
-    virtual SkStreamRewindable* duplicate() const SK_OVERRIDE = 0;
+    bool rewind() SK_OVERRIDE = 0;
+    SkStreamRewindable* duplicate() const SK_OVERRIDE = 0;
 };
 
 /** SkStreamSeekable is a SkStreamRewindable for which position, seek, move, and fork are required. */
 class SK_API SkStreamSeekable : public SkStreamRewindable {
 public:
-    virtual SkStreamSeekable* duplicate() const SK_OVERRIDE = 0;
+    SkStreamSeekable* duplicate() const SK_OVERRIDE = 0;
 
-    virtual bool hasPosition() const SK_OVERRIDE { return true; }
-    virtual size_t getPosition() const SK_OVERRIDE = 0;
-    virtual bool seek(size_t position) SK_OVERRIDE = 0;
-    virtual bool move(long offset) SK_OVERRIDE = 0;
-    virtual SkStreamSeekable* fork() const SK_OVERRIDE = 0;
+    bool hasPosition() const SK_OVERRIDE { return true; }
+    size_t getPosition() const SK_OVERRIDE = 0;
+    bool seek(size_t position) SK_OVERRIDE = 0;
+    bool move(long offset) SK_OVERRIDE = 0;
+    SkStreamSeekable* fork() const SK_OVERRIDE = 0;
 };
 
 /** SkStreamAsset is a SkStreamSeekable for which getLength is required. */
 class SK_API SkStreamAsset : public SkStreamSeekable {
 public:
-    virtual SkStreamAsset* duplicate() const SK_OVERRIDE = 0;
-    virtual SkStreamAsset* fork() const SK_OVERRIDE = 0;
+    SkStreamAsset* duplicate() const SK_OVERRIDE = 0;
+    SkStreamAsset* fork() const SK_OVERRIDE = 0;
 
-    virtual bool hasLength() const SK_OVERRIDE { return true; }
-    virtual size_t getLength() const SK_OVERRIDE = 0;
+    bool hasLength() const SK_OVERRIDE { return true; }
+    size_t getLength() const SK_OVERRIDE = 0;
 };
 
 /** SkStreamMemory is a SkStreamAsset for which getMemoryBase is required. */
 class SK_API SkStreamMemory : public SkStreamAsset {
 public:
-    virtual SkStreamMemory* duplicate() const SK_OVERRIDE = 0;
-    virtual SkStreamMemory* fork() const SK_OVERRIDE = 0;
+    SkStreamMemory* duplicate() const SK_OVERRIDE = 0;
+    SkStreamMemory* fork() const SK_OVERRIDE = 0;
 
-    virtual const void* getMemoryBase() SK_OVERRIDE = 0;
+    const void* getMemoryBase() SK_OVERRIDE = 0;
 };
 
 class SK_API SkWStream : SkNoncopyable {
 public:
     SK_DECLARE_INST_COUNT_ROOT(SkWStream)
 
     virtual ~SkWStream();
 
     /** Called to write bytes to a SkWStream. Returns true on success
         @param buffer the address of at least size bytes to be written to the stream
@@ skipping 62 matching lines @@
     virtual ~SkFILEStream();
 
     /** Returns true if the current path could be opened. */
     bool isValid() const { return fFILE != NULL; }
 
     /** Close the current file, and open a new file with the specified path.
      *  If path is NULL, just close the current file.
      */
     void setPath(const char path[]);
 
-    virtual size_t read(void* buffer, size_t size) SK_OVERRIDE;
-    virtual bool isAtEnd() const SK_OVERRIDE;
+    size_t read(void* buffer, size_t size) SK_OVERRIDE;
+    bool isAtEnd() const SK_OVERRIDE;
 
-    virtual bool rewind() SK_OVERRIDE;
-    virtual SkStreamAsset* duplicate() const SK_OVERRIDE;
+    bool rewind() SK_OVERRIDE;
+    SkStreamAsset* duplicate() const SK_OVERRIDE;
 
-    virtual size_t getPosition() const SK_OVERRIDE;
-    virtual bool seek(size_t position) SK_OVERRIDE;
-    virtual bool move(long offset) SK_OVERRIDE;
-    virtual SkStreamAsset* fork() const SK_OVERRIDE;
+    size_t getPosition() const SK_OVERRIDE;
+    bool seek(size_t position) SK_OVERRIDE;
+    bool move(long offset) SK_OVERRIDE;
+    SkStreamAsset* fork() const SK_OVERRIDE;
 
-    virtual size_t getLength() const SK_OVERRIDE;
+    size_t getLength() const SK_OVERRIDE;
 
-    virtual const void* getMemoryBase() SK_OVERRIDE;
+    const void* getMemoryBase() SK_OVERRIDE;
 
 private:
     SkFILE*     fFILE;
     SkString    fName;
     Ownership   fOwnership;
     // fData is lazilly initialized when needed.
     mutable SkAutoTUnref<SkData> fData;
 
     typedef SkStreamAsset INHERITED;
 };
@@ skipping 38 matching lines @@
      *  Use the specified data as the memory for this stream.
      *  The stream will call ref() on the data (assuming it is not NULL).
      *  The function returns the data parameter as a convenience.
      */
     SkData* setData(SkData*);
 
     void skipToAlign4();
     const void* getAtPos();
     size_t peek() const { return fOffset; }
 
-    virtual size_t read(void* buffer, size_t size) SK_OVERRIDE;
-    virtual bool isAtEnd() const SK_OVERRIDE;
+    size_t read(void* buffer, size_t size) SK_OVERRIDE;
+    bool isAtEnd() const SK_OVERRIDE;
 
-    virtual bool rewind() SK_OVERRIDE;
-    virtual SkMemoryStream* duplicate() const SK_OVERRIDE;
+    bool rewind() SK_OVERRIDE;
+    SkMemoryStream* duplicate() const SK_OVERRIDE;
 
-    virtual size_t getPosition() const SK_OVERRIDE;
-    virtual bool seek(size_t position) SK_OVERRIDE;
-    virtual bool move(long offset) SK_OVERRIDE;
-    virtual SkMemoryStream* fork() const SK_OVERRIDE;
+    size_t getPosition() const SK_OVERRIDE;
+    bool seek(size_t position) SK_OVERRIDE;
+    bool move(long offset) SK_OVERRIDE;
+    SkMemoryStream* fork() const SK_OVERRIDE;
 
-    virtual size_t getLength() const SK_OVERRIDE;
+    size_t getLength() const SK_OVERRIDE;
 
-    virtual const void* getMemoryBase() SK_OVERRIDE;
+    const void* getMemoryBase() SK_OVERRIDE;
 
 private:
     SkData* fData;
     size_t  fOffset;
 
     typedef SkStreamMemory INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 class SK_API SkFILEWStream : public SkWStream {
 public:
     SK_DECLARE_INST_COUNT(SkFILEWStream)
 
     SkFILEWStream(const char path[]);
     virtual ~SkFILEWStream();
 
     /** Returns true if the current path could be opened.
     */
     bool isValid() const { return fFILE != NULL; }
 
-    virtual bool write(const void* buffer, size_t size) SK_OVERRIDE;
-    virtual void flush() SK_OVERRIDE;
-    virtual size_t bytesWritten() const SK_OVERRIDE;
+    bool write(const void* buffer, size_t size) SK_OVERRIDE;
+    void flush() SK_OVERRIDE;
+    size_t bytesWritten() const SK_OVERRIDE;
 
 private:
     SkFILE* fFILE;
 
     typedef SkWStream INHERITED;
 };
 
 class SkMemoryWStream : public SkWStream {
 public:
     SK_DECLARE_INST_COUNT(SkMemoryWStream)
 
     SkMemoryWStream(void* buffer, size_t size);
-    virtual bool write(const void* buffer, size_t size) SK_OVERRIDE;
-    virtual size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
+    bool write(const void* buffer, size_t size) SK_OVERRIDE;
+    size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
 
 private:
     char*   fBuffer;
     size_t  fMaxLength;
     size_t  fBytesWritten;
 
     typedef SkWStream INHERITED;
 };
 
 class SK_API SkDynamicMemoryWStream : public SkWStream {
 public:
     SK_DECLARE_INST_COUNT(SkDynamicMemoryWStream)
 
     SkDynamicMemoryWStream();
     virtual ~SkDynamicMemoryWStream();
 
-    virtual bool write(const void* buffer, size_t size) SK_OVERRIDE;
-    virtual size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
+    bool write(const void* buffer, size_t size) SK_OVERRIDE;
+    size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
     // random access write
     // modifies stream and returns true if offset + size is less than or equal to getOffset()
     bool write(const void* buffer, size_t offset, size_t size);
     bool read(void* buffer, size_t offset, size_t size);
     size_t getOffset() const { return fBytesWritten; }
 
     // copy what has been written to the stream into dst
     void copyTo(void* dst) const;
 
     /**
@@ skipping 24 matching lines @@
     typedef SkWStream INHERITED;
 };
 
 
 class SK_API SkDebugWStream : public SkWStream {
 public:
     SkDebugWStream() : fBytesWritten(0) {}
     SK_DECLARE_INST_COUNT(SkDebugWStream)
 
     // overrides
-    virtual bool write(const void* buffer, size_t size) SK_OVERRIDE;
-    virtual void newline() SK_OVERRIDE;
-    virtual size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
+    bool write(const void* buffer, size_t size) SK_OVERRIDE;
+    void newline() SK_OVERRIDE;
+    size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
 
 private:
     size_t fBytesWritten;
     typedef SkWStream INHERITED;
 };
 
 // for now
 typedef SkFILEStream SkURLStream;
 
 #endif