1 files changed, 33 insertions, 42 deletions

diff --git a/Source/WebCore/svg/SVGRadialGradientElement.cpp b/Source/WebCore/svg/SVGRadialGradientElement.cpp
index a92bf0010..355479f07 100644
--- a/Source/WebCore/svg/SVGRadialGradientElement.cpp
+++ b/Source/WebCore/svg/SVGRadialGradientElement.cpp
@@ -22,21 +22,16 @@
  */
 
 #include "config.h"
-
-#if ENABLE(SVG)
 #include "SVGRadialGradientElement.h"
 
-#include "Attribute.h"
 #include "FloatConversion.h"
 #include "FloatPoint.h"
 #include "RadialGradientAttributes.h"
 #include "RenderSVGResourceRadialGradient.h"
-#include "SVGElementInstance.h"
 #include "SVGNames.h"
 #include "SVGStopElement.h"
-#include "SVGTransform.h"
-#include "SVGTransformList.h"
 #include "SVGUnitTypes.h"
+#include <wtf/NeverDestroyed.h>
 
 namespace WebCore {
 
@@ -72,47 +67,45 @@ inline SVGRadialGradientElement::SVGRadialGradientElement(const QualifiedName& t
     registerAnimatedPropertiesForSVGRadialGradientElement();
 }
 
-PassRefPtr<SVGRadialGradientElement> SVGRadialGradientElement::create(const QualifiedName& tagName, Document& document)
+Ref<SVGRadialGradientElement> SVGRadialGradientElement::create(const QualifiedName& tagName, Document& document)
 {
-    return adoptRef(new SVGRadialGradientElement(tagName, document));
+    return adoptRef(*new SVGRadialGradientElement(tagName, document));
 }
 
 bool SVGRadialGradientElement::isSupportedAttribute(const QualifiedName& attrName)
 {
-    DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, supportedAttributes, ());
-    if (supportedAttributes.isEmpty()) {
-        supportedAttributes.add(SVGNames::cxAttr);
-        supportedAttributes.add(SVGNames::cyAttr);
-        supportedAttributes.add(SVGNames::fxAttr);
-        supportedAttributes.add(SVGNames::fyAttr);
-        supportedAttributes.add(SVGNames::rAttr);
-        supportedAttributes.add(SVGNames::frAttr);
+    static NeverDestroyed<HashSet<QualifiedName>> supportedAttributes;
+    if (supportedAttributes.get().isEmpty()) {
+        supportedAttributes.get().add(SVGNames::cxAttr);
+        supportedAttributes.get().add(SVGNames::cyAttr);
+        supportedAttributes.get().add(SVGNames::fxAttr);
+        supportedAttributes.get().add(SVGNames::fyAttr);
+        supportedAttributes.get().add(SVGNames::rAttr);
+        supportedAttributes.get().add(SVGNames::frAttr);
     }
-    return supportedAttributes.contains<SVGAttributeHashTranslator>(attrName);
+    return supportedAttributes.get().contains<SVGAttributeHashTranslator>(attrName);
 }
 
 void SVGRadialGradientElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     SVGParsingError parseError = NoError;
 
-    if (!isSupportedAttribute(name))
-        SVGGradientElement::parseAttribute(name, value);
-    else if (name == SVGNames::cxAttr)
-        setCxBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
+    if (name == SVGNames::cxAttr)
+        setCxBaseValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
     else if (name == SVGNames::cyAttr)
-        setCyBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
+        setCyBaseValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
     else if (name == SVGNames::rAttr)
-        setRBaseValue(SVGLength::construct(LengthModeOther, value, parseError, ForbidNegativeLengths));
+        setRBaseValue(SVGLengthValue::construct(LengthModeOther, value, parseError, ForbidNegativeLengths));
     else if (name == SVGNames::fxAttr)
-        setFxBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
+        setFxBaseValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
     else if (name == SVGNames::fyAttr)
-        setFyBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
+        setFyBaseValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
     else if (name == SVGNames::frAttr)
-        setFrBaseValue(SVGLength::construct(LengthModeOther, value, parseError, ForbidNegativeLengths));
-    else
-        ASSERT_NOT_REACHED();
+        setFrBaseValue(SVGLengthValue::construct(LengthModeOther, value, parseError, ForbidNegativeLengths));
 
     reportAttributeParsingError(parseError, name, value);
+
+    SVGGradientElement::parseAttribute(name, value);
 }
 
 void SVGRadialGradientElement::svgAttributeChanged(const QualifiedName& attrName)
@@ -122,7 +115,7 @@ void SVGRadialGradientElement::svgAttributeChanged(const QualifiedName& attrName
         return;
     }
 
-    SVGElementInstance::InvalidationGuard invalidationGuard(this);
+    InstanceInvalidationGuard guard(*this);
     
     updateRelativeLengthsInformation();
         
@@ -130,9 +123,9 @@ void SVGRadialGradientElement::svgAttributeChanged(const QualifiedName& attrName
         object->setNeedsLayout();
 }
 
-RenderPtr<RenderElement> SVGRadialGradientElement::createElementRenderer(PassRef<RenderStyle> style)
+RenderPtr<RenderElement> SVGRadialGradientElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
 {
-    return createRenderer<RenderSVGResourceRadialGradient>(*this, std::move(style));
+    return createRenderer<RenderSVGResourceRadialGradient>(*this, WTFMove(style));
 }
 
 static void setGradientAttributes(SVGGradientElement& element, RadialGradientAttributes& attributes, bool isRadial = true)
@@ -156,25 +149,25 @@ static void setGradientAttributes(SVGGradientElement& element, RadialGradientAtt
     }
 
     if (isRadial) {
-        SVGRadialGradientElement* radial = toSVGRadialGradientElement(&element);
+        SVGRadialGradientElement& radial = downcast<SVGRadialGradientElement>(element);
 
         if (!attributes.hasCx() && element.hasAttribute(SVGNames::cxAttr))
-            attributes.setCx(radial->cx());
+            attributes.setCx(radial.cx());
 
         if (!attributes.hasCy() && element.hasAttribute(SVGNames::cyAttr))
-            attributes.setCy(radial->cy());
+            attributes.setCy(radial.cy());
 
         if (!attributes.hasR() && element.hasAttribute(SVGNames::rAttr))
-            attributes.setR(radial->r());
+            attributes.setR(radial.r());
 
         if (!attributes.hasFx() && element.hasAttribute(SVGNames::fxAttr))
-            attributes.setFx(radial->fx());
+            attributes.setFx(radial.fx());
 
         if (!attributes.hasFy() && element.hasAttribute(SVGNames::fyAttr))
-            attributes.setFy(radial->fy());
+            attributes.setFy(radial.fy());
 
         if (!attributes.hasFr() && element.hasAttribute(SVGNames::frAttr))
-            attributes.setFr(radial->fr());
+            attributes.setFr(radial.fr());
     }
 }
 
@@ -192,8 +185,8 @@ bool SVGRadialGradientElement::collectGradientAttributes(RadialGradientAttribute
     while (true) {
         // Respect xlink:href, take attributes from referenced element
         Node* refNode = SVGURIReference::targetElementFromIRIString(current->href(), document());
-        if (refNode && isSVGGradientElement(*refNode)) {
-            current = toSVGGradientElement(refNode);
+        if (is<SVGGradientElement>(refNode)) {
+            current = downcast<SVGGradientElement>(refNode);
 
             // Cycle detection
             if (processedGradients.contains(current))
@@ -229,5 +222,3 @@ bool SVGRadialGradientElement::selfHasRelativeLengths() const
 }
 
 }
-
-#endif // ENABLE(SVG)