Remove one SVG animated type special case from the bindings generator

Source/core/svg/SVGFESpecularLightingElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2005 Oliver Hunt <oliver@nerget.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 124 matching lines @@
 {
     FESpecularLighting* specularLighting = static_cast<FESpecularLighting*>(effect);
 
     if (attrName == SVGNames::lighting_colorAttr) {
         RenderObject* renderer = this->renderer();
         ASSERT(renderer);
         ASSERT(renderer->style());
         return specularLighting->setLightingColor(renderer->style()->svgStyle()->lightingColor());
     }
     if (attrName == SVGNames::surfaceScaleAttr)
-        return specularLighting->setSurfaceScale(surfaceScale());
+        return specularLighting->setSurfaceScale(surfaceScaleCurrentValue());
     if (attrName == SVGNames::specularConstantAttr)
-        return specularLighting->setSpecularConstant(specularConstant());
+        return specularLighting->setSpecularConstant(specularConstantCurrentValue());
     if (attrName == SVGNames::specularExponentAttr)
-        return specularLighting->setSpecularExponent(specularExponent());
+        return specularLighting->setSpecularExponent(specularExponentCurrentValue());
 
     LightSource* lightSource = const_cast<LightSource*>(specularLighting->lightSource());
     const SVGFELightElement* lightElement = SVGFELightElement::findLightElement(this);
     ASSERT(lightSource);
     ASSERT(lightElement);
 
     if (attrName == SVGNames::azimuthAttr)
-        return lightSource->setAzimuth(lightElement->azimuth());
+        return lightSource->setAzimuth(lightElement->azimuthCurrentValue());
     if (attrName == SVGNames::elevationAttr)
-        return lightSource->setElevation(lightElement->elevation());
+        return lightSource->setElevation(lightElement->elevationCurrentValue());
     if (attrName == SVGNames::xAttr)
-        return lightSource->setX(lightElement->x());
+        return lightSource->setX(lightElement->xCurrentValue());
     if (attrName == SVGNames::yAttr)
-        return lightSource->setY(lightElement->y());
+        return lightSource->setY(lightElement->yCurrentValue());
     if (attrName == SVGNames::zAttr)
-        return lightSource->setZ(lightElement->z());
+        return lightSource->setZ(lightElement->zCurrentValue());
     if (attrName == SVGNames::pointsAtXAttr)
-        return lightSource->setPointsAtX(lightElement->pointsAtX());
+        return lightSource->setPointsAtX(lightElement->pointsAtXCurrentValue());
     if (attrName == SVGNames::pointsAtYAttr)
-        return lightSource->setPointsAtY(lightElement->pointsAtY());
+        return lightSource->setPointsAtY(lightElement->pointsAtYCurrentValue());
     if (attrName == SVGNames::pointsAtZAttr)
-        return lightSource->setPointsAtZ(lightElement->pointsAtZ());
+        return lightSource->setPointsAtZ(lightElement->pointsAtZCurrentValue());
     if (attrName == SVGNames::specularExponentAttr)
-        return lightSource->setSpecularExponent(lightElement->specularExponent());
+        return lightSource->setSpecularExponent(lightElement->specularExponentCurrentValue());
     if (attrName == SVGNames::limitingConeAngleAttr)
-        return lightSource->setLimitingConeAngle(lightElement->limitingConeAngle());
+        return lightSource->setLimitingConeAngle(lightElement->limitingConeAngleCurrentValue());
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
 void SVGFESpecularLightingElement::svgAttributeChanged(const QualifiedName& attrName)
 {
     if (!isSupportedAttribute(attrName)) {
         SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
         return;
@@ skipping 21 matching lines @@
 {
     if (SVGFELightElement::findLightElement(this) != lightElement)
         return;
 
     // The light element has different attribute names so attrName can identify the requested attribute.
     primitiveAttributeChanged(attrName);
 }
 
 PassRefPtr<FilterEffect> SVGFESpecularLightingElement::build(SVGFilterBuilder* filterBuilder, Filter* filter)
 {
-    FilterEffect* input1 = filterBuilder->getEffectById(in1());
+    FilterEffect* input1 = filterBuilder->getEffectById(in1CurrentValue());
 
     if (!input1)
         return 0;
 
     RefPtr<LightSource> lightSource = SVGFELightElement::findLightSource(this);
     if (!lightSource)
         return 0;
 
     RenderObject* renderer = this->renderer();
     if (!renderer)
         return 0;
     
     ASSERT(renderer->style());
     Color color = renderer->style()->svgStyle()->lightingColor();
 
-    RefPtr<FilterEffect> effect = FESpecularLighting::create(filter, color, surfaceScale(), specularConstant(),
-                                          specularExponent(), kernelUnitLengthX(), kernelUnitLengthY(), lightSource.release());
+    RefPtr<FilterEffect> effect = FESpecularLighting::create(filter, color, surfaceScaleCurrentValue(), specularConstantCurrentValue(),
+        specularExponentCurrentValue(), kernelUnitLengthXCurrentValue(), kernelUnitLengthYCurrentValue(), lightSource.release());
     effect->inputEffects().append(input1);
     return effect.release();
 }
 
 }