Push hasValidAttributeName/Type down into SVGAnimateElement

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

 /*
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2007 Rob Buis <buis@kde.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 16 matching lines @@
 #include "core/svg/SVGMPathElement.h"
 #include "core/svg/SVGParserUtilities.h"
 #include "core/svg/SVGPathElement.h"
 #include "core/svg/SVGPathUtilities.h"
 #include "platform/transforms/AffineTransform.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 
 namespace blink {
 
-using namespace SVGNames;
+namespace {
+
+bool targetCanHaveMotionTransform(const SVGElement& target) {
+  // We don't have a special attribute name to verify the animation type. Check
+  // the element name instead.
+  if (!target.isSVGGraphicsElement())
+    return false;
+  // Spec: SVG 1.1 section 19.2.15
+  // FIXME: svgTag is missing. Needs to be checked, if transforming <svg> could
+  // cause problems.
+  return isSVGGElement(target) || isSVGDefsElement(target) ||
+         isSVGUseElement(target) || isSVGImageElement(target) ||
+         isSVGSwitchElement(target) || isSVGPathElement(target) ||
+         isSVGRectElement(target) || isSVGCircleElement(target) ||
+         isSVGEllipseElement(target) || isSVGLineElement(target) ||
+         isSVGPolylineElement(target) || isSVGPolygonElement(target) ||
+         isSVGTextElement(target) || isSVGClipPathElement(target) ||
+         isSVGMaskElement(target) || isSVGAElement(target) ||
+         isSVGForeignObjectElement(target);
+}
+}
 
 inline SVGAnimateMotionElement::SVGAnimateMotionElement(Document& document)
-    : SVGAnimationElement(animateMotionTag, document),
+    : SVGAnimationElement(SVGNames::animateMotionTag, document),
       m_hasToPointAtEndOfDuration(false) {
   setCalcMode(CalcModePaced);
 }
 
 DEFINE_NODE_FACTORY(SVGAnimateMotionElement)
 
 SVGAnimateMotionElement::~SVGAnimateMotionElement() {}
 
-bool SVGAnimateMotionElement::hasValidAttributeType() {
-  SVGElement* targetElement = this->targetElement();
-  if (!targetElement)
-    return false;
-
-  // We don't have a special attribute name to verify the animation type. Check
-  // the element name instead.
-  if (!targetElement->isSVGGraphicsElement())
-    return false;
-  // Spec: SVG 1.1 section 19.2.15
-  // FIXME: svgTag is missing. Needs to be checked, if transforming <svg> could
-  // cause problems.
-  return (
-      isSVGGElement(*targetElement) || isSVGDefsElement(*targetElement) ||
-      isSVGUseElement(*targetElement) || isSVGImageElement(*targetElement) ||
-      isSVGSwitchElement(*targetElement) || isSVGPathElement(*targetElement) ||
-      isSVGRectElement(*targetElement) || isSVGCircleElement(*targetElement) ||
-      isSVGEllipseElement(*targetElement) || isSVGLineElement(*targetElement) ||
-      isSVGPolylineElement(*targetElement) ||
-      isSVGPolygonElement(*targetElement) || isSVGTextElement(*targetElement) ||
-      isSVGClipPathElement(*targetElement) ||
-      isSVGMaskElement(*targetElement) || isSVGAElement(*targetElement) ||
-      isSVGForeignObjectElement(*targetElement));
-}
-
-bool SVGAnimateMotionElement::hasValidAttributeName() {
-  // AnimateMotion does not use attributeName so it is always valid.
-  return true;
+bool SVGAnimateMotionElement::hasValidTarget() {
+  return SVGAnimationElement::hasValidTarget() &&
+         targetCanHaveMotionTransform(*targetElement());
 }
 
 void SVGAnimateMotionElement::parseAttribute(const QualifiedName& name,
                                              const AtomicString& oldValue,
                                              const AtomicString& value) {
   if (name == SVGNames::pathAttr) {
     m_path = Path();
     buildPathFromString(value, m_path);
     updateAnimationPath();
     return;
@@ skipping 57 matching lines @@
 
 static bool parsePoint(const String& string, FloatPoint& point) {
   if (string.isEmpty())
     return false;
   if (string.is8Bit())
     return parsePointInternal<LChar>(string, point);
   return parsePointInternal<UChar>(string, point);
 }
 
 void SVGAnimateMotionElement::resetAnimatedType() {
-  if (!hasValidAttributeType())
-    return;
   SVGElement* targetElement = this->targetElement();
-  if (!targetElement)
+  if (!targetElement || !targetCanHaveMotionTransform(*targetElement))
     return;
   if (AffineTransform* transform = targetElement->animateMotionTransform())
     transform->makeIdentity();
 }
 
 void SVGAnimateMotionElement::clearAnimatedType() {
   SVGElement* targetElement = this->targetElement();
   if (!targetElement)
     return;
 
@@ skipping 136 matching lines @@
 }
 
 void SVGAnimateMotionElement::updateAnimationMode() {
   if (!m_animationPath.isEmpty())
     setAnimationMode(PathAnimation);
   else
     SVGAnimationElement::updateAnimationMode();
 }
 
 }  // namespace blink