mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

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

Differential Revision: https://phabricator.services.mozilla.com/D172590
This commit is contained in:
Robert Longson 2023-03-15 19:13:51 +00:00
Родитель c23b959532
Коммит 4264460c99
54 изменённых файлов: 84 добавлений и 704 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
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 {

2
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;
}

11
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) {

1
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;

1
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)

15
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_

14
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

3
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);

171
dom/svg/SVGElement.cpp
Просмотреть файл

@ -943,108 +943,79 @@ SVGElement::IsAttributeMapped(const nsAtom* name) const {
if (name == nsGkAtoms::lang) {
return true;
}
return SVGElementBase::IsAttributeMapped(name);
if (IsSVGAnimationElement()) {
return SVGElementBase::IsAttributeMapped(name);
}
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},
{nsGkAtoms::stroke_linecap},
{nsGkAtoms::stroke_linejoin},
{nsGkAtoms::stroke_miterlimit},
{nsGkAtoms::stroke_opacity},
{nsGkAtoms::stroke_width},
{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}};
static const MappedAttributeEntry* const map[] = {attributes};
return FindAttributeDependence(name, map) ||
SVGElementBase::IsAttributeMapped(name);
}
// PresentationAttributes-Graphics
/* static */
const Element::MappedAttributeEntry SVGElement::sGraphicsMap[] = {
{nsGkAtoms::clip_path},
{nsGkAtoms::clip_rule},
{nsGkAtoms::colorInterpolation},
{nsGkAtoms::cursor},
{nsGkAtoms::display},
{nsGkAtoms::fill},
{nsGkAtoms::fill_opacity},
{nsGkAtoms::fill_rule},
{nsGkAtoms::filter},
{nsGkAtoms::image_rendering},
{nsGkAtoms::mask},
{nsGkAtoms::opacity},
{nsGkAtoms::paint_order},
{nsGkAtoms::pointer_events},
{nsGkAtoms::shape_rendering},
{nsGkAtoms::stroke},
{nsGkAtoms::stroke_dasharray},
{nsGkAtoms::stroke_dashoffset},
{nsGkAtoms::stroke_linecap},
{nsGkAtoms::stroke_linejoin},
{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::unicode_bidi},
{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}};
// 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}};
//----------------------------------------------------------------------
// Element methods

11
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

11
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

2
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

8
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);

2
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;

8
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,

2
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,

17
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

1
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;

20
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));

4
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 {

6
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);
}

14
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

2
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;
};

12
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(

4
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;

5
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);
}

11
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

3
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;

14
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

3
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;

14
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

1
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;

5
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);
}

14
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

2
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:

11
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

3
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;

12
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

2
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

14
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:

2
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:

11
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

3
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)

8
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 =

2
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;

6
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);
}

8
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);
}
//----------------------------------------------------------------------

3
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();
}

4
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;
}

2
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

111
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

3
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

3
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

165
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