C++11 override should now be supported by all of {bots,Chrome,Android,Mozilla}

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.
-    void blitH(int x, int y, int width) SK_OVERRIDE {
+    void blitH(int x, int y, int width) 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[],
-                           const int16_t runs[]) SK_OVERRIDE {
+                           const int16_t runs[]) override {
         SkASSERT(0 == x);
 
         // Make sure that the new row to blit is either the first
         // row that we're blitting, or it's exactly the next scan row
         // since the last row that we blit. This is to ensure that when
         // we go to flush the runs, that they are all the same four
         // runs.
         if (fNextRun > 0 &&
             ((x != fBufferedRuns[fNextRun-1].fX) ||
              (y-1 != fBufferedRuns[fNextRun-1].fY))) {
@@ skipping 24 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.
-    void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
+    void blitV(int x, int y, int height, SkAlpha alpha) 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
-    void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+    void blitRect(int x, int y, int width, int height) 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 95 matching lines @@
                                      startBlockX, endBlockX);
             }
         }
 #endif
     }
 
     // Blit a rectangle with one alpha-blended column on the left,
     // width (zero or more) opaque pixels, and one alpha-blended column
     // on the right. The result will always be at least two pixels wide.
     virtual void blitAntiRect(int x, int y, int width, int height,
-                              SkAlpha leftAlpha, SkAlpha rightAlpha) SK_OVERRIDE {
+                              SkAlpha leftAlpha, SkAlpha rightAlpha) 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 as follows:
         // 1. If width/height are smaller than a block, then update the
         //    indices of the affected blocks.
         // 2. If width/height are larger than a block, then construct a 9-patch
         //    of block encodings that represent the rectangle, and write them
         //    to the compressed buffer as necessary. Whether or not the blocks
         //    are overwritten by zeros or just their indices are updated is up
         //    to debate.
         SkFAIL("Not implemented!");
     }
 
     // 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
-    void blitMask(const SkMask& mask, const SkIRect& clip) SK_OVERRIDE {
+    void blitMask(const SkMask& mask, const SkIRect& clip) 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.
-    const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE {
+    const SkBitmap* justAnOpaqueColor(uint32_t* value) 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...
      */
-    int requestRowsPreserved() const SK_OVERRIDE { return BlockDim; }
+    int requestRowsPreserved() const 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