Bug 367994 - Map all SVG styles to all non-animation SVG elements r=emilio

Differential Revision: https://phabricator.services.mozilla.com/D172590

dom/base/nsINode.h

@@ -832,6 +832,7 @@ class nsINode : public mozilla::dom::EventTarget {
     return IsSVGElement() && IsNodeInternal(aFirst, aArgs...);
   }
 
+  virtual bool IsSVGAnimationElement() const { return false; }
   virtual bool IsSVGGraphicsElement() const { return false; }
 
   inline bool IsXULElement() const {

dom/smil/SMILTimeValueSpec.cpp

@@ -215,7 +215,7 @@ void SMILTimeValueSpec::UnregisterFromReferencedElement(Element* aElement) {
 }
 
 SMILTimedElement* SMILTimeValueSpec::GetTimedElement(Element* aElement) {
-  nsCOMPtr<SVGAnimationElement> animationElement = do_QueryInterface(aElement);
+  auto* animationElement = SVGAnimationElement::FromNodeOrNull(aElement);
   return animationElement ? &animationElement->TimedElement() : nullptr;
 }
 

dom/svg/SVGAElement.cpp

@@ -162,17 +162,6 @@ void SVGAElement::UnbindFromTree(bool aNullParent) {
   SVGAElementBase::UnbindFromTree(aNullParent);
 }
 
-NS_IMETHODIMP_(bool)
-SVGAElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGAElementBase::IsAttributeMapped(name);
-}
-
 int32_t SVGAElement::TabIndexDefault() { return 0; }
 
 bool SVGAElement::IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse) {

dom/svg/SVGAElement.h

@@ -51,7 +51,6 @@ class SVGAElement final : public SVGAElementBase,
   // nsIContent
   nsresult BindToTree(BindContext&, nsINode& aParent) override;
   void UnbindFromTree(bool aNullParent = true) override;
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
 
   int32_t TabIndexDefault() override;
   bool IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse) override;

dom/svg/SVGAnimationElement.cpp

@@ -27,7 +27,6 @@ NS_IMPL_ADDREF_INHERITED(SVGAnimationElement, SVGAnimationElementBase)
 NS_IMPL_RELEASE_INHERITED(SVGAnimationElement, SVGAnimationElementBase)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SVGAnimationElement)
-  NS_INTERFACE_MAP_ENTRY_CONCRETE(SVGAnimationElement)
   NS_INTERFACE_MAP_ENTRY(mozilla::dom::SVGTests)
 NS_INTERFACE_MAP_END_INHERITING(SVGAnimationElementBase)
 

dom/svg/SVGAnimationElement.h

@@ -13,14 +13,6 @@
 #include "mozilla/dom/SVGElement.h"
 #include "mozilla/dom/SVGTests.h"
 
-// {f80ef85f-ef48-401a-8aed-1652312326b0}
-#define MOZILLA_SVGANIMATIONELEMENT_IID              \
-  {                                                  \
-    0xf80ef85f, 0xef48, 0x401a, {                    \
-      0x8a, 0xed, 0x16, 0x52, 0x31, 0x23, 0x26, 0xb0 \
-    }                                                \
-  }
-
 namespace mozilla::dom {
 
 using SVGAnimationElementBase = SVGElement;
@@ -36,10 +28,12 @@ class SVGAnimationElement : public SVGAnimationElementBase, public SVGTests {
   // interfaces:
   NS_DECL_ISUPPORTS_INHERITED
 
-  NS_DECLARE_STATIC_IID_ACCESSOR(MOZILLA_SVGANIMATIONELEMENT_IID)
+  NS_IMPL_FROMNODE_HELPER(SVGAnimationElement, IsSVGAnimationElement())
+
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(SVGAnimationElement,
                                            SVGAnimationElementBase)
 
+  bool IsSVGAnimationElement() const final { return true; }
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override = 0;
 
   // nsIContent specializations
@@ -120,9 +114,6 @@ class SVGAnimationElement : public SVGAnimationElementBase, public SVGTests {
   mozilla::SMILTimedElement mTimedElement;
 };
 
-NS_DEFINE_STATIC_IID_ACCESSOR(SVGAnimationElement,
-                              MOZILLA_SVGANIMATIONELEMENT_IID)
-
 }  // namespace mozilla::dom
 
 #endif  // DOM_SVG_SVGANIMATIONELEMENT_H_

dom/svg/SVGDefsElement.cpp

@@ -28,18 +28,4 @@ SVGDefsElement::SVGDefsElement(
 
 NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGDefsElement)
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGDefsElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGGraphicsElement::IsAttributeMapped(name);
-}
-
 }  // namespace mozilla::dom

