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

src/effects/gradients/SkGradientShaderPriv.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGradientShaderPriv_DEFINED
 #define SkGradientShaderPriv_DEFINED
 
@@ skipping 148 matching lines @@
 
         static void Build16bitCache(uint16_t[], SkColor c0, SkColor c1, int count);
         static void Build32bitCache(SkPMColor[], SkColor c0, SkColor c1, int count,
                                     U8CPU alpha, uint32_t gradFlags);
     };
 
     class GradientShaderBaseContext : public SkShader::Context {
     public:
         GradientShaderBaseContext(const SkGradientShaderBase& shader, const ContextRec&);
 
-        uint32_t getFlags() const SK_OVERRIDE { return fFlags; }
+        uint32_t getFlags() const override { return fFlags; }
 
     protected:
         SkMatrix    fDstToIndex;
         SkMatrix::MapXYProc fDstToIndexProc;
         uint8_t     fDstToIndexClass;
         uint8_t     fFlags;
 
         SkAutoTUnref<GradientShaderCache> fCache;
 
     private:
         typedef SkShader::Context INHERITED;
     };
 
-    bool isOpaque() const SK_OVERRIDE;
+    bool isOpaque() const override;
 
     void getGradientTableBitmap(SkBitmap*) const;
 
     enum {
         /// Seems like enough for visual accuracy. TODO: if pos[] deserves
         /// it, use a larger cache.
         kCache16Bits    = 8,
         kCache16Count = (1 << kCache16Bits),
         kCache16Shift   = 16 - kCache16Bits,
         kSqrt16Shift    = 8 - kCache16Bits,
@@ skipping 19 matching lines @@
 
     // Determines and returns the gradient is a two color gradient, symmetric three color gradient
     // or other (texture gradient). If it is two or symmetric three color, the colors array will
     // also be filled with the gradient colors
     GpuColorType getGpuColorType(SkColor colors[3]) const;
 
     uint32_t getGradFlags() const { return fGradFlags; }
 
 protected:
     SkGradientShaderBase(SkReadBuffer& );
-    void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+    void flatten(SkWriteBuffer&) const override;
     SK_TO_STRING_OVERRIDE()
 
     const SkMatrix fPtsToUnit;
     TileMode    fTileMode;
     TileProc    fTileProc;
     int         fColorCount;
     uint8_t     fGradFlags;
 
     struct Rec {
         SkFixed     fPos;   // 0...1
         uint32_t    fScale; // (1 << 24) / range
     };
     Rec*        fRecs;
 
     void commonAsAGradient(GradientInfo*, bool flipGrad = false) const;
 
-    bool onAsLuminanceColor(SkColor*) const SK_OVERRIDE;
+    bool onAsLuminanceColor(SkColor*) const override;
 
     /*
      * Takes in pointers to gradient color and Rec info as colorSrc and recSrc respectively.
      * Count is the number of colors in the gradient
      * It will then flip all the color and rec information and return in their respective Dst
      * pointers. It is assumed that space has already been allocated for the Dst pointers.
      * The rec src and dst are only assumed to be valid if count > 2
      */
     static void FlipGradientColors(SkColor* colorDst, Rec* recDst,
                                    SkColor* colorSrc, Rec* recSrc,
@@ skipping 110 matching lines @@
         sized to be at least kMaxRandomGradientColors. stops is a pointer to an array of at least
         size kMaxRandomGradientColors. It may be updated to NULL, indicating that NULL should be
         passed to the gradient factory rather than the array.
     */
     static const int kMaxRandomGradientColors = 4;
     static int RandomGradientParams(SkRandom* r,
                                     SkColor colors[kMaxRandomGradientColors],
                                     SkScalar** stops,
                                     SkShader::TileMode* tm);
 
-    bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+    bool onIsEqual(const GrFragmentProcessor&) const override;
 
-    void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
     const GrCoordTransform& getCoordTransform() const { return fCoordTransform; }
 
 private:
     static const GrCoordSet kCoordSet = kLocal_GrCoordSet;
 
     GrCoordTransform fCoordTransform;
     GrTextureAccess fTextureAccess;
     SkScalar fYCoord;
     GrTextureStripAtlas* fAtlas;
     int fRow;
     bool fIsOpaque;
     SkGradientShaderBase::GpuColorType fColorType;
     SkColor fColors[3]; // More than 3 colors we use texture
     PremulType fPremulType; // This only changes behavior for two and three color special cases.
                             // It is already baked into to the table for texture gradients.
     typedef GrFragmentProcessor INHERITED;
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Base class for GL gradient effects
 class GrGLGradientEffect : public GrGLFragmentProcessor {
 public:
     GrGLGradientEffect();
     virtual ~GrGLGradientEffect();
 
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 protected:
     /**
      * Subclasses must call this. It will return a key for the part of the shader code controlled
      * by the base class. The subclasses must stick it in their key and then pass it to the below
      * emit* functions from their emitCode function.
      */
     static uint32_t GenBaseGradientKey(const GrProcessor&);
 
     // Emits the uniform used as the y-coord to texture samples in derived classes. Subclasses
@@ skipping 33 matching lines @@
     GrGLProgramDataManager::UniformHandle fColorStartUni;
     GrGLProgramDataManager::UniformHandle fColorMidUni;
     GrGLProgramDataManager::UniformHandle fColorEndUni;
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 #endif
 
 #endif