Push attributeName handling down into SVGAnimateElement

third_party/WebKit/Source/core/svg/SVGAnimateElement.cpp

 /*
  * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/svg/SVGAnimateElement.h"
 
+#include "core/XLinkNames.h"
 #include "core/css/CSSComputedStyleDeclaration.h"
 #include "core/css/StylePropertySet.h"
 #include "core/dom/Document.h"
 #include "core/dom/QualifiedName.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/svg/SVGAnimatedColor.h"
 #include "core/svg/SVGLength.h"
 #include "core/svg/SVGLengthList.h"
 #include "core/svg/SVGNumber.h"
 #include "core/svg/SVGString.h"
@@ skipping 27 matching lines @@
 
 AnimatedPropertyValueType propertyValueType(const QualifiedName& attributeName,
                                             const String& value) {
   DEFINE_STATIC_LOCAL(const AtomicString, inherit, ("inherit"));
   if (value.isEmpty() || value != inherit ||
       !SVGElement::isAnimatableCSSProperty(attributeName))
     return RegularPropertyValue;
   return InheritValue;
 }
 
+QualifiedName constructQualifiedName(const SVGElement& svgElement,
+                                     const AtomicString& attributeName) {
+  if (attributeName.isEmpty())
+    return anyQName();
+  if (!attributeName.contains(':'))
+    return QualifiedName(nullAtom, attributeName, nullAtom);
+
+  AtomicString prefix;
+  AtomicString localName;
+  if (!Document::parseQualifiedName(attributeName, prefix, localName,
+                                    IGNORE_EXCEPTION))
+    return anyQName();
+
+  const AtomicString& namespaceURI = svgElement.lookupNamespaceURI(prefix);
+  if (namespaceURI.isEmpty())
+    return anyQName();
+
+  QualifiedName resolvedAttrName(nullAtom, localName, namespaceURI);
+  // "Animation elements treat attributeName='xlink:href' as being an alias
+  //  for targetting the 'href' attribute."

[pdr., 2017/01/03 18:23:02]

Nit: extra space

[fs, 2017/01/04 09:37:36]

Removed.

+  // https://svgwg.org/svg2-draft/types.html#__svg__SVGURIReference__href
+  if (resolvedAttrName == XLinkNames::hrefAttr)
+    return SVGNames::hrefAttr;
+  return resolvedAttrName;
+}
+
 }  // unnamed namespace
 
 SVGAnimateElement::SVGAnimateElement(const QualifiedName& tagName,
                                      Document& document)
     : SVGAnimationElement(tagName, document),
       m_type(AnimatedUnknown),
       m_cssPropertyId(CSSPropertyInvalid),
       m_fromPropertyValueType(RegularPropertyValue),
       m_toPropertyValueType(RegularPropertyValue),
       m_attributeType(AttributeTypeAuto),
@@ skipping 20 matching lines @@
     }
     for (const auto& part : parts) {
       if (protocolIsJavaScript(part))
         return true;
     }
   }
 
   return SVGSMILElement::isSVGAnimationAttributeSettingJavaScriptURL(attribute);
 }
 
+Node::InsertionNotificationRequest SVGAnimateElement::insertedInto(
+    ContainerNode* rootParent) {
+  SVGAnimationElement::insertedInto(rootParent);
+  if (rootParent->isConnected()) {
+    setAttributeName(constructQualifiedName(
+        *this, fastGetAttribute(SVGNames::attributeNameAttr)));
+  }
+  return InsertionDone;
+}
+
+void SVGAnimateElement::removedFrom(ContainerNode* rootParent) {
+  if (rootParent->isConnected())
+    setAttributeName(anyQName());
+  SVGAnimationElement::removedFrom(rootParent);
+}
+
 void SVGAnimateElement::parseAttribute(const QualifiedName& name,
                                        const AtomicString& oldValue,
                                        const AtomicString& value) {
   if (name == SVGNames::attributeTypeAttr) {
     setAttributeType(value);
     return;
   }
   SVGAnimationElement::parseAttribute(name, oldValue, value);
 }
 
 void SVGAnimateElement::svgAttributeChanged(const QualifiedName& attrName) {
   if (attrName == SVGNames::attributeTypeAttr) {
-    animationAttributeChanged();
+  } else if (attrName == SVGNames::attributeNameAttr) {
+    setAttributeName(constructQualifiedName(
+        *this, fastGetAttribute(SVGNames::attributeNameAttr)));
+  } else {
+    SVGAnimationElement::svgAttributeChanged(attrName);
     return;
   }
-  SVGAnimationElement::svgAttributeChanged(attrName);
+  animationAttributeChanged();
 }
 
 void SVGAnimateElement::resolveTargetProperty() {
   DCHECK(targetElement());
   m_targetProperty = targetElement()->propertyFromAttribute(attributeName());
   if (m_targetProperty) {
     m_type = m_targetProperty->type();
     m_cssPropertyId = m_targetProperty->cssPropertyId();
 
     // Only <animateTransform> is allowed to animate AnimatedTransformList.
@@ skipping 371 matching lines @@
   return fromValue->calculateDistance(toValue, targetElement());
 }
 
 void SVGAnimateElement::setTargetElement(SVGElement* target) {
   SVGAnimationElement::setTargetElement(target);
   checkInvalidCSSAttributeType();
   resetAnimatedPropertyType();
 }
 
 void SVGAnimateElement::setAttributeName(const QualifiedName& attributeName) {
-  SVGAnimationElement::setAttributeName(attributeName);
+  unscheduleIfScheduled();
+  if (targetElement())
+    clearAnimatedType();
+  m_attributeName = attributeName;
+  schedule();
   checkInvalidCSSAttributeType();
   resetAnimatedPropertyType();
 }
 
 void SVGAnimateElement::setAttributeType(const AtomicString& attributeType) {
   if (attributeType == "CSS")
     m_attributeType = AttributeTypeCSS;
   else if (attributeType == "XML")
     m_attributeType = AttributeTypeXML;
   else
@@ skipping 33 matching lines @@
 DEFINE_TRACE(SVGAnimateElement) {
   visitor->trace(m_fromProperty);
   visitor->trace(m_toProperty);
   visitor->trace(m_toAtEndOfDurationProperty);
   visitor->trace(m_animatedValue);
   visitor->trace(m_targetProperty);
   SVGAnimationElement::trace(visitor);
 }
 
 }  // namespace blink