Merge 91148

Source/WebCore/svg/SVGAnimateTransformElement.cpp

 /*
  * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 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 96 matching lines @@
         else if (value == "skewX")
             m_type = SVGTransform::SVG_TRANSFORM_SKEWX;
         else if (value == "skewY")
             m_type = SVGTransform::SVG_TRANSFORM_SKEWY;
         return;
     }
 
     ASSERT_NOT_REACHED();
 }
 
-static SVGTransformList* transformListFor(SVGElement* element)
+static PassRefPtr<SVGAnimatedTransformList> animatedTransformListFor(SVGElement* element)
 {
     ASSERT(element);
     if (element->isStyledTransformable())
-        return &static_cast<SVGStyledTransformableElement*>(element)->transform();
+        return static_cast<SVGStyledTransformableElement*>(element)->transformAnimated();
     if (element->hasTagName(SVGNames::textTag))
-        return &static_cast<SVGTextElement*>(element)->transform();
+        return static_cast<SVGTextElement*>(element)->transformAnimated();
     if (element->hasTagName(SVGNames::linearGradientTag) || element->hasTagName(SVGNames::radialGradientTag))
-        return &static_cast<SVGGradientElement*>(element)->gradientTransform();
+        return static_cast<SVGGradientElement*>(element)->gradientTransformAnimated();
     // FIXME: Handle patternTransform, which is obviously missing!
     return 0;
 }
     
 void SVGAnimateTransformElement::resetToBaseValue(const String& baseValue)
 {
     SVGElement* targetElement = this->targetElement();
     if (!targetElement || determineAnimatedAttributeType(targetElement) == AnimatedUnknown)
         return;
 
     if (targetElement->hasTagName(SVGNames::linearGradientTag) || targetElement->hasTagName(SVGNames::radialGradientTag)) {
         targetElement->setAttribute(SVGNames::gradientTransformAttr, baseValue.isEmpty() ? "matrix(1 0 0 1 0 0)" : baseValue);
         return;
     }
 
     if (baseValue.isEmpty()) {
-        if (SVGTransformList* list = transformListFor(targetElement))
-            list->clear();
+        if (RefPtr<SVGAnimatedTransformList> list = animatedTransformListFor(targetElement)) {
+            list->detachListWrappers(0);
+            list->values().clear();
+        }
     } else
         targetElement->setAttribute(SVGNames::transformAttr, baseValue);
 }
 
 void SVGAnimateTransformElement::calculateAnimatedValue(float percentage, unsigned repeat, SVGSMILElement*)
 {
     SVGElement* targetElement = this->targetElement();
     if (!targetElement || determineAnimatedAttributeType(targetElement) == AnimatedUnknown)
         return;
-    SVGTransformList* transformList = transformListFor(targetElement);
-    ASSERT(transformList);
+    RefPtr<SVGAnimatedTransformList> animatedList = animatedTransformListFor(targetElement);
+    ASSERT(animatedList);
 
-    if (!isAdditive())
-        transformList->clear();
+    if (!isAdditive()) {
+        animatedList->detachListWrappers(0);
+        animatedList->values().clear();
+    }
     if (isAccumulated() && repeat) {
         SVGTransform accumulatedTransform = SVGTransformDistance(m_fromTransform, m_toTransform).scaledDistance(repeat).addToSVGTransform(SVGTransform());
         transformList->append(accumulatedTransform);
     }
     SVGTransform transform = SVGTransformDistance(m_fromTransform, m_toTransform).scaledDistance(percentage).addToSVGTransform(m_fromTransform);
-    transformList->append(transform);
+    animatedList->values().append(transform);
+    animatedList->wrappers().append(RefPtr<SVGPropertyTearOff<SVGTransform> >());
 }
     
 bool SVGAnimateTransformElement::calculateFromAndToValues(const String& fromString, const String& toString)
 {
     m_fromTransform = parseTransformValue(fromString);
     if (!m_fromTransform.isValid())
         return false;
     m_toTransform = parseTransformValue(toString);
     return m_toTransform.isValid();
 }
@@ skipping 25 matching lines @@
     if (!targetElement || determineAnimatedAttributeType(targetElement) == AnimatedUnknown)
         return;
 
     // We accumulate to the target element transform list so there is not much to do here.
     if (RenderObject* renderer = targetElement->renderer()) {
         renderer->setNeedsTransformUpdate();
         RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
     }
 
     // ...except in case where we have additional instances in <use> trees.
-    SVGTransformList* transformList = transformListFor(targetElement);
-    if (!transformList)
+    RefPtr<SVGAnimatedTransformList> animatedList = animatedTransformListFor(targetElement);
+    if (!animatedList)
         return;
+    SVGTransformList* transformList = &animatedList->values();
 
     const HashSet<SVGElementInstance*>& instances = targetElement->instancesForElement();
     const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
     for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
         SVGElement* shadowTreeElement = (*it)->shadowTreeElement();
         ASSERT(shadowTreeElement);
         if (shadowTreeElement->isStyledTransformable())
             static_cast<SVGStyledTransformableElement*>(shadowTreeElement)->setTransformBaseValue(*transformList);
         else if (shadowTreeElement->hasTagName(SVGNames::textTag))
             static_cast<SVGTextElement*>(shadowTreeElement)->setTransformBaseValue(*transformList);
@@ skipping 25 matching lines @@
         return fabsf(to.angle() - from.angle());
     if (to.type() == SVGTransform::SVG_TRANSFORM_SCALE) {
         FloatSize diff = to.scale() - from.scale();
         return sqrtf(diff.width() * diff.width() + diff.height() * diff.height());
     }
     return -1;
 }
 
 }
 #endif // ENABLE(SVG)