Attachment 346527 Details for Bug 186751 – Remove SVG macros from SVGMarkerElement

[patch] Remove SVG macros from SVGMarkerElement

186751-76.patch (text/plain), 20.31 KB, created by Said Abou-Hallawa on 2018-08-03 12:41:17 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Said Abou-Hallawa

Created: 2018-08-03 12:41:17 PDT

Size: 20.31 KB

patch

obsolete

>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 9bec0377e7f..66c2c1610bb 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,30 @@
>+2018-08-02  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        [76] Remove the SVG elements' attributes macros
>+        https://bugs.webkit.org/show_bug.cgi?id=186751
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Remove SVG macros from SVGMarkerElement.
>+
>+        -- Define a custom animated attribute for angle orient type.
>+        -- Define a custom pair attributes accessor for the custom orient type
>+           and the angle value.
>+
>+        * svg/SVGMarkerElement.cpp:
>+        (WebCore::SVGMarkerElement::SVGMarkerElement):
>+        (WebCore::SVGMarkerElement::registerAttributes):
>+        (WebCore::SVGMarkerElement::parseAttribute):
>+        (WebCore::SVGMarkerElement::svgAttributeChanged):
>+        (WebCore::SVGMarkerElement::setOrient):
>+        (WebCore::SVGMarkerElement::orientTypePropertyInfo): Deleted.
>+        (WebCore::SVGMarkerElement::isSupportedAttribute): Deleted.
>+        (WebCore::SVGMarkerElement::synchronizeOrientType): Deleted.
>+        (WebCore::SVGMarkerElement::lookupOrCreateOrientTypeWrapper): Deleted.
>+        (WebCore::SVGMarkerElement::orientType const): Deleted.
>+        (WebCore::SVGMarkerElement::orientTypeAnimated): Deleted.
>+        * svg/SVGMarkerElement.h:
>+
> 2018-08-02  Said Abou-Hallawa  <sabouhallawa@apple.com>
> 
>         [75] Remove the SVG elements' attributes macros
>diff --git a/Source/WebCore/svg/SVGMarkerElement.cpp b/Source/WebCore/svg/SVGMarkerElement.cpp
>index 4c31e95ed7b..836e957509c 100644
>--- a/Source/WebCore/svg/SVGMarkerElement.cpp
>+++ b/Source/WebCore/svg/SVGMarkerElement.cpp
>@@ -2,6 +2,7 @@
>  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
>  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
>  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
>+ * Copyright (C) 2018 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
>@@ -32,58 +33,14 @@ namespace WebCore {
> 
> WTF_MAKE_ISO_ALLOCATED_IMPL(SVGMarkerElement);
> 
>-// Define custom animated property 'orientType'.
>-const SVGPropertyInfo* SVGMarkerElement::orientTypePropertyInfo()
>-{
>-    static const SVGPropertyInfo* s_propertyInfo = 0;
>-    if (!s_propertyInfo) {
>-        s_propertyInfo = new SVGPropertyInfo(AnimatedEnumeration,
>-                                             PropertyIsReadWrite,
>-                                             SVGNames::orientAttr,
>-                                             orientTypeIdentifier(),
>-                                             &SVGMarkerElement::synchronizeOrientType,
>-                                             &SVGMarkerElement::lookupOrCreateOrientTypeWrapper);
>-    }
>-    return s_propertyInfo;
>-}
>-
>-// Animated property definitions
>-DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::refXAttr, RefX, refX)
>-DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::refYAttr, RefY, refY)
>-DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::markerWidthAttr, MarkerWidth, markerWidth)
>-DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::markerHeightAttr, MarkerHeight, markerHeight)
>-DEFINE_ANIMATED_ENUMERATION(SVGMarkerElement, SVGNames::markerUnitsAttr, MarkerUnits, markerUnits, SVGMarkerUnitsType)
>-DEFINE_ANIMATED_ANGLE_AND_ENUMERATION(SVGMarkerElement, SVGNames::orientAttr, orientAngleIdentifier(), OrientAngle, orientAngle)
>-DEFINE_ANIMATED_BOOLEAN(SVGMarkerElement, SVGNames::externalResourcesRequiredAttr, ExternalResourcesRequired, externalResourcesRequired)
>-DEFINE_ANIMATED_RECT(SVGMarkerElement, SVGNames::viewBoxAttr, ViewBox, viewBox)
>-DEFINE_ANIMATED_PRESERVEASPECTRATIO(SVGMarkerElement, SVGNames::preserveAspectRatioAttr, PreserveAspectRatio, preserveAspectRatio)
>-
>-BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGMarkerElement)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(refX)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(refY)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(markerWidth)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(markerHeight)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(markerUnits)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(orientAngle)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(orientType)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(externalResourcesRequired)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(viewBox)
>-    REGISTER_LOCAL_ANIMATED_PROPERTY(preserveAspectRatio)
>-    REGISTER_PARENT_ANIMATED_PROPERTIES(SVGElement)
>-END_REGISTER_ANIMATED_PROPERTIES
>-
> inline SVGMarkerElement::SVGMarkerElement(const QualifiedName& tagName, Document& document)
>     : SVGElement(tagName, document)
>-    , m_refX(LengthModeWidth)
>-    , m_refY(LengthModeHeight)
>-    , m_markerWidth(LengthModeWidth, "3")
>-    , m_markerHeight(LengthModeHeight, "3") 
>-    , m_markerUnits(SVGMarkerUnitsStrokeWidth)
>-    , m_orientType(SVGMarkerOrientAngle)
>+    , SVGExternalResourcesRequired(*this)
>+    , SVGFitToViewBox(*this)
> {
>     // Spec: If the markerWidth/markerHeight attribute is not specified, the effect is as if a value of "3" were specified.
>     ASSERT(hasTagName(SVGNames::markerTag));
>-    registerAnimatedPropertiesForSVGMarkerElement();
>+    registerAttributes();
> }
> 
> Ref<SVGMarkerElement> SVGMarkerElement::create(const QualifiedName& tagName, Document& document)
>@@ -108,24 +65,19 @@ AffineTransform SVGMarkerElement::viewBoxToViewTransform(float viewWidth, float
>     return SVGFitToViewBox::viewBoxToViewTransform(viewBox(), preserveAspectRatio(), viewWidth, viewHeight);
> }
> 
>-bool SVGMarkerElement::isSupportedAttribute(const QualifiedName& attrName)
>+void SVGMarkerElement::registerAttributes()
> {
>-    static const auto supportedAttributes = makeNeverDestroyed([] {
>-        HashSet<QualifiedName> set;
>-        SVGLangSpace::addSupportedAttributes(set);
>-        SVGExternalResourcesRequired::addSupportedAttributes(set);
>-        SVGFitToViewBox::addSupportedAttributes(set);
>-        set.add({
>-            SVGNames::markerUnitsAttr.get(),
>-            SVGNames::refXAttr.get(),
>-            SVGNames::refYAttr.get(),
>-            SVGNames::markerWidthAttr.get(),
>-            SVGNames::markerHeightAttr.get(),
>-            SVGNames::orientAttr.get(),
>-        });
>-        return set;
>-    }());
>-    return supportedAttributes.get().contains<SVGAttributeHashTranslator>(attrName);
>+    auto& registry = attributeRegistry();
>+    if (!registry.isEmpty())
>+        return;
>+    registry.registerAttribute<SVGNames::refXAttr, &SVGMarkerElement::m_refX>();
>+    registry.registerAttribute<SVGNames::refYAttr, &SVGMarkerElement::m_refY>();
>+    registry.registerAttribute<SVGNames::markerWidthAttr, &SVGMarkerElement::m_markerWidth>();
>+    registry.registerAttribute<SVGNames::markerHeightAttr, &SVGMarkerElement::m_markerHeight>();
>+    registry.registerAttribute<SVGNames::markerUnitsAttr, SVGMarkerUnitsType, &SVGMarkerElement::m_markerUnits>();
>+    registry.registerAttribute(SVGAnimatedCustomAngleAttributeAccessor::singleton<SVGNames::orientAttr,
>+        &SVGMarkerElement::orientAngleIdentifier, &SVGMarkerElement::m_orientAngle,
>+        &SVGMarkerElement::orientTypeIdentifier, &SVGMarkerElement::m_orientType>());
> }
> 
> void SVGMarkerElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
>@@ -133,7 +85,7 @@ void SVGMarkerElement::parseAttribute(const QualifiedName& name, const AtomicStr
>     if (name == SVGNames::markerUnitsAttr) {
>         auto propertyValue = SVGPropertyTraits<SVGMarkerUnitsType>::fromString(value);
>         if (propertyValue > 0)
>-            setMarkerUnitsBaseValue(propertyValue);
>+            m_markerUnits.setValue(propertyValue);
>         return;
>     }
> 
>@@ -141,47 +93,44 @@ void SVGMarkerElement::parseAttribute(const QualifiedName& name, const AtomicStr
>         SVGAngleValue angle;
>         auto orientType = SVGPropertyTraits<SVGMarkerOrientType>::fromString(value, angle);
>         if (orientType > 0)
>-            setOrientTypeBaseValue(orientType);
>+            m_orientType.setValue(orientType);
>         if (orientType == SVGMarkerOrientAngle)
>-            setOrientAngleBaseValue(angle);
>+            m_orientAngle.setValue(angle);
>         return;
>     }
> 
>     SVGParsingError parseError = NoError;
> 
>     if (name == SVGNames::refXAttr)
>-        setRefXBaseValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
>+        m_refX.setValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
>     else if (name == SVGNames::refYAttr)
>-        setRefYBaseValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
>+        m_refY.setValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
>     else if (name == SVGNames::markerWidthAttr)
>-        setMarkerWidthBaseValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
>+        m_markerWidth.setValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
>     else if (name == SVGNames::markerHeightAttr)
>-        setMarkerHeightBaseValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
>+        m_markerHeight.setValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
> 
>     reportAttributeParsingError(parseError, name, value);
> 
>     SVGElement::parseAttribute(name, value);
>     SVGExternalResourcesRequired::parseAttribute(name, value);
>-    SVGFitToViewBox::parseAttribute(this, name, value);
>+    SVGFitToViewBox::parseAttribute(name, value);
> }
> 
> void SVGMarkerElement::svgAttributeChanged(const QualifiedName& attrName)
> {
>-    if (!isSupportedAttribute(attrName)) {
>-        SVGElement::svgAttributeChanged(attrName);
>+    if (isKnownAttribute(attrName)) {
>+        InstanceInvalidationGuard guard(*this);
>+        if (isAnimatedLengthAttribute(attrName))
>+            updateRelativeLengthsInformation();
>+        if (RenderObject* object = renderer())
>+            object->setNeedsLayout();
>         return;
>     }
> 
>-    InstanceInvalidationGuard guard(*this);
>-    
>-    if (attrName == SVGNames::refXAttr
>-        || attrName == SVGNames::refYAttr
>-        || attrName == SVGNames::markerWidthAttr
>-        || attrName == SVGNames::markerHeightAttr)
>-        updateRelativeLengthsInformation();
>-
>-    if (RenderObject* object = renderer())
>-        object->setNeedsLayout();
>+    SVGElement::svgAttributeChanged(attrName);
>+    SVGExternalResourcesRequired::svgAttributeChanged(attrName)
>+    SVGFitToViewBox::svgAttributeChanged(attrName);
> }
> 
> void SVGMarkerElement::childrenChanged(const ChildChange& change)
>@@ -197,14 +146,14 @@ void SVGMarkerElement::childrenChanged(const ChildChange& change)
> 
> void SVGMarkerElement::setOrient(SVGMarkerOrientType orientType, const SVGAngleValue& angle)
> {
>-    setOrientTypeBaseValue(orientType);
>-    setOrientAngleBaseValue(angle);
>+    m_orientType.setValue(orientType);
>+    m_orientAngle.setValue(angle);
> 
>     // Mark orientAttr dirty - the next XML DOM access of that attribute kicks in synchronization.
>-    m_orientAngle.shouldSynchronize = true;
>-    m_orientType.shouldSynchronize = true;
>+    m_orientAngle.setShouldSynchronize(true);
>+    m_orientType.setShouldSynchronize(true);
>     invalidateSVGAttributes();
>-    svgAttributeChanged(orientAnglePropertyInfo()->attributeName);
>+    svgAttributeChanged(SVGNames::orientAttr);
> }
> 
> void SVGMarkerElement::setOrientToAuto()
>@@ -230,49 +179,4 @@ bool SVGMarkerElement::selfHasRelativeLengths() const
>         || markerHeight().isRelative();
> }
> 
>-void SVGMarkerElement::synchronizeOrientType(SVGElement* contextElement)
>-{
>-    ASSERT(contextElement);
>-    SVGMarkerElement& ownerType = downcast<SVGMarkerElement>(*contextElement);
>-    if (!ownerType.m_orientType.shouldSynchronize)
>-        return;
>-
>-    static NeverDestroyed<AtomicString> autoString("auto", AtomicString::ConstructFromLiteral);
>-    static NeverDestroyed<AtomicString> autoStartReverseString("auto-start-reverse", AtomicString::ConstructFromLiteral);
>-
>-    // If orient is not auto or auto-start-reverse, the previous call to synchronizeOrientAngle already set the orientAttr to the right angle.
>-    if (ownerType.m_orientType.value == SVGMarkerOrientAuto) {
>-        ownerType.m_orientType.synchronize(&ownerType, orientTypePropertyInfo()->attributeName, autoString);
>-        return;
>-    }
>-
>-    if (ownerType.m_orientType.value == SVGMarkerOrientAutoStartReverse)
>-        ownerType.m_orientType.synchronize(&ownerType, orientTypePropertyInfo()->attributeName, autoStartReverseString);
>-}
>-
>-Ref<SVGAnimatedProperty> SVGMarkerElement::lookupOrCreateOrientTypeWrapper(SVGElement* contextElement)
>-{
>-    ASSERT(contextElement);
>-    SVGMarkerElement& ownerType = downcast<SVGMarkerElement>(*contextElement);
>-    return SVGAnimatedProperty::lookupOrCreateWrapper<SVGMarkerElement, SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>, SVGMarkerOrientType>
>-        (&ownerType, orientTypePropertyInfo(), ownerType.m_orientType.value);
>-}
>-
>-SVGMarkerOrientType& SVGMarkerElement::orientType() const
>-{
>-    if (auto wrapper = SVGAnimatedProperty::lookupWrapper<UseOwnerType, SVGAnimatedEnumeration>(this, orientTypePropertyInfo())) {
>-        if (wrapper->isAnimating()) {
>-            ASSERT(wrapper->currentAnimatedValue() < SVGMarkerOrientMax);
>-            return reinterpret_cast<SVGMarkerOrientType&>(wrapper->currentAnimatedValue());
>-        }
>-    }
>-    return m_orientType.value;
>-}
>-
>-Ref<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>> SVGMarkerElement::orientTypeAnimated()
>-{
>-    m_orientType.shouldSynchronize = true;
>-    return static_reference_cast<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>>(lookupOrCreateOrientTypeWrapper(this));
>-}
>-
> }
>diff --git a/Source/WebCore/svg/SVGMarkerElement.h b/Source/WebCore/svg/SVGMarkerElement.h
>index 67f4051f553..5cc36816ed4 100644
>--- a/Source/WebCore/svg/SVGMarkerElement.h
>+++ b/Source/WebCore/svg/SVGMarkerElement.h
>@@ -1,6 +1,7 @@
> /*
>  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
>  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
>+ * Copyright (C) 2018 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
>@@ -57,14 +58,32 @@ public:
>     void setOrientToAuto();
>     void setOrientToAngle(SVGAngle&);
> 
>-    static const SVGPropertyInfo* orientTypePropertyInfo();
>+    const SVGLengthValue& refX() const { return m_refX.currentValue(); }
>+    const SVGLengthValue& refY() const { return m_refY.currentValue(); }
>+    const SVGLengthValue& markerWidth() const { return m_markerWidth.currentValue(); }
>+    const SVGLengthValue& markerHeight() const { return m_markerHeight.currentValue(); }
>+    SVGMarkerUnitsType markerUnits() const { return m_markerUnits.currentValue(); }
>+    const SVGAngleValue& orientAngle() const { return m_orientAngle.currentValue(); }
>+    SVGMarkerOrientType orientType() const { return m_orientType.currentValue(); }
>+
>+    RefPtr<SVGAnimatedLength> refXAnimated() { return m_refX.animatedProperty(); }
>+    RefPtr<SVGAnimatedLength> refYAnimated() { return m_refY.animatedProperty(); }
>+    RefPtr<SVGAnimatedLength> markerWidthAnimated() { return m_markerWidth.animatedProperty(); }
>+    RefPtr<SVGAnimatedLength> markerHeightAnimated() { return m_markerHeight.animatedProperty(); }
>+    RefPtr<SVGAnimatedEnumeration> markerUnitsAnimated() { return m_markerUnits.animatedProperty(); }
>+    RefPtr<SVGAnimatedAngle> orientAngleAnimated() { return m_orientAngle.animatedProperty(); }
>+    RefPtr<SVGAnimatedEnumeration> orientTypeAnimated() { return m_orientType.animatedProperty(); }
> 
> private:
>     SVGMarkerElement(const QualifiedName&, Document&);
> 
>-    bool needsPendingResourceHandling() const override { return false; }
>+    using AttributeOwnerProxy = SVGAttributeOwnerProxyImpl<SVGMarkerElement, SVGElement, SVGExternalResourcesRequired, SVGFitToViewBox>;
>+    static AttributeOwnerProxy::AttributeRegistry& attributeRegistry() { return AttributeOwnerProxy::attributeRegistry(); }
>+    static bool isKnownAttribute(const QualifiedName& attributeName) { return AttributeOwnerProxy::isKnownAttribute(attributeName); }
>+    static bool isAnimatedLengthAttribute(const QualifiedName& attributeName) { return AttributeOwnerProxy::isAnimatedLengthAttribute(attributeName); }
>+    static void registerAttributes();
> 
>-    static bool isSupportedAttribute(const QualifiedName&);
>+    const SVGAttributeOwnerProxy& attributeOwnerProxy() const final { return m_attributeOwnerProxy; }
>     void parseAttribute(const QualifiedName&, const AtomicString&) override;
>     void svgAttributeChanged(const QualifiedName&) override;
>     void childrenChanged(const ChildChange&) override;
>@@ -72,38 +91,48 @@ private:
>     RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) override;
>     bool rendererIsNeeded(const RenderStyle&) override { return true; }
> 
>+    bool needsPendingResourceHandling() const override { return false; }
>+
>     bool selfHasRelativeLengths() const override;
> 
>     void setOrient(SVGMarkerOrientType, const SVGAngleValue&);
> 
>-    void synchronizeOrientType();
>-
>     static const AtomicString& orientTypeIdentifier();
>     static const AtomicString& orientAngleIdentifier();
>- 
>-    BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGMarkerElement)
>-        DECLARE_ANIMATED_LENGTH(RefX, refX)
>-        DECLARE_ANIMATED_LENGTH(RefY, refY)
>-        DECLARE_ANIMATED_LENGTH(MarkerWidth, markerWidth)
>-        DECLARE_ANIMATED_LENGTH(MarkerHeight, markerHeight)
>-        DECLARE_ANIMATED_ENUMERATION(MarkerUnits, markerUnits, SVGMarkerUnitsType)
>-        DECLARE_ANIMATED_ANGLE(OrientAngle, orientAngle)
>-        DECLARE_ANIMATED_BOOLEAN_OVERRIDE(ExternalResourcesRequired, externalResourcesRequired)
>-        DECLARE_ANIMATED_RECT(ViewBox, viewBox)
>-        DECLARE_ANIMATED_PRESERVEASPECTRATIO(PreserveAspectRatio, preserveAspectRatio)
>-    END_DECLARE_ANIMATED_PROPERTIES
>-  
>-public:
>-    // Custom 'orientType' property.
>-    static void synchronizeOrientType(SVGElement* contextElement);
>-    static Ref<SVGAnimatedProperty> lookupOrCreateOrientTypeWrapper(SVGElement* contextElement);
>-    SVGMarkerOrientType& orientType() const;
>-    SVGMarkerOrientType& orientTypeBaseValue() const { return m_orientType.value; }
>-    void setOrientTypeBaseValue(const SVGMarkerOrientType& type) { m_orientType.value = type; }
>-    Ref<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>> orientTypeAnimated();
> 
>-private:
>-    mutable SVGSynchronizableAnimatedProperty<SVGMarkerOrientType> m_orientType;
>+    AttributeOwnerProxy m_attributeOwnerProxy { *this };
>+
>+    class SVGAnimatedCustomOrientTypeAttribute : public SVGAnimatedEnumerationAttribute<SVGMarkerOrientType> {
>+    public:
>+        using Base = SVGAnimatedEnumerationAttribute<SVGMarkerOrientType>;
>+
>+        SVGAnimatedCustomOrientTypeAttribute(const SVGAttributeOwnerProxy& attributeOwnerProxy, SVGMarkerOrientType baseValue)
>+            : Base(attributeOwnerProxy, baseValue)
>+        {
>+        }
>+        void synchronize(Element& element, const QualifiedName& attributeName)
>+        {
>+            static const NeverDestroyed<String> autoString = MAKE_STATIC_STRING_IMPL("auto");
>+            static const NeverDestroyed<String> autoStartReverseString = MAKE_STATIC_STRING_IMPL("auto-start-reverse");
>+
>+            if (!shouldSynchronize())
>+                return;
>+            if (value() == SVGMarkerOrientAuto)
>+                element.setSynchronizedLazyAttribute(attributeName, autoString.get());
>+            else if (value() == SVGMarkerOrientAutoStartReverse)
>+                element.setSynchronizedLazyAttribute(attributeName, autoStartReverseString.get());
>+        }
>+    };
>+
>+    using SVGAnimatedCustomAngleAttributeAccessor = SVGAnimatedPairAttributeAccessor<SVGMarkerElement, SVGAnimatedAngleAttribute, AnimatedAngle, SVGAnimatedCustomOrientTypeAttribute, AnimatedEnumeration>;
>+
>+    SVGAnimatedLengthAttribute m_refX { m_attributeOwnerProxy, LengthModeWidth };
>+    SVGAnimatedLengthAttribute m_refY { m_attributeOwnerProxy, LengthModeHeight };
>+    SVGAnimatedLengthAttribute m_markerWidth { m_attributeOwnerProxy, LengthModeWidth, "3" };
>+    SVGAnimatedLengthAttribute m_markerHeight { m_attributeOwnerProxy, LengthModeHeight, "3" };
>+    SVGAnimatedEnumerationAttribute<SVGMarkerUnitsType> m_markerUnits { m_attributeOwnerProxy, SVGMarkerUnitsStrokeWidth };
>+    SVGAnimatedAngleAttribute m_orientAngle { m_attributeOwnerProxy };
>+    SVGAnimatedCustomOrientTypeAttribute m_orientType { m_attributeOwnerProxy, SVGMarkerOrientAngle };
> };
> 
> } // namespace WebCore

Actions: View | Formatted Diff | Diff

Attachments on bug 186751: 342916 | 342917 | 342985 | 343001 | 343114 | 343123 | 343124 | 343127 | 343129 | 343162 | 343167 | 343169 | 343171 | 343174 | 343213 | 343217 | 343327 | 343335 | 343338 | 343339 | 343343 | 343415 | 343979 | 343989 | 344002 | 344513 | 344516 | 344523 | 344534 | 344536 | 344988 | 344990 | 346097 | 346103 | 346124 | 346129 | 346177 | 346179 | 346180 | 346182 | 346185 | 346188 | 346190 | 346192 | 346193 | 346197 | 346199 | 346201 | 346202 | 346203 | 346204 | 346205 | 346206 | 346207 | 346211 | 346212 | 346217 | 346224 | 346230 | 346233 | 346241 | 346244 | 346245 | 346315 | 346316 | 346317 | 346318 | 346319 | 346320 | 346322 | 346323 | 346324 | 346325 | 346326 | 346327 | 346328 | 346329 | 346330 | 346331 | 346332 | 346333 | 346334 | 346335 | 346336 | 346337 | 346338 | 346339 | 346340 | 346341 | 346342 | 346343 | 346344 | 346345 | 346346 | 346347 | 346348 | 346349 | 346350 | 346518 | 346519 | 346520 | 346521 | 346522 | 346524 | 346525 | 346526 | 346527 | 346528 | 346529 | 346530 | 346531 | 346532 | 346533 | 346534 | 346535 | 346536 | 346537 | 346538 | 346539 | 346540 | 346541 | 346545 | 346546 | 346549 | 346551 | 346552 | 346601 | 346602 | 346611 | 346636 | 346642