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

src/effects/SkLightingImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 271 matching lines @@
     static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter*,
                                  const CropRect*);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter)
     SkScalar kd() const { return fKD; }
 
 protected:
     SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
                                  SkScalar kd, SkImageFilter* input, const CropRect* cropRect);
-    void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
+    void flatten(SkWriteBuffer& buffer) const override;
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+                               SkBitmap* result, SkIPoint* offset) const override;
 #if SK_SUPPORT_GPU
     virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
-                                     const SkIRect& bounds) const SK_OVERRIDE;
+                                     const SkIRect& bounds) const override;
 #endif
 
 private:
     friend class SkLightingImageFilter;
     typedef SkLightingImageFilter INHERITED;
     SkScalar fKD;
 };
 
 class SkSpecularLightingImageFilter : public SkLightingImageFilter {
 public:
     static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale,
                                  SkScalar ks, SkScalar shininess, SkImageFilter*, const CropRect*);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter)
 
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
 protected:
     SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks,
                                   SkScalar shininess, SkImageFilter* input, const CropRect*);
-    void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
+    void flatten(SkWriteBuffer& buffer) const override;
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+                               SkBitmap* result, SkIPoint* offset) const override;
 #if SK_SUPPORT_GPU
     virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
-                                     const SkIRect& bounds) const SK_OVERRIDE;
+                                     const SkIRect& bounds) const override;
 #endif
 
 private:
     SkScalar fKS;
     SkScalar fShininess;
     friend class SkLightingImageFilter;
     typedef SkLightingImageFilter INHERITED;
 };
 
 #if SK_SUPPORT_GPU
 
 class GrLightingEffect : public GrSingleTextureEffect {
 public:
     GrLightingEffect(GrTexture* texture, const SkLight* light, SkScalar surfaceScale, const SkMatrix& matrix);
     virtual ~GrLightingEffect();
 
     const SkLight* light() const { return fLight; }
     SkScalar surfaceScale() const { return fSurfaceScale; }
     const SkMatrix& filterMatrix() const { return fFilterMatrix; }
 
 protected:
-    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 {
         // lighting shaders are complicated. We just throw up our hands.
         inout->mulByUnknownFourComponents();
     }
 
 private:
     typedef GrSingleTextureEffect INHERITED;
     const SkLight* fLight;
     SkScalar fSurfaceScale;
     SkMatrix fFilterMatrix;
 };
 
 class GrDiffuseLightingEffect : public GrLightingEffect {
 public:
     static GrFragmentProcessor* Create(GrTexture* texture,
                                        const SkLight* light,
                                        SkScalar surfaceScale,
                                        const SkMatrix& matrix,
                                        SkScalar kd) {
         return SkNEW_ARGS(GrDiffuseLightingEffect, (texture,
                                                     light,
                                                     surfaceScale,
                                                     matrix,
                                                     kd));
     }
 
-    const char* name() const SK_OVERRIDE { return "DiffuseLighting"; }
+    const char* name() const override { return "DiffuseLighting"; }
 
-    void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+    void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
 
-    GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+    GrGLFragmentProcessor* createGLInstance() const override;
 
     SkScalar kd() const { return fKD; }
 
 private:
-    bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+    bool onIsEqual(const GrFragmentProcessor&) const override;
 
     GrDiffuseLightingEffect(GrTexture* texture,
                             const SkLight* light,
                             SkScalar surfaceScale,
                             const SkMatrix& matrix,
                             SkScalar kd);
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
     typedef GrLightingEffect INHERITED;
     SkScalar fKD;
 };
 
 class GrSpecularLightingEffect : public GrLightingEffect {
 public:
     static GrFragmentProcessor* Create(GrTexture* texture,
                                        const SkLight* light,
                                        SkScalar surfaceScale,
                                        const SkMatrix& matrix,
                                        SkScalar ks,
                                        SkScalar shininess) {
         return SkNEW_ARGS(GrSpecularLightingEffect, (texture,
                                                      light,
                                                      surfaceScale,
                                                      matrix,
                                                      ks,
                                                      shininess));
     }
 
-    const char* name() const SK_OVERRIDE { return "SpecularLighting"; }
+    const char* name() const override { return "SpecularLighting"; }
 
-    void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+    void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
 
-    GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+    GrGLFragmentProcessor* createGLInstance() const override;
 
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
 private:
-    bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+    bool onIsEqual(const GrFragmentProcessor&) const override;
 
     GrSpecularLightingEffect(GrTexture* texture,
                              const SkLight* light,
                              SkScalar surfaceScale,
                              const SkMatrix& matrix,
                              SkScalar ks,
                              SkScalar shininess);
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
     typedef GrLightingEffect INHERITED;
@@ skipping 41 matching lines @@
 
     typedef SkRefCnt INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDistantLight : public GrGLLight {
 public:
     virtual ~GrGLDistantLight() {}
     virtual void setData(const GrGLProgramDataManager&,
-                         const SkLight* light) const SK_OVERRIDE;
-    void emitSurfaceToLight(GrGLFPBuilder*, const char* z) SK_OVERRIDE;
+                         const SkLight* light) const override;
+    void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
 
 private:
     typedef GrGLLight INHERITED;
     UniformHandle fDirectionUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLPointLight : public GrGLLight {
 public:
     virtual ~GrGLPointLight() {}
     virtual void setData(const GrGLProgramDataManager&,
-                         const SkLight* light) const SK_OVERRIDE;
-    void emitSurfaceToLight(GrGLFPBuilder*, const char* z) SK_OVERRIDE;
+                         const SkLight* light) const override;
+    void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
 
 private:
     typedef GrGLLight INHERITED;
     UniformHandle fLocationUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpotLight : public GrGLLight {
 public:
     virtual ~GrGLSpotLight() {}
     virtual void setData(const GrGLProgramDataManager&,
-                         const SkLight* light) const SK_OVERRIDE;
-    void emitSurfaceToLight(GrGLFPBuilder*, const char* z) SK_OVERRIDE;
-    void emitLightColor(GrGLFPBuilder*, const char *surfaceToLight) SK_OVERRIDE;
+                         const SkLight* light) const override;
+    void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
+    void emitLightColor(GrGLFPBuilder*, const char *surfaceToLight) override;
 
 private:
     typedef GrGLLight INHERITED;
 
     SkString        fLightColorFunc;
     UniformHandle   fLocationUni;
     UniformHandle   fExponentUni;
     UniformHandle   fCosOuterConeAngleUni;
     UniformHandle   fCosInnerConeAngleUni;
     UniformHandle   fConeScaleUni;
@@ skipping 56 matching lines @@
 class SkDistantLight : public SkLight {
 public:
     SkDistantLight(const SkPoint3& direction, SkColor color)
       : INHERITED(color), fDirection(direction) {
     }
 
     SkPoint3 surfaceToLight(int x, int y, int z, SkScalar surfaceScale) const {
         return fDirection;
     };
     SkPoint3 lightColor(const SkPoint3&) const { return color(); }
-    LightType type() const SK_OVERRIDE { return kDistant_LightType; }
+    LightType type() const override { return kDistant_LightType; }
     const SkPoint3& direction() const { return fDirection; }
-    GrGLLight* createGLLight() const SK_OVERRIDE {
+    GrGLLight* createGLLight() const override {
 #if SK_SUPPORT_GPU
         return SkNEW(GrGLDistantLight);
 #else
         SkDEBUGFAIL("Should not call in GPU-less build");
         return NULL;
 #endif
     }
-    bool requiresFragmentPosition() const SK_OVERRIDE { return false; }
+    bool requiresFragmentPosition() const override { return false; }
 
-    bool isEqual(const SkLight& other) const SK_OVERRIDE {
+    bool isEqual(const SkLight& other) const override {
         if (other.type() != kDistant_LightType) {
             return false;
         }
 
         const SkDistantLight& o = static_cast<const SkDistantLight&>(other);
         return INHERITED::isEqual(other) &&
                fDirection == o.fDirection;
     }
 
     SkDistantLight(SkReadBuffer& buffer) : INHERITED(buffer) {
         fDirection = readPoint3(buffer);
     }
 
 protected:
     SkDistantLight(const SkPoint3& direction, const SkPoint3& color)
       : INHERITED(color), fDirection(direction) {
     }
-    SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
+    SkLight* transform(const SkMatrix& matrix) const override {
         return new SkDistantLight(direction(), color());
     }
-    void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
+    void onFlattenLight(SkWriteBuffer& buffer) const override {
         writePoint3(fDirection, buffer);
     }
 
 private:
     typedef SkLight INHERITED;
     SkPoint3 fDirection;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkPointLight : public SkLight {
 public:
     SkPointLight(const SkPoint3& location, SkColor color)
      : INHERITED(color), fLocation(location) {}
 
     SkPoint3 surfaceToLight(int x, int y, int z, SkScalar surfaceScale) const {
         SkPoint3 direction(fLocation.fX - SkIntToScalar(x),
                            fLocation.fY - SkIntToScalar(y),
                            fLocation.fZ - SkScalarMul(SkIntToScalar(z), surfaceScale));
         direction.normalize();
         return direction;
     };
     SkPoint3 lightColor(const SkPoint3&) const { return color(); }
-    LightType type() const SK_OVERRIDE { return kPoint_LightType; }
+    LightType type() const override { return kPoint_LightType; }
     const SkPoint3& location() const { return fLocation; }
-    GrGLLight* createGLLight() const SK_OVERRIDE {
+    GrGLLight* createGLLight() const override {
 #if SK_SUPPORT_GPU
         return SkNEW(GrGLPointLight);
 #else
         SkDEBUGFAIL("Should not call in GPU-less build");
         return NULL;
 #endif
     }
-    bool requiresFragmentPosition() const SK_OVERRIDE { return true; }
-    bool isEqual(const SkLight& other) const SK_OVERRIDE {
+    bool requiresFragmentPosition() const override { return true; }
+    bool isEqual(const SkLight& other) const override {
         if (other.type() != kPoint_LightType) {
             return false;
         }
         const SkPointLight& o = static_cast<const SkPointLight&>(other);
         return INHERITED::isEqual(other) &&
                fLocation == o.fLocation;
     }
-    SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
+    SkLight* transform(const SkMatrix& matrix) const override {
         SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
         matrix.mapPoints(&location2, 1);
         // Use X scale and Y scale on Z and average the result
         SkPoint locationZ = SkPoint::Make(fLocation.fZ, fLocation.fZ);
         matrix.mapVectors(&locationZ, 1);
         SkPoint3 location(location2.fX, location2.fY, SkScalarAve(locationZ.fX, locationZ.fY));
         return new SkPointLight(location, color());
     }
 
     SkPointLight(SkReadBuffer& buffer) : INHERITED(buffer) {
         fLocation = readPoint3(buffer);
     }
 
 protected:
     SkPointLight(const SkPoint3& location, const SkPoint3& color)
      : INHERITED(color), fLocation(location) {}
-    void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
+    void onFlattenLight(SkWriteBuffer& buffer) const override {
         writePoint3(fLocation, buffer);
     }
 
 private:
     typedef SkLight INHERITED;
     SkPoint3 fLocation;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkSpotLight : public SkLight {
 public:
     SkSpotLight(const SkPoint3& location, const SkPoint3& target, SkScalar specularExponent, SkScalar cutoffAngle, SkColor color)
      : INHERITED(color),
        fLocation(location),
        fTarget(target),
        fSpecularExponent(SkScalarPin(specularExponent, kSpecularExponentMin, kSpecularExponentMax))
     {
        fS = target - location;
        fS.normalize();
        fCosOuterConeAngle = SkScalarCos(SkDegreesToRadians(cutoffAngle));
        const SkScalar antiAliasThreshold = 0.016f;
        fCosInnerConeAngle = fCosOuterConeAngle + antiAliasThreshold;
        fConeScale = SkScalarInvert(antiAliasThreshold);
     }
 
-    SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
+    SkLight* transform(const SkMatrix& matrix) const override {
         SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
         matrix.mapPoints(&location2, 1);
         // Use X scale and Y scale on Z and average the result
         SkPoint locationZ = SkPoint::Make(fLocation.fZ, fLocation.fZ);
         matrix.mapVectors(&locationZ, 1);
         SkPoint3 location(location2.fX, location2.fY, SkScalarAve(locationZ.fX, locationZ.fY));
         SkPoint target2 = SkPoint::Make(fTarget.fX, fTarget.fY);
         matrix.mapPoints(&target2, 1);
         SkPoint targetZ = SkPoint::Make(fTarget.fZ, fTarget.fZ);
         matrix.mapVectors(&targetZ, 1);
@@ skipping 15 matching lines @@
         if (cosAngle < fCosOuterConeAngle) {
             return SkPoint3(0, 0, 0);
         }
         SkScalar scale = SkScalarPow(cosAngle, fSpecularExponent);
         if (cosAngle < fCosInnerConeAngle) {
             scale = SkScalarMul(scale, cosAngle - fCosOuterConeAngle);
             return color() * SkScalarMul(scale, fConeScale);
         }
         return color() * scale;
     }
-    GrGLLight* createGLLight() const SK_OVERRIDE {
+    GrGLLight* createGLLight() const override {
 #if SK_SUPPORT_GPU
         return SkNEW(GrGLSpotLight);
 #else
         SkDEBUGFAIL("Should not call in GPU-less build");
         return NULL;
 #endif
     }
-    bool requiresFragmentPosition() const SK_OVERRIDE { return true; }
-    LightType type() const SK_OVERRIDE { return kSpot_LightType; }
+    bool requiresFragmentPosition() const override { return true; }
+    LightType type() const override { return kSpot_LightType; }
     const SkPoint3& location() const { return fLocation; }
     const SkPoint3& target() const { return fTarget; }
     SkScalar specularExponent() const { return fSpecularExponent; }
     SkScalar cosInnerConeAngle() const { return fCosInnerConeAngle; }
     SkScalar cosOuterConeAngle() const { return fCosOuterConeAngle; }
     SkScalar coneScale() const { return fConeScale; }
     const SkPoint3& s() const { return fS; }
 
     SkSpotLight(SkReadBuffer& buffer) : INHERITED(buffer) {
         fLocation = readPoint3(buffer);
@@ skipping 13 matching lines @@
      : INHERITED(color),
        fLocation(location),
        fTarget(target),
        fSpecularExponent(specularExponent),
        fCosOuterConeAngle(cosOuterConeAngle),
        fCosInnerConeAngle(cosInnerConeAngle),
        fConeScale(coneScale),
        fS(s)
     {
     }
-    void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
+    void onFlattenLight(SkWriteBuffer& buffer) const override {
         writePoint3(fLocation, buffer);
         writePoint3(fTarget, buffer);
         buffer.writeScalar(fSpecularExponent);
         buffer.writeScalar(fCosOuterConeAngle);
         buffer.writeScalar(fCosInnerConeAngle);
         buffer.writeScalar(fConeScale);
         writePoint3(fS, buffer);
     }
 
-    bool isEqual(const SkLight& other) const SK_OVERRIDE {
+    bool isEqual(const SkLight& other) const override {
         if (other.type() != kSpot_LightType) {
             return false;
         }
 
         const SkSpotLight& o = static_cast<const SkSpotLight&>(other);
         return INHERITED::isEqual(other) &&
                fLocation == o.fLocation &&
                fTarget == o.fTarget &&
                fSpecularExponent == o.fSpecularExponent &&
                fCosOuterConeAngle == o.fCosOuterConeAngle;
@@ skipping 395 matching lines @@
 class GrGLLightingEffect  : public GrGLFragmentProcessor {
 public:
     GrGLLightingEffect(const GrProcessor&);
     virtual ~GrGLLightingEffect();
 
     virtual void emitCode(GrGLFPBuilder*,
                           const GrFragmentProcessor&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
-                          const TextureSamplerArray&) SK_OVERRIDE;
+                          const TextureSamplerArray&) override;
 
     static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b);
 
     /**
      * Subclasses of GrGLLightingEffect must call INHERITED::setData();
      */
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 protected:
     virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) = 0;
 
 private:
     typedef GrGLFragmentProcessor INHERITED;
 
     UniformHandle       fImageIncrementUni;
     UniformHandle       fSurfaceScaleUni;
     GrGLLight*          fLight;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDiffuseLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLDiffuseLightingEffect(const GrProcessor&);
-    void emitLightFunc(GrGLFPBuilder*, SkString* funcName) SK_OVERRIDE;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+    void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
+    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKDUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpecularLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLSpecularLightingEffect(const GrProcessor&);
-    void emitLightFunc(GrGLFPBuilder*, SkString* funcName) SK_OVERRIDE;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+    void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
+    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKSUni;
     UniformHandle   fShininessUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 444 matching lines @@
 
     fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END