Remove one SVG animated type special case from the bindings generator

Source/core/svg/SVGSVGElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Apple Inc. All rights reserved.
  *
  * 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 411 matching lines @@
 {
     AffineTransform viewBoxTransform;
     if (!hasEmptyViewBox()) {
         FloatSize size = currentViewportSize();
         viewBoxTransform = viewBoxToViewTransform(size.width(), size.height());
     }
 
     AffineTransform transform;
     if (!isOutermostSVGSVGElement()) {
         SVGLengthContext lengthContext(this);
-        transform.translate(x().value(lengthContext), y().value(lengthContext));
+        transform.translate(xCurrentValue().value(lengthContext), yCurrentValue().value(lengthContext));
     } else if (mode == SVGLocatable::ScreenScope) {
         if (RenderObject* renderer = this->renderer()) {
             FloatPoint location;
             float zoomFactor = 1;
 
             // At the SVG/HTML boundary (aka RenderSVGRoot), we apply the localToBorderBoxTransform 
             // to map an element from SVG viewport coordinates to CSS box coordinates.
             // RenderSVGRoot's localToAbsolute method expects CSS box coordinates.
             // We also need to adjust for the zoom level factored into CSS coordinates (bug #96361).
             if (renderer->isSVGRoot()) {
@@ skipping 87 matching lines @@
 void SVGSVGElement::setCurrentTime(float seconds)
 {
     if (std::isnan(seconds))
         return;
     seconds = max(seconds, 0.0f);
     m_timeContainer->setElapsed(seconds);
 }
 
 bool SVGSVGElement::selfHasRelativeLengths() const
 {
-    return x().isRelative()
-        || y().isRelative()
-        || width().isRelative()
-        || height().isRelative()
+    return xCurrentValue().isRelative()
+        || yCurrentValue().isRelative()
+        || widthCurrentValue().isRelative()
+        || heightCurrentValue().isRelative()
         || hasAttribute(SVGNames::viewBoxAttr);
 }
 
 FloatRect SVGSVGElement::currentViewBoxRect() const
 {
     if (m_useCurrentView)
-        return m_viewSpec ? m_viewSpec->viewBox() : FloatRect();
+        return m_viewSpec ? m_viewSpec->viewBoxCurrentValue() : FloatRect();
 
-    FloatRect useViewBox = viewBox();
+    FloatRect useViewBox = viewBoxCurrentValue();
     if (!useViewBox.isEmpty())
         return useViewBox;
     if (!renderer() || !renderer()->isSVGRoot())
         return FloatRect();
     if (!toRenderSVGRoot(renderer())->isEmbeddedThroughSVGImage())
         return FloatRect();
 
     Length intrinsicWidth = this->intrinsicWidth();
     Length intrinsicHeight = this->intrinsicHeight();
     if (!intrinsicWidth.isFixed() || !intrinsicHeight.isFixed())
@@ skipping 67 matching lines @@
     // SVG embedded via SVGImage (background-image/border-image/etc) / Inline SVG.
     if (root->isEmbeddedThroughSVGImage() || document()->documentElement() != this)
         return !root->hasReplacedLogicalHeight();
 
     return true;
 }
 
 Length SVGSVGElement::intrinsicWidth(ConsiderCSSMode mode) const
 {
     if (widthAttributeEstablishesViewport() || mode == IgnoreCSSProperties) {
-        if (width().unitType() == LengthTypePercentage)
-            return Length(width().valueAsPercentage() * 100, Percent);
+        if (widthCurrentValue().unitType() == LengthTypePercentage)
+            return Length(widthCurrentValue().valueAsPercentage() * 100, Percent);
 
         SVGLengthContext lengthContext(this);
-        return Length(width().value(lengthContext), Fixed);
+        return Length(widthCurrentValue().value(lengthContext), Fixed);
     }
 
     ASSERT(renderer());
     return renderer()->style()->width();
 }
 
 Length SVGSVGElement::intrinsicHeight(ConsiderCSSMode mode) const
 {
     if (heightAttributeEstablishesViewport() || mode == IgnoreCSSProperties) {
-        if (height().unitType() == LengthTypePercentage)
-            return Length(height().valueAsPercentage() * 100, Percent);
+        if (heightCurrentValue().unitType() == LengthTypePercentage)
+            return Length(heightCurrentValue().valueAsPercentage() * 100, Percent);
 
         SVGLengthContext lengthContext(this);
-        return Length(height().value(lengthContext), Fixed);
+        return Length(heightCurrentValue().value(lengthContext), Fixed);
     }
 
     ASSERT(renderer());
     return renderer()->style()->height();
 }
 
 AffineTransform SVGSVGElement::viewBoxToViewTransform(float viewWidth, float viewHeight) const
 {
     if (!m_useCurrentView || !m_viewSpec)
-        return SVGFitToViewBox::viewBoxToViewTransform(currentViewBoxRect(), preserveAspectRatio(), viewWidth, viewHeight);
+        return SVGFitToViewBox::viewBoxToViewTransform(currentViewBoxRect(), preserveAspectRatioCurrentValue(), viewWidth, viewHeight);
 
-    AffineTransform ctm = SVGFitToViewBox::viewBoxToViewTransform(currentViewBoxRect(), m_viewSpec->preserveAspectRatio(), viewWidth, viewHeight);
+    AffineTransform ctm = SVGFitToViewBox::viewBoxToViewTransform(currentViewBoxRect(), m_viewSpec->preserveAspectRatioCurrentValue(), viewWidth, viewHeight);
     const SVGTransformList& transformList = m_viewSpec->transformBaseValue();
     if (transformList.isEmpty())
         return ctm;
 
     AffineTransform transform;
     if (transformList.concatenate(transform))
         ctm *= transform;
 
     return ctm;
 }
@@ skipping 50 matching lines @@
     // FIXME: We need to decide which <svg> to focus on, and zoom to it.
     // FIXME: We need to actually "highlight" the viewTarget(s).
 }
 
 void SVGSVGElement::inheritViewAttributes(SVGViewElement* viewElement)
 {
     SVGViewSpec* view = currentView();
     m_useCurrentView = true;
 
     if (viewElement->hasAttribute(SVGNames::viewBoxAttr))
-        view->setViewBoxBaseValue(viewElement->viewBox());
+        view->setViewBoxBaseValue(viewElement->viewBoxCurrentValue());
     else
-        view->setViewBoxBaseValue(viewBox());
+        view->setViewBoxBaseValue(viewBoxCurrentValue());
 
     if (viewElement->hasAttribute(SVGNames::preserveAspectRatioAttr))
         view->setPreserveAspectRatioBaseValue(viewElement->preserveAspectRatioBaseValue());
     else
         view->setPreserveAspectRatioBaseValue(preserveAspectRatioBaseValue());
 
     if (viewElement->hasAttribute(SVGNames::zoomAndPanAttr))
         view->setZoomAndPanBaseValue(viewElement->zoomAndPan());
     else
         view->setZoomAndPanBaseValue(zoomAndPan());
@@ skipping 14 matching lines @@
             continue;
 
         Element* element = toElement(node);
         if (element->getIdAttribute() == id)
             return element;
     }
     return 0;
 }
 
 }