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

src/core/SkBlitter.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 "SkBlitter.h"
 #include "SkAntiRun.h"
 #include "SkColor.h"
@@ skipping 562 matching lines @@
 class Sk3DShader : public SkShader {
 public:
     Sk3DShader(SkShader* proxy) : fProxy(proxy) {
         SkSafeRef(proxy);
     }
 
     virtual ~Sk3DShader() {
         SkSafeUnref(fProxy);
     }
 
-    virtual size_t contextSize() const SK_OVERRIDE {
+    size_t contextSize() const SK_OVERRIDE {
         size_t size = sizeof(Sk3DShaderContext);
         if (fProxy) {
             size += fProxy->contextSize();
         }
         return size;
     }
 
-    virtual Context* onCreateContext(const ContextRec& rec, void* storage) const SK_OVERRIDE {
+    Context* onCreateContext(const ContextRec& rec, void* storage) const SK_OVERRIDE {
         SkShader::Context* proxyContext = NULL;
         if (fProxy) {
             char* proxyContextStorage = (char*) storage + sizeof(Sk3DShaderContext);
             proxyContext = fProxy->createContext(rec, proxyContextStorage);
             if (!proxyContext) {
                 return NULL;
             }
         }
         return SkNEW_PLACEMENT_ARGS(storage, Sk3DShaderContext, (*this, rec, proxyContext));
     }
@@ skipping 11 matching lines @@
                 fPMColor = SkPreMultiplyColor(rec.fPaint->getColor());
             }
         }
 
         virtual ~Sk3DShaderContext() {
             if (fProxyContext) {
                 fProxyContext->~Context();
             }
         }
 
-        virtual void set3DMask(const SkMask* mask) SK_OVERRIDE { fMask = mask; }
+        void set3DMask(const SkMask* mask) SK_OVERRIDE { fMask = mask; }
 
-        virtual void shadeSpan(int x, int y, SkPMColor span[], int count) SK_OVERRIDE {
+        void shadeSpan(int x, int y, SkPMColor span[], int count) SK_OVERRIDE {
             if (fProxyContext) {
                 fProxyContext->shadeSpan(x, y, span, count);
             }
 
             if (fMask == NULL) {
                 if (fProxyContext == NULL) {
                     sk_memset32(span, fPMColor, count);
                 }
                 return;
             }
@@ skipping 54 matching lines @@
         // Unowned.
         const SkMask*       fMask;
         // Memory is unowned, but we need to call the destructor.
         SkShader::Context*  fProxyContext;
         SkPMColor           fPMColor;
 
         typedef SkShader::Context INHERITED;
     };
 
 #ifndef SK_IGNORE_TO_STRING
-    virtual void toString(SkString* str) const SK_OVERRIDE {
+    void toString(SkString* str) const SK_OVERRIDE {
         str->append("Sk3DShader: (");
 
         if (fProxy) {
             str->append("Proxy: ");
             fProxy->toString(str);
         }
 
         this->INHERITED::toString(str);
 
         str->append(")");
     }
 #endif
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Sk3DShader)
 
 protected:
-    virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+    void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
         buffer.writeFlattenable(fProxy);
     }
 
 private:
     SkShader*       fProxy;
 
     typedef SkShader INHERITED;
 };
 
 SkFlattenable* Sk3DShader::CreateProc(SkReadBuffer& buffer) {
     SkAutoTUnref<SkShader> shader(buffer.readShader());
     return SkNEW_ARGS(Sk3DShader, (shader));
 }
 
 class Sk3DBlitter : public SkBlitter {
 public:
     Sk3DBlitter(SkBlitter* proxy, SkShader::Context* shaderContext)
         : fProxy(proxy)
         , fShaderContext(shaderContext)
     {}
 
-    virtual void blitH(int x, int y, int width) SK_OVERRIDE {
+    void blitH(int x, int y, int width) SK_OVERRIDE {
         fProxy->blitH(x, y, width);
     }
 
     virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
                            const int16_t runs[]) SK_OVERRIDE {
         fProxy->blitAntiH(x, y, antialias, runs);
     }
 
-    virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
+    void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
         fProxy->blitV(x, y, height, alpha);
     }
 
-    virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+    void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
         fProxy->blitRect(x, y, width, height);
     }
 
-    virtual void blitMask(const SkMask& mask, const SkIRect& clip) SK_OVERRIDE {
+    void blitMask(const SkMask& mask, const SkIRect& clip) SK_OVERRIDE {
         if (mask.fFormat == SkMask::k3D_Format) {
             fShaderContext->set3DMask(&mask);
 
             ((SkMask*)&mask)->fFormat = SkMask::kA8_Format;
             fProxy->blitMask(mask, clip);
             ((SkMask*)&mask)->fFormat = SkMask::k3D_Format;
 
             fShaderContext->set3DMask(NULL);
         } else {
             fProxy->blitMask(mask, clip);
@@ skipping 217 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkTransparentShaderContext : public SkShader::Context {
 public:
     SkTransparentShaderContext(const SkShader& shader, const SkShader::ContextRec& rec)
         // Override rec with the identity matrix, so it is guaranteed to be invertible.
         : INHERITED(shader, SkShader::ContextRec(*rec.fDevice, *rec.fPaint, SkMatrix::I())) {}
 
-    virtual void shadeSpan(int x, int y, SkPMColor colors[], int count) SK_OVERRIDE {
+    void shadeSpan(int x, int y, SkPMColor colors[], int count) SK_OVERRIDE {
         sk_bzero(colors, count * sizeof(SkPMColor));
     }
 
 private:
     typedef SkShader::Context INHERITED;
 };
 
 SkShaderBlitter::SkShaderBlitter(const SkBitmap& device, const SkPaint& paint,
                                  SkShader::Context* shaderContext)
         : INHERITED(device)
@@ skipping 19 matching lines @@
     fShaderContext->~Context();
     SkShader::Context* ctx = fShader->createContext(rec, (void*)fShaderContext);
     if (NULL == ctx) {
         // Need a valid context in fShaderContext's storage, so we can later (or our caller) call
         // the in-place destructor.
         SkNEW_PLACEMENT_ARGS(fShaderContext, SkTransparentShaderContext, (*fShader, rec));
         return false;
     }
     return true;
 }