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

src/gpu/effects/GrCustomXfermode.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrCustomXfermode.h"
 #include "effects/GrCustomXfermodePriv.h"
 
@@ skipping 389 matching lines @@
     } else {
         return SkNEW_ARGS(GrCustomXferFP, (mode, background));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GLCustomXferFP : public GrGLFragmentProcessor {
 public:
     GLCustomXferFP(const GrFragmentProcessor&) {}
-    ~GLCustomXferFP() SK_OVERRIDE {};
+    ~GLCustomXferFP() override {};
 
     void emitCode(GrGLFPBuilder* builder,
                   const GrFragmentProcessor& fp,
                   const char* outputColor,
                   const char* inputColor,
                   const TransformedCoordsArray& coords,
-                  const TextureSamplerArray& samplers) SK_OVERRIDE {
+                  const TextureSamplerArray& samplers) override {
         SkXfermode::Mode mode = fp.cast<GrCustomXferFP>().mode();
         GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
         const char* dstColor = "bgColor";
         fsBuilder->codeAppendf("vec4 %s = ", dstColor);
         fsBuilder->appendTextureLookup(samplers[0], coords[0].c_str(), coords[0].getType());
         fsBuilder->codeAppendf(";");
 
         emit_custom_xfermode_code(mode, fsBuilder, outputColor, inputColor, dstColor); 
     }
 
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE {}
+    void setData(const GrGLProgramDataManager&, const GrProcessor&) override {}
 
     static void GenKey(const GrFragmentProcessor& proc, const GrGLCaps&, GrProcessorKeyBuilder* b) {
         // The background may come from the dst or from a texture.
         uint32_t key = proc.numTextures();
         SkASSERT(key <= 1);
         key |= proc.cast<GrCustomXferFP>().mode() << 1;
         b->add32(key);
     }
 
 private:
@@ skipping 49 matching lines @@
 public:
     static GrXferProcessor* Create(SkXfermode::Mode mode, const GrDeviceCoordTexture* dstCopy,
                                    bool willReadDstColor) {
         if (!GrCustomXfermode::IsSupportedMode(mode)) {
             return NULL;
         } else {
             return SkNEW_ARGS(CustomXP, (mode, dstCopy, willReadDstColor));
         }
     }
 
-    ~CustomXP() SK_OVERRIDE {};
+    ~CustomXP() override {};
 
-    const char* name() const SK_OVERRIDE { return "Custom Xfermode"; }
+    const char* name() const override { return "Custom Xfermode"; }
 
-    GrGLXferProcessor* createGLInstance() const SK_OVERRIDE;
+    GrGLXferProcessor* createGLInstance() const override;
 
-    bool hasSecondaryOutput() const SK_OVERRIDE { return false; }
+    bool hasSecondaryOutput() const override { return false; }
 
     GrXferProcessor::OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
                                                const GrProcOptInfo& coveragePOI,
                                                bool doesStencilWrite,
                                                GrColor* overrideColor,
-                                               const GrDrawTargetCaps& caps) SK_OVERRIDE;
+                                               const GrDrawTargetCaps& caps) override;
 
-    void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const SK_OVERRIDE {
+    void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
         blendInfo->fSrcBlend = kOne_GrBlendCoeff;
         blendInfo->fDstBlend = kZero_GrBlendCoeff;
         blendInfo->fBlendConstant = 0;
     }
 
     SkXfermode::Mode mode() const { return fMode; }
 
 private:
     CustomXP(SkXfermode::Mode mode, const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
 
-    void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+    void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
-    bool onIsEqual(const GrXferProcessor& xpBase) const SK_OVERRIDE;
+    bool onIsEqual(const GrXferProcessor& xpBase) const override;
 
     SkXfermode::Mode fMode;
 
     typedef GrXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrXPFactory* GrCustomXfermode::CreateXPFactory(SkXfermode::Mode mode) {
     if (!GrCustomXfermode::IsSupportedMode(mode)) {
         return NULL;
     } else {
         return SkNEW_ARGS(GrCustomXPFactory, (mode));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GLCustomXP : public GrGLXferProcessor {
 public:
     GLCustomXP(const GrXferProcessor&) {}
-    ~GLCustomXP() SK_OVERRIDE {}
+    ~GLCustomXP() override {}
 
     static void GenKey(const GrXferProcessor& proc, const GrGLCaps&, GrProcessorKeyBuilder* b) {
         uint32_t key = proc.numTextures();
         SkASSERT(key <= 1);
         key |= proc.cast<CustomXP>().mode() << 1;
         b->add32(key);
     }
 
 private:
-    void onEmitCode(const EmitArgs& args) SK_OVERRIDE {
+    void onEmitCode(const EmitArgs& args) override {
         SkXfermode::Mode mode = args.fXP.cast<CustomXP>().mode();
         GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
         const char* dstColor = fsBuilder->dstColor();
 
         emit_custom_xfermode_code(mode, fsBuilder, args.fOutputPrimary, args.fInputColor, dstColor);
 
         fsBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
                                args.fOutputPrimary, args.fOutputPrimary, args.fInputCoverage,
                                args.fInputCoverage, dstColor);
     }
 
-    void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {}
+    void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
 
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CustomXP::CustomXP(SkXfermode::Mode mode, const GrDeviceCoordTexture* dstCopy,
                    bool willReadDstColor)
     : INHERITED(dstCopy, willReadDstColor), fMode(mode) {
     this->initClassID<CustomXP>();
@@ skipping 46 matching lines @@
 GR_DEFINE_XP_FACTORY_TEST(GrCustomXPFactory);
 GrXPFactory* GrCustomXPFactory::TestCreate(SkRandom* rand,
                                            GrContext*,
                                            const GrDrawTargetCaps&,
                                            GrTexture*[]) {
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(GrCustomXPFactory, (static_cast<SkXfermode::Mode>(mode)));
 }