Cleanup: Mark some overridden methods with 'SK_OVERRIDE'.

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 572 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(); }
-    virtual LightType type() const { return kDistant_LightType; }
+    virtual LightType type() const SK_OVERRIDE { return kDistant_LightType; }
     const SkPoint3& direction() const { return fDirection; }
     virtual GrGLLight* createGLLight() const SK_OVERRIDE {
 #if SK_SUPPORT_GPU
         return SkNEW(GrGLDistantLight);
 #else
         SkDEBUGFAIL("Should not call in GPU-less build");
         return NULL;
 #endif
     }
     virtual bool requiresFragmentPosition() const SK_OVERRIDE { return false; }
 
     virtual bool isEqual(const SkLight& other) const SK_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) {
     }
-    virtual SkLight* transform(const SkMatrix& matrix) const {
+    virtual SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
         return new SkDistantLight(direction(), color());
     }
     virtual void onFlattenLight(SkWriteBuffer& buffer) const SK_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(); }
-    virtual LightType type() const { return kPoint_LightType; }
+    virtual LightType type() const SK_OVERRIDE { return kPoint_LightType; }
     const SkPoint3& location() const { return fLocation; }
     virtual GrGLLight* createGLLight() const SK_OVERRIDE {
 #if SK_SUPPORT_GPU
         return SkNEW(GrGLPointLight);
 #else
         SkDEBUGFAIL("Should not call in GPU-less build");
         return NULL;
 #endif
     }
     virtual bool requiresFragmentPosition() const SK_OVERRIDE { return true; }
     virtual bool isEqual(const SkLight& other) const SK_OVERRIDE {
         if (other.type() != kPoint_LightType) {
             return false;
         }
         const SkPointLight& o = static_cast<const SkPointLight&>(other);
         return INHERITED::isEqual(other) &&
                fLocation == o.fLocation;
     }
-    virtual SkLight* transform(const SkMatrix& matrix) const {
+    virtual SkLight* transform(const SkMatrix& matrix) const SK_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) {
@@ skipping 23 matching lines @@
        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);
     }
 
-    virtual SkLight* transform(const SkMatrix& matrix) const {
+    virtual SkLight* transform(const SkMatrix& matrix) const SK_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 24 matching lines @@
     }
     virtual GrGLLight* createGLLight() const SK_OVERRIDE {
 #if SK_SUPPORT_GPU
         return SkNEW(GrGLSpotLight);
 #else
         SkDEBUGFAIL("Should not call in GPU-less build");
         return NULL;
 #endif
     }
     virtual bool requiresFragmentPosition() const SK_OVERRIDE { return true; }
-    virtual LightType type() const { return kSpot_LightType; }
+    virtual LightType type() const SK_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 929 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