dom/svg/SVGDefsElement.h

@@ -24,9 +24,6 @@ class SVGDefsElement final : public SVGGraphicsElement {
                      JS::Handle<JSObject*> aGivenProto) override;
 
  public:
-  // nsIContent
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   // defs elements are not focusable.
   bool IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse) override {
     return nsIContent::IsFocusableInternal(aTabIndex, aWithMouse);

dom/svg/SVGElement.cpp

@@ -943,27 +943,53 @@ SVGElement::IsAttributeMapped(const nsAtom* name) const {
   if (name == nsGkAtoms::lang) {
     return true;
   }
+
+  if (IsSVGAnimationElement()) {
     return SVGElementBase::IsAttributeMapped(name);
   }
 
-// PresentationAttributes-Graphics
-/* static */
-const Element::MappedAttributeEntry SVGElement::sGraphicsMap[] = {
+  static const MappedAttributeEntry attributes[] = {
+      // Properties that we don't support are commented out.
+      // { nsGkAtoms::alignment_baseline },
+      // { nsGkAtoms::baseline_shift },
+      {nsGkAtoms::clip},
       {nsGkAtoms::clip_path},
       {nsGkAtoms::clip_rule},
+      {nsGkAtoms::color},
       {nsGkAtoms::colorInterpolation},
+      {nsGkAtoms::colorInterpolationFilters},
       {nsGkAtoms::cursor},
+      {nsGkAtoms::direction},
       {nsGkAtoms::display},
+      {nsGkAtoms::dominant_baseline},
       {nsGkAtoms::fill},
       {nsGkAtoms::fill_opacity},
       {nsGkAtoms::fill_rule},
       {nsGkAtoms::filter},
+      {nsGkAtoms::flood_color},
+      {nsGkAtoms::flood_opacity},
+      {nsGkAtoms::font_family},
+      {nsGkAtoms::font_size},
+      {nsGkAtoms::font_size_adjust},
+      {nsGkAtoms::font_stretch},
+      {nsGkAtoms::font_style},
+      {nsGkAtoms::font_variant},
+      {nsGkAtoms::fontWeight},
       {nsGkAtoms::image_rendering},
+      {nsGkAtoms::letter_spacing},
+      {nsGkAtoms::lighting_color},
+      {nsGkAtoms::marker_end},
+      {nsGkAtoms::marker_mid},
+      {nsGkAtoms::marker_start},
       {nsGkAtoms::mask},
+      {nsGkAtoms::mask_type},
       {nsGkAtoms::opacity},
+      {nsGkAtoms::overflow},
       {nsGkAtoms::paint_order},
       {nsGkAtoms::pointer_events},
       {nsGkAtoms::shape_rendering},
+      {nsGkAtoms::stop_color},
+      {nsGkAtoms::stop_opacity},
       {nsGkAtoms::stroke},
       {nsGkAtoms::stroke_dasharray},
       {nsGkAtoms::stroke_dashoffset},
@@ -972,78 +998,23 @@ const Element::MappedAttributeEntry SVGElement::sGraphicsMap[] = {
       {nsGkAtoms::stroke_miterlimit},
       {nsGkAtoms::stroke_opacity},
       {nsGkAtoms::stroke_width},
-    {nsGkAtoms::text_rendering},
-    {nsGkAtoms::transform_origin},
-    {nsGkAtoms::vector_effect},
-    {nsGkAtoms::visibility},
-    {nullptr}};
-
-// PresentationAttributes-TextContentElements
-/* static */
-const Element::MappedAttributeEntry SVGElement::sTextContentElementsMap[] = {
-    // Properties that we don't support are commented out.
-    // { nsGkAtoms::alignment_baseline },
-    // { nsGkAtoms::baseline_shift },
-    {nsGkAtoms::direction},
-    {nsGkAtoms::dominant_baseline},
-    {nsGkAtoms::font_family},
-    {nsGkAtoms::font_size},
-    {nsGkAtoms::font_size_adjust},
-    {nsGkAtoms::font_stretch},
-    {nsGkAtoms::font_style},
-    {nsGkAtoms::font_variant},
-    {nsGkAtoms::fontWeight},
-    {nsGkAtoms::letter_spacing},
       {nsGkAtoms::text_anchor},
       {nsGkAtoms::text_decoration},
+      {nsGkAtoms::text_rendering},
+      {nsGkAtoms::transform_origin},
       {nsGkAtoms::unicode_bidi},
+      {nsGkAtoms::vector_effect},
+      {nsGkAtoms::visibility},
       {nsGkAtoms::white_space},
       {nsGkAtoms::word_spacing},
       {nsGkAtoms::writing_mode},
       {nullptr}};
 
-// PresentationAttributes-GradientStop
-/* static */
-const Element::MappedAttributeEntry SVGElement::sGradientStopMap[] = {
-    {nsGkAtoms::stop_color}, {nsGkAtoms::stop_opacity}, {nullptr}};
+  static const MappedAttributeEntry* const map[] = {attributes};
 
-// PresentationAttributes-Viewports
-/* static */
-const Element::MappedAttributeEntry SVGElement::sViewportsMap[] = {
-    {nsGkAtoms::overflow}, {nsGkAtoms::clip}, {nullptr}};
-
-// PresentationAttributes-Markers
-/* static */
-const Element::MappedAttributeEntry SVGElement::sMarkersMap[] = {
-    {nsGkAtoms::marker_end},
-    {nsGkAtoms::marker_mid},
-    {nsGkAtoms::marker_start},
-    {nullptr}};
-
-// PresentationAttributes-Color
-/* static */
-const Element::MappedAttributeEntry SVGElement::sColorMap[] = {
-    {nsGkAtoms::color}, {nullptr}};
-
-// PresentationAttributes-Filters
-/* static */
-const Element::MappedAttributeEntry SVGElement::sFiltersMap[] = {
-    {nsGkAtoms::colorInterpolationFilters}, {nullptr}};
-
-// PresentationAttributes-feFlood
-/* static */
-const Element::MappedAttributeEntry SVGElement::sFEFloodMap[] = {
-    {nsGkAtoms::flood_color}, {nsGkAtoms::flood_opacity}, {nullptr}};
-
-// PresentationAttributes-LightingEffects
-/* static */
-const Element::MappedAttributeEntry SVGElement::sLightingEffectsMap[] = {
-    {nsGkAtoms::lighting_color}, {nullptr}};
-
-// PresentationAttributes-mask
-/* static */
-const Element::MappedAttributeEntry SVGElement::sMaskMap[] = {
-    {nsGkAtoms::mask_type}, {nullptr}};
+  return FindAttributeDependence(name, map) ||
+         SVGElementBase::IsAttributeMapped(name);
+}
 
 //----------------------------------------------------------------------
 // Element methods

dom/svg/SVGElement.h

@@ -127,17 +127,6 @@ class SVGElement : public SVGElementBase  // nsIContent
 
   NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
 
-  static const MappedAttributeEntry sGraphicsMap[];
-  static const MappedAttributeEntry sTextContentElementsMap[];
-  static const MappedAttributeEntry sGradientStopMap[];
-  static const MappedAttributeEntry sViewportsMap[];
-  static const MappedAttributeEntry sMarkersMap[];
-  static const MappedAttributeEntry sColorMap[];
-  static const MappedAttributeEntry sFiltersMap[];
-  static const MappedAttributeEntry sFEFloodMap[];
-  static const MappedAttributeEntry sLightingEffectsMap[];
-  static const MappedAttributeEntry sMaskMap[];
-
   NS_IMPL_FROMNODE(SVGElement, kNameSpaceID_SVG)
 
   // Gets the element that establishes the rectangular viewport against which

dom/svg/SVGFEDropShadowElement.cpp

@@ -116,17 +116,6 @@ void SVGFEDropShadowElement::GetSourceImageNames(
   aSources.AppendElement(SVGStringInfo(&mStringAttributes[IN1], this));
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGFEDropShadowElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sFEFloodMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGFEDropShadowElementBase::IsAttributeMapped(name);
-}
-
 //----------------------------------------------------------------------
 // SVGElement methods
 

dom/svg/SVGFEDropShadowElement.h

@@ -44,8 +44,6 @@ class SVGFEDropShadowElement final : public SVGFEDropShadowElementBase {
   void GetSourceImageNames(nsTArray<SVGStringInfo>& aSources) override;
 
   // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 
   // WebIDL

dom/svg/SVGFEFloodElement.cpp

@@ -53,14 +53,6 @@ FilterPrimitiveDescription SVGFEFloodElement::GetPrimitiveDescription(
 //----------------------------------------------------------------------
 // nsIContent methods
 
-NS_IMETHODIMP_(bool)
-SVGFEFloodElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sColorMap, sFEFloodMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGFEFloodElementBase::IsAttributeMapped(name);
-}
-
 nsresult SVGFEFloodElement::BindToTree(BindContext& aCtx, nsINode& aParent) {
   if (aCtx.InComposedDoc()) {
     aCtx.OwnerDoc().SetUseCounter(eUseCounter_custom_feFlood);

dom/svg/SVGFEFloodElement.h

@@ -39,8 +39,6 @@ class SVGFEFloodElement final : public SVGFEFloodElementBase {
   }
 
   // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 
   nsresult BindToTree(BindContext& aCtx, nsINode& aParent) override;

dom/svg/SVGFEImageElement.cpp

@@ -101,14 +101,6 @@ void SVGFEImageElement::AsyncEventRunning(AsyncEventDispatcher* aEvent) {
 //----------------------------------------------------------------------
 // nsIContent methods:
 
-NS_IMETHODIMP_(bool)
-SVGFEImageElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sGraphicsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGFEImageElementBase::IsAttributeMapped(name);
-}
-
 nsresult SVGFEImageElement::AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
                                          const nsAttrValue* aValue,
                                          const nsAttrValue* aOldValue,

dom/svg/SVGFEImageElement.h

@@ -56,8 +56,6 @@ class SVGFEImageElement final : public SVGFEImageElementBase,
                        nsIPrincipal* aReferencePrincipal) override;
 
   // nsIContent
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 
   nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,

dom/svg/SVGFilterElement.cpp

@@ -89,23 +89,6 @@ already_AddRefed<DOMSVGAnimatedString> SVGFilterElement::Href() {
              : mStringAttributes[XLINK_HREF].ToDOMAnimatedString(this);
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGFilterElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sColorMap,
-                                                    sFEFloodMap,
-                                                    sFiltersMap,
-                                                    sGradientStopMap,
-                                                    sLightingEffectsMap,
-                                                    sMarkersMap,
-                                                    sTextContentElementsMap,
-                                                    sViewportsMap};
-  return FindAttributeDependence(name, map) ||
-         SVGFilterElementBase::IsAttributeMapped(name);
-}
-
 //----------------------------------------------------------------------
 // SVGElement methods
 

dom/svg/SVGFilterElement.h

@@ -41,7 +41,6 @@ class SVGFilterElement final : public SVGFilterElementBase {
 
   // nsIContent
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
 
   // SVGSVGElement methods:
   bool HasValidDimensions() const override;

dom/svg/SVGFilters.cpp

@@ -109,17 +109,6 @@ already_AddRefed<DOMSVGAnimatedString> SVGFE::Result() {
   return GetResultImageName().ToDOMAnimatedString(this);
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGFE::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sFiltersMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGFEBase::IsAttributeMapped(name);
-}
-
 //----------------------------------------------------------------------
 // SVGElement methods
 
@@ -377,15 +366,6 @@ SVGElement::StringInfo SVGFELightingElement::sStringInfo[2] = {
 //----------------------------------------------------------------------
 // Implementation
 
-NS_IMETHODIMP_(bool)
-SVGFELightingElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sColorMap,
-                                                    sLightingEffectsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGFELightingElementBase::IsAttributeMapped(name);
-}
-
 void SVGFELightingElement::GetSourceImageNames(
     nsTArray<SVGStringInfo>& aSources) {
   aSources.AppendElement(SVGStringInfo(&mStringAttributes[IN1], this));

dom/svg/SVGFilters.h

@@ -82,9 +82,6 @@ class SVGFE : public SVGFEBase {
   // interfaces:
   NS_DECL_ISUPPORTS_INHERITED
 
-  // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   // SVGElement interface
   nsresult Clone(mozilla::dom::NodeInfo*, nsINode** aResult) const override = 0;
 
@@ -190,7 +187,6 @@ class SVGFELightingElement : public SVGFELightingElementBase {
     return mStringAttributes[RESULT];
   }
   void GetSourceImageNames(nsTArray<SVGStringInfo>& aSources) override;
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
 
  protected:
   bool OperatesOnSRGB(int32_t aInputIndex, bool aInputIsAlreadySRGB) override {

dom/svg/SVGForeignObjectElement.cpp

@@ -111,13 +111,7 @@ bool SVGForeignObjectElement::HasValidDimensions() const {
 
 NS_IMETHODIMP_(bool)
 SVGForeignObjectElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
   return IsInLengthInfo(name, sLengthInfo) ||
-         FindAttributeDependence(name, map) ||
          SVGGraphicsElement::IsAttributeMapped(name);
 }
 

dom/svg/SVGGElement.cpp

@@ -27,18 +27,4 @@ SVGGElement::SVGGElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
 
 NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGGElement)
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGGElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGGraphicsElement::IsAttributeMapped(name);
-}
-
 }  // namespace mozilla::dom

dom/svg/SVGGElement.h

@@ -24,8 +24,6 @@ class SVGGElement final : public SVGGraphicsElement {
 
  public:
   // nsIContent
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 };
 

dom/svg/SVGGradientElement.cpp

@@ -84,18 +84,6 @@ already_AddRefed<DOMSVGAnimatedString> SVGGradientElement::Href() {
              : mStringAttributes[XLINK_HREF].ToDOMAnimatedString(this);
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGGradientElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sColorMap,
-                                                    sGradientStopMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGGradientElementBase::IsAttributeMapped(name);
-}
-
 //---------------------Linear Gradients------------------------
 
 JSObject* SVGLinearGradientElement::WrapNode(

dom/svg/SVGGradientElement.h

@@ -42,10 +42,8 @@ class SVGGradientElement : public SVGGradientElementBase {
                      JS::Handle<JSObject*> aGivenProto) override = 0;
 
  public:
-  nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override = 0;
-
   // nsIContent
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
+  nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override = 0;
 
   virtual SVGAnimatedTransformList* GetAnimatedTransformList(
       uint32_t aFlags = 0) override;

dom/svg/SVGImageElement.cpp

@@ -259,12 +259,7 @@ void SVGImageElement::DestroyContent() {
 
 NS_IMETHODIMP_(bool)
 SVGImageElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sViewportsMap,
-  };
-
   return IsInLengthInfo(name, sLengthInfo) ||
-         FindAttributeDependence(name, map) ||
          SVGImageElementBase::IsAttributeMapped(name);
 }
 

dom/svg/SVGLineElement.cpp

@@ -76,17 +76,6 @@ already_AddRefed<DOMSVGAnimatedLength> SVGLineElement::Y2() {
   return mLengthAttributes[ATTR_Y2].ToDOMAnimatedLength(this);
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGLineElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sMarkersMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGLineElementBase::IsAttributeMapped(name);
-}
-
 //----------------------------------------------------------------------
 // SVGElement methods
 

dom/svg/SVGLineElement.h

@@ -30,9 +30,6 @@ class SVGLineElement final : public SVGLineElementBase {
   void MaybeAdjustForZeroLength(float aX1, float aY1, float& aX2, float aY2);
 
  public:
-  // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* name) const override;
-
   // SVGGeometryElement methods:
   bool IsMarkable() override { return true; }
   void GetMarkPoints(nsTArray<SVGMark>* aMarks) override;

dom/svg/SVGMarkerElement.cpp

@@ -118,20 +118,6 @@ void SVGMarkerElement::SetOrientToAngle(DOMSVGAngle& angle, ErrorResult& rv) {
   mOrient.SetBaseValue(f, angle.UnitType(), this, true);
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGMarkerElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sColorMap,    sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sGraphicsMap, sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGMarkerElementBase::IsAttributeMapped(name);
-}
-
 //----------------------------------------------------------------------
 // SVGElement methods
 

dom/svg/SVGMarkerElement.h

@@ -44,9 +44,6 @@ class SVGMarkerElement final : public SVGMarkerElementBase {
   JSObject* WrapNode(JSContext* cx, JS::Handle<JSObject*> aGivenProto) override;
 
  public:
-  // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* name) const override;
-
   // SVGSVGElement methods:
   bool HasValidDimensions() const override;
 

dom/svg/SVGMaskElement.cpp

@@ -100,18 +100,4 @@ SVGElement::EnumAttributesInfo SVGMaskElement::GetEnumInfo() {
   return EnumAttributesInfo(mEnumAttributes, sEnumInfo, ArrayLength(sEnumInfo));
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGMaskElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sColorMap,    sFEFloodMap, sFiltersMap, sGradientStopMap,
-      sGraphicsMap, sMarkersMap, sMaskMap,    sTextContentElementsMap,
-      sViewportsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGMaskElementBase::IsAttributeMapped(name);
-}
-
 }  // namespace mozilla::dom

dom/svg/SVGMaskElement.h

@@ -36,7 +36,6 @@ class SVGMaskElement final : public SVGMaskElementBase {
  public:
   // nsIContent interface
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
 
   // SVGSVGElement methods:
   bool HasValidDimensions() const override;

dom/svg/SVGPathElement.cpp

@@ -258,10 +258,7 @@ bool SVGPathElement::HasValidDimensions() const {
 
 NS_IMETHODIMP_(bool)
 SVGPathElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sMarkersMap};
-
-  return FindAttributeDependence(name, map) ||
-         (StaticPrefs::layout_css_d_property_enabled() &&
+  return (StaticPrefs::layout_css_d_property_enabled() &&
           name == nsGkAtoms::d) ||
          SVGPathElementBase::IsAttributeMapped(name);
 }

dom/svg/SVGPatternElement.cpp

@@ -112,20 +112,6 @@ already_AddRefed<DOMSVGAnimatedString> SVGPatternElement::Href() {
              : mStringAttributes[XLINK_HREF].ToDOMAnimatedString(this);
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGPatternElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sColorMap,    sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sGraphicsMap, sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGPatternElementBase::IsAttributeMapped(name);
-}
-
 //----------------------------------------------------------------------
 // SVGElement methods
 

dom/svg/SVGPatternElement.h

@@ -40,8 +40,6 @@ class SVGPatternElement final : public SVGPatternElementBase {
 
  public:
   // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* name) const override;
-
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 
   // SVGSVGElement methods:

dom/svg/SVGPolyElement.cpp

@@ -34,17 +34,6 @@ already_AddRefed<DOMSVGPointList> SVGPolyElement::AnimatedPoints() {
   return points.forget();
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGPolyElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sMarkersMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGPolyElementBase::IsAttributeMapped(name);
-}
-
 //----------------------------------------------------------------------
 // SVGElement methods
 

dom/svg/SVGPolyElement.h

@@ -28,9 +28,6 @@ class SVGPolyElement : public SVGPolyElementBase {
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(SVGPolyElement, SVGPolyElementBase)
 
-  // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* name) const override;
-
   SVGAnimatedPointList* GetAnimatedPointList() override { return &mPoints; }
   nsStaticAtom* GetPointListAttrName() const override {
     return nsGkAtoms::points;

dom/svg/SVGStopElement.cpp

@@ -44,16 +44,4 @@ SVGElement::NumberAttributesInfo SVGStopElement::GetNumberInfo() {
   return NumberAttributesInfo(&mOffset, &sNumberInfo, 1);
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGStopElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sColorMap,
-                                                    sGradientStopMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGStopElementBase::IsAttributeMapped(name);
-}
-
 }  // namespace mozilla::dom

dom/svg/SVGStopElement.h

@@ -28,8 +28,6 @@ class SVGStopElement final : public SVGStopElementBase {
 
  public:
   // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 
   // WebIDL

dom/svg/SVGSwitchElement.cpp

@@ -86,20 +86,6 @@ void SVGSwitchElement::RemoveChildNode(nsIContent* aKid, bool aNotify) {
   MaybeInvalidate();
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGSwitchElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGSwitchElementBase::IsAttributeMapped(name);
-}
-
 //----------------------------------------------------------------------
 // Implementation Helpers:
 

dom/svg/SVGSwitchElement.h

@@ -47,8 +47,6 @@ class SVGSwitchElement final : public SVGSwitchElementBase {
   void RemoveChildNode(nsIContent* aKid, bool aNotify) override;
 
   // nsIContent
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 
  private:

dom/svg/SVGTextContentElement.cpp

@@ -187,15 +187,4 @@ int32_t SVGTextContentElement::GetCharNumAtPosition(
   return textFrame ? textFrame->GetCharNumAtPosition(this, aPoint) : -1;
 }
 
-//----------------------------------------------------------------------
-// nsIContent methods
-
-NS_IMETHODIMP_(bool)
-SVGTextContentElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sTextContentElementsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGTextContentElementBase::IsAttributeMapped(name);
-}
-
 }  // namespace mozilla::dom

dom/svg/SVGTextContentElement.h

@@ -50,9 +50,6 @@ class SVGTextContentElement : public SVGTextContentElementBase {
   MOZ_CAN_RUN_SCRIPT float GetRotationOfChar(uint32_t charnum, ErrorResult& rv);
   MOZ_CAN_RUN_SCRIPT int32_t GetCharNumAtPosition(const DOMPointInit& aPoint);
 
-  // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
  protected:
   explicit SVGTextContentElement(
       already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)

dom/svg/SVGTransformableElement.cpp

@@ -26,14 +26,6 @@ SVGTransformableElement::Transform() {
 //----------------------------------------------------------------------
 // nsIContent methods
 
-NS_IMETHODIMP_(bool)
-SVGTransformableElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {sColorMap, sGraphicsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGElement::IsAttributeMapped(name);
-}
-
 nsChangeHint SVGTransformableElement::GetAttributeChangeHint(
     const nsAtom* aAttribute, int32_t aModType) const {
   nsChangeHint retval =

dom/svg/SVGTransformableElement.h

@@ -34,8 +34,6 @@ class SVGTransformableElement : public SVGElement {
   already_AddRefed<DOMSVGAnimatedTransformList> Transform();
 
   // nsIContent interface
-  NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
-
   nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
                                       int32_t aModType) const override;
 

dom/svg/SVGUseElement.cpp

@@ -610,13 +610,7 @@ SVGUseFrame* SVGUseElement::GetFrame() const {
 
 NS_IMETHODIMP_(bool)
 SVGUseElement::IsAttributeMapped(const nsAtom* name) const {
-  static const MappedAttributeEntry* const map[] = {
-      sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
   return name == nsGkAtoms::x || name == nsGkAtoms::y ||
-         FindAttributeDependence(name, map) ||
          SVGUseElementBase::IsAttributeMapped(name);
 }
 

dom/svg/SVGViewportElement.cpp

@@ -87,13 +87,7 @@ SVGViewportElement::IsAttributeMapped(const nsAtom* name) const {
     return true;
   }
 
-  static const MappedAttributeEntry* const map[] = {
-      sFEFloodMap,         sFiltersMap, sGradientStopMap,
-      sLightingEffectsMap, sMarkersMap, sTextContentElementsMap,
-      sViewportsMap};
-
-  return FindAttributeDependence(name, map) ||
-         SVGGraphicsElement::IsAttributeMapped(name);
+  return SVGGraphicsElement::IsAttributeMapped(name);
 }
 
 //----------------------------------------------------------------------

layout/base/PresShell.cpp

@@ -3233,8 +3233,7 @@ nsresult PresShell::GoToAnchor(const nsAString& aAnchorName, bool aScroll,
     }
 
     // If the target is an animation element, activate the animation
-    if (nsCOMPtr<SVGAnimationElement> animationElement =
-            do_QueryInterface(target)) {
+    if (auto* animationElement = SVGAnimationElement::FromNode(target.get())) {
       animationElement->ActivateByHyperlink();
     }
 

layout/base/nsCSSFrameConstructor.cpp

@@ -119,7 +119,6 @@
 #undef NOISY_FIRST_LETTER
 
 #include "nsMathMLParts.h"
-#include "mozilla/dom/SVGAnimationElement.h"
 #include "mozilla/dom/SVGFilters.h"
 #include "mozilla/dom/SVGTests.h"
 #include "mozilla/SVGGradientFrame.h"
@@ -4930,8 +4929,7 @@ nsCSSFrameConstructor::FindSVGData(const Element& aElement,
   }
 
   // We don't need frames for animation elements
-  if (nsCOMPtr<SVGAnimationElement> animationElement =
-          do_QueryInterface(const_cast<Element*>(&aElement))) {
+  if (aElement.IsSVGAnimationElement()) {
     return &sSuppressData;
   }
 

testing/web-platform/meta/svg/animations/svglength-animation-px-to-ems.html.ini

@@ -1,5 +1,3 @@
 [svglength-animation-px-to-ems.html]
   expected:
     if (os == "android") and fission: [OK, TIMEOUT]
-  [Test SVGLength animation from px to ems.]
-    expected: FAIL

testing/web-platform/meta/svg/styling/presentation-attributes-irrelevant.html.ini

@@ -1,115 +1,4 @@
 [presentation-attributes-irrelevant.html]
-  [clip-path presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [clip-rule presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [color-interpolation-filters presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [direction presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [display presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [dominant-baseline presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [filter presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [flood-color presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [flood-opacity presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [font-family presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [font-size presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [font-size-adjust presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [font-stretch presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [font-style presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [font-variant presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [font-weight presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [letter-spacing presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [lighting-color presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [marker-end presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [marker-mid presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [marker-start presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [mask-type presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [mask presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [opacity presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [overflow presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [pointer-events presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [stop-color presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [stop-opacity presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [text-anchor presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [text-decoration presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
   [text-overflow presentation attribute supported on an irrelevant element]
     expected: FAIL
 
-  [transform-origin presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [unicode-bidi presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [vector-effect presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [visibility presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [white-space presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [word-spacing presentation attribute supported on an irrelevant element]
-    expected: FAIL
-
-  [writing-mode presentation attribute supported on an irrelevant element]
-    expected: FAIL
-

testing/web-platform/meta/svg/styling/presentation-attributes-relevant.html.ini

@@ -1,7 +1,4 @@
 [presentation-attributes-relevant.html]
-  [color-interpolation presentation attribute supported on a relevant element]
-    expected: FAIL
-
   [text-overflow presentation attribute supported on a relevant element]
     expected: FAIL
 

testing/web-platform/meta/svg/styling/presentation-attributes-special-cases.html.ini

@@ -8,6 +8,9 @@
   [x, y, width, and height presentation attributes supported on use element]
     expected: FAIL
 
+  [fill presentation attribute not supported on discard]
+    expected: FAIL
+
   [transform presentation attribute supported on g]
     expected: FAIL
 

testing/web-platform/meta/svg/styling/presentation-attributes-unknown.html.ini

@@ -1,170 +1,5 @@
 [presentation-attributes-unknown.html]
   expected:
     if (os == "android") and fission: [OK, TIMEOUT]
-  [clip-path presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [clip-rule presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [color presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [color-interpolation-filters presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [color-interpolation presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [cursor presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [direction presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [display presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [dominant-baseline presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [fill presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [fill-opacity presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [fill-rule presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [filter presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [flood-color presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [flood-opacity presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [font-family presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [font-size presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [font-size-adjust presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [font-stretch presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [font-style presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [font-variant presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [font-weight presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [image-rendering presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [letter-spacing presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [lighting-color presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [marker-end presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [marker-mid presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [marker-start presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [mask-type presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [mask presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [opacity presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [overflow presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [paint-order presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [pointer-events presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [shape-rendering presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stop-color presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stop-opacity presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stroke presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stroke-dasharray presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stroke-dashoffset presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stroke-linecap presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stroke-linejoin presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stroke-miterlimit presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stroke-opacity presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [stroke-width presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [text-anchor presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [text-decoration presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
   [text-overflow presentation attribute supported on an unknown SVG element]
     expected: FAIL
-
-  [text-rendering presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [transform-origin presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [unicode-bidi presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [vector-effect presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [visibility presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [white-space presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [word-spacing presentation attribute supported on an unknown SVG element]
-    expected: FAIL
-
-  [writing-mode presentation attribute supported on an unknown SVG element]
-    expected: FAIL