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

src/gpu/effects/GrPorterDuffXferProcessor.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrPorterDuffXferProcessor.h"
 
 #include "GrBlend.h"
@@ skipping 23 matching lines @@
 
 class PorterDuffXferProcessor : public GrXferProcessor {
 public:
     static GrXferProcessor* Create(GrBlendCoeff srcBlend, GrBlendCoeff dstBlend,
                                    GrColor constant, const GrDeviceCoordTexture* dstCopy,
                                    bool willReadDstColor) {
         return SkNEW_ARGS(PorterDuffXferProcessor, (srcBlend, dstBlend, constant, dstCopy,
                                                     willReadDstColor));
     }
 
-    ~PorterDuffXferProcessor() SK_OVERRIDE;
+    ~PorterDuffXferProcessor() override;
 
-    const char* name() const SK_OVERRIDE { return "Porter Duff"; }
+    const char* name() const override { return "Porter Duff"; }
 
-    GrGLXferProcessor* createGLInstance() const SK_OVERRIDE;
+    GrGLXferProcessor* createGLInstance() const override;
 
-    bool hasSecondaryOutput() const SK_OVERRIDE;
+    bool hasSecondaryOutput() const override;
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Stage Output Types
     ////
 
     enum PrimaryOutputType {
         kNone_PrimaryOutputType,
         kColor_PrimaryOutputType,
         kCoverage_PrimaryOutputType,
         // Modulate color and coverage, write result as the color output.
@@ skipping 20 matching lines @@
         kSecondaryOutputTypeCnt,
     };
 
     PrimaryOutputType primaryOutputType() const { return fPrimaryOutputType; }
     SecondaryOutputType secondaryOutputType() const { return fSecondaryOutputType; }
 
     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 {
         if (!this->willReadDstColor()) {
             blendInfo->fSrcBlend = fSrcBlend;
             blendInfo->fDstBlend = fDstBlend;
         } else {
             blendInfo->fSrcBlend = kOne_GrBlendCoeff;
             blendInfo->fDstBlend = kZero_GrBlendCoeff;
         }
         blendInfo->fBlendConstant = fBlendConstant;
     }
 
     GrBlendCoeff getSrcBlend() const { return fSrcBlend; }
     GrBlendCoeff getDstBlend() const { return fDstBlend; }
 
 private:
     PorterDuffXferProcessor(GrBlendCoeff srcBlend, GrBlendCoeff dstBlend, GrColor constant,
                             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 {
         const PorterDuffXferProcessor& xp = xpBase.cast<PorterDuffXferProcessor>();
         if (fSrcBlend != xp.fSrcBlend ||
             fDstBlend != xp.fDstBlend ||
             fBlendConstant != xp.fBlendConstant ||
             fPrimaryOutputType != xp.fPrimaryOutputType || 
             fSecondaryOutputType != xp.fSecondaryOutputType) {
             return false;
         }
         return true;
     }
@@ skipping 71 matching lines @@
         const PorterDuffXferProcessor& xp = processor.cast<PorterDuffXferProcessor>();
         b->add32(xp.primaryOutputType());
         b->add32(xp.secondaryOutputType());
         if (xp.willReadDstColor()) {
             b->add32(xp.getSrcBlend());
             b->add32(xp.getDstBlend());
         }
     };
 
 private:
-    void onEmitCode(const EmitArgs& args) SK_OVERRIDE {
+    void onEmitCode(const EmitArgs& args) override {
         const PorterDuffXferProcessor& xp = args.fXP.cast<PorterDuffXferProcessor>();
         GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
         if (PorterDuffXferProcessor::kCustom_PrimaryOutputType != xp.primaryOutputType()) {
             SkASSERT(!xp.willReadDstColor());
             switch(xp.secondaryOutputType()) {
                 case PorterDuffXferProcessor::kNone_SecondaryOutputType:
                     break;
                 case PorterDuffXferProcessor::kCoverage_SecondaryOutputType:
                     fsBuilder->codeAppendf("%s = %s;", args.fOutputSecondary,
                                            args.fInputCoverage);
@@ skipping 44 matching lines @@
                                                   dstColor, args.fInputColor,
                                                   dstColor, didAppend));
             fsBuilder->codeAppend(";");
 
             fsBuilder->codeAppendf("%s = %s * colorBlend + (vec4(1.0) - %s) * %s;",
                                    args.fOutputPrimary, args.fInputCoverage, args.fInputCoverage,
                                    dstColor);
         }
     }
 
-    void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {};
+    void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {};
 
     typedef GrGLXferProcessor INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 PorterDuffXferProcessor::PorterDuffXferProcessor(GrBlendCoeff srcBlend,
                                                  GrBlendCoeff dstBlend,
                                                  GrColor constant,
                                                  const GrDeviceCoordTexture* dstCopy,
@@ skipping 419 matching lines @@
 GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
 GrXPFactory* GrPorterDuffXPFactory::TestCreate(SkRandom* random,
                                                GrContext*,
                                                const GrDrawTargetCaps&,
                                                GrTexture*[]) {
     SkXfermode::Mode mode = SkXfermode::Mode(random->nextULessThan(SkXfermode::kLastCoeffMode));
     return GrPorterDuffXPFactory::Create(mode);
 }