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

src/utils/SkTextureCompressor_Blitter.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTextureCompressor_Blitter_DEFINED
 #define SkTextureCompressor_Blitter_DEFINED
 
@@ skipping 67 matching lines @@
         , fHeight(height)
         , fBuffer(compressedBuffer)
         {
             SkASSERT((width % BlockDim) == 0);
             SkASSERT((height % BlockDim) == 0);
         }
 
     virtual ~SkTCompressedAlphaBlitter() { this->flushRuns(); }
 
     // Blit a horizontal run of one or more pixels.
-    virtual void blitH(int x, int y, int width) SK_OVERRIDE {
+    void blitH(int x, int y, int width) SK_OVERRIDE {
         // This function is intended to be called from any standard RGB
         // buffer, so we should never encounter it. However, if some code
         // path does end up here, then this needs to be investigated.
         SkFAIL("Not implemented!");
     }
     
     // Blit a horizontal run of antialiased pixels; runs[] is a *sparse*
     // zero-terminated run-length encoding of spans of constant alpha values.
     virtual void blitAntiH(int x, int y,
                            const SkAlpha antialias[],
@@ skipping 35 matching lines @@
         fBufferedRuns[fNextRun].fY = y;
 
         // If we've output a block of scanlines in a row that don't violate our
         // assumptions, then it's time to flush them...
         if (BlockDim == ++fNextRun) {
             this->flushRuns();
         }
     }
     
     // Blit a vertical run of pixels with a constant alpha value.
-    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 {
         // This function is currently not implemented. It is not explicitly
         // required by the contract, but if at some time a code path runs into
         // this function (which is entirely possible), it needs to be implemented.
         //
         // TODO (krajcevski):
         // This function will be most easily implemented in one of two ways:
         // 1. Buffer each vertical column value and then construct a list
         //    of alpha values and output all of the blocks at once. This only
         //    requires a write to the compressed buffer
         // 2. Replace the indices of each block with the proper indices based
         //    on the alpha value. This requires a read and write of the compressed
         //    buffer, but much less overhead.
         SkFAIL("Not implemented!");
     }
 
     // Blit a solid rectangle one or more pixels wide. It's assumed that blitRect
     // is called as a way to bracket blitAntiH where above and below the path the
     // called path just needs a solid rectangle to fill in the mask.
 #ifdef SK_DEBUG
     bool fCalledOnceWithNonzeroY;
 #endif
-    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 {
 
         // Assumptions:
         SkASSERT(0 == x);
         SkASSERT(width <= fWidth);
 
         // Make sure that we're only ever bracketing calls to blitAntiH.
         SkASSERT((0 == y) || (!fCalledOnceWithNonzeroY && (fCalledOnceWithNonzeroY = true)));
         
 #if !(PEDANTIC_BLIT_RECT)
         for (int i = 0; i < height; ++i) {
@@ skipping 122 matching lines @@
     // Blit a pattern of pixels defined by a rectangle-clipped mask; We make an
     // assumption here that if this function gets called, then it will replace all
     // of the compressed texture blocks that it touches. Hence, two separate calls
     // to blitMask that have clips next to one another will cause artifacts. Most
     // of the time, however, this function gets called because constructing the mask
     // was faster than constructing the RLE for blitAntiH, and this function will
     // only be called once.
 #ifdef SK_DEBUG
     bool fBlitMaskCalled;
 #endif
-    virtual void blitMask(const SkMask& mask, const SkIRect& clip) SK_OVERRIDE {
+    void blitMask(const SkMask& mask, const SkIRect& clip) SK_OVERRIDE {
 
         // Assumptions:
         SkASSERT(!fBlitMaskCalled);
         SkDEBUGCODE(fBlitMaskCalled = true);
         SkASSERT(SkMask::kA8_Format == mask.fFormat);
         SkASSERT(mask.fBounds.contains(clip));
 
         // Start from largest block boundary less than the clip boundaries.
         const int startI = BlockDim * (clip.left() / BlockDim);
         const int startJ = BlockDim * (clip.top() / BlockDim);
@@ skipping 41 matching lines @@
                 }
 
                 dst += EncodedBlockSize;
             }
         }
     }
 
     // If the blitter just sets a single value for each pixel, return the
     // bitmap it draws into, and assign value. If not, return NULL and ignore
     // the value parameter.
-    virtual const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE {
+    const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE {
         return NULL;
     }
 
     /**
      * Compressed texture blitters only really work correctly if they get
      * BlockDim rows at a time. That being said, this blitter tries it's best
      * to preserve semantics if blitAntiH doesn't get called in too many
      * weird ways...
      */
-    virtual int requestRowsPreserved() const SK_OVERRIDE { return BlockDim; }
+    int requestRowsPreserved() const SK_OVERRIDE { return BlockDim; }
 
 private:
     static const int kPixelsPerBlock = BlockDim * BlockDim;
 
     // The longest possible run of pixels that this blitter will receive.
     // This is initialized in the constructor to 0x7FFE, which is one less
     // than the largest positive 16-bit integer. We make sure that it's one
     // less for debugging purposes. We also don't make this variable static
     // in order to make sure that we can construct a valid pointer to it.
     const int16_t kLongestRun;
@@ skipping 332 matching lines @@
                                         mask, BlockDim, mask);
         }
     }
 #endif  // PEDANTIC_BLIT_RECT
 
 };
 
 }  // namespace SkTextureCompressor
 
 #endif  // SkTextureCompressor_Blitter_DEFINED