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

src/lazy/SkDiscardableMemoryPool.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 "SkDiscardableMemory.h"
 #include "SkDiscardableMemoryPool.h"
 #include "SkImageGenerator.h"
@@ skipping 14 matching lines @@
  *  pool works.
  */
 class DiscardableMemoryPool : public SkDiscardableMemoryPool {
 public:
     /**
      *  Without mutex, will be not be thread safe.
      */
     DiscardableMemoryPool(size_t budget, SkBaseMutex* mutex = NULL);
     virtual ~DiscardableMemoryPool();
 
-    virtual SkDiscardableMemory* create(size_t bytes) SK_OVERRIDE;
+    SkDiscardableMemory* create(size_t bytes) SK_OVERRIDE;
 
-    virtual size_t getRAMUsed() SK_OVERRIDE;
-    virtual void setRAMBudget(size_t budget) SK_OVERRIDE;
-    virtual size_t getRAMBudget() SK_OVERRIDE { return fBudget; }
+    size_t getRAMUsed() SK_OVERRIDE;
+    void setRAMBudget(size_t budget) SK_OVERRIDE;
+    size_t getRAMBudget() SK_OVERRIDE { return fBudget; }
 
     /** purges all unlocked DMs */
-    virtual void dumpPool() SK_OVERRIDE;
+    void dumpPool() SK_OVERRIDE;
 
     #if SK_LAZY_CACHE_STATS  // Defined in SkDiscardableMemoryPool.h
-    virtual int getCacheHits() SK_OVERRIDE { return fCacheHits; }
-    virtual int getCacheMisses() SK_OVERRIDE { return fCacheMisses; }
-    virtual void resetCacheHitsAndMisses() SK_OVERRIDE {
+    int getCacheHits() SK_OVERRIDE { return fCacheHits; }
+    int getCacheMisses() SK_OVERRIDE { return fCacheMisses; }
+    void resetCacheHitsAndMisses() SK_OVERRIDE {
         fCacheHits = fCacheMisses = 0;
     }
     int          fCacheHits;
     int          fCacheMisses;
     #endif  // SK_LAZY_CACHE_STATS
 
 private:
     SkBaseMutex* fMutex;
     size_t       fBudget;
     size_t       fUsed;
@@ skipping 15 matching lines @@
 
 /**
  *  A PoolDiscardableMemory is a SkDiscardableMemory that relies on
  *  a DiscardableMemoryPool object to manage the memory.
  */
 class PoolDiscardableMemory : public SkDiscardableMemory {
 public:
     PoolDiscardableMemory(DiscardableMemoryPool* pool,
                             void* pointer, size_t bytes);
     virtual ~PoolDiscardableMemory();
-    virtual bool lock() SK_OVERRIDE;
-    virtual void* data() SK_OVERRIDE;
-    virtual void unlock() SK_OVERRIDE;
+    bool lock() SK_OVERRIDE;
+    void* data() SK_OVERRIDE;
+    void unlock() SK_OVERRIDE;
     friend class DiscardableMemoryPool;
 private:
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(PoolDiscardableMemory);
     DiscardableMemoryPool* const fPool;
     bool                         fLocked;
     void*                        fPointer;
     const size_t                 fBytes;
 };
 
 PoolDiscardableMemory::PoolDiscardableMemory(DiscardableMemoryPool* pool,
@@ skipping 164 matching lines @@
     return SkNEW_ARGS(DiscardableMemoryPool, (size, mutex));
 }
 
 SK_DECLARE_STATIC_LAZY_PTR(SkDiscardableMemoryPool, global, create_global_pool);
 
 SkDiscardableMemoryPool* SkGetGlobalDiscardableMemoryPool() {
     return global.get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////