--- a/dom/svg/SVGAElement.cpp
+++ b/dom/svg/SVGAElement.cpp
@@ -24,19 +24,19 @@ namespace dom {
JSObject*
SVGAElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGAElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGAElement::sStringInfo[3] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_XLink, true },
- { &nsGkAtoms::target, kNameSpaceID_None, true }
+ { nsGkAtoms::href, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_XLink, true },
+ { nsGkAtoms::target, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsISupports methods
NS_INTERFACE_MAP_BEGIN(SVGAElement)
NS_INTERFACE_MAP_ENTRY(nsIDOMNode)
--- a/dom/svg/SVGAnimateMotionElement.h
+++ b/dom/svg/SVGAnimateMotionElement.h
@@ -35,17 +35,17 @@ public:
bool aPreallocateChildren) const override;
// SVGAnimationElement
virtual nsSMILAnimationFunction& AnimationFunction() override;
virtual bool GetTargetAttributeName(int32_t *aNamespaceID,
nsAtom **aLocalName) const override;
// nsSVGElement
- virtual nsAtom* GetPathDataAttrName() const override {
+ virtual nsStaticAtom* GetPathDataAttrName() const override {
return nsGkAtoms::path;
}
// Utility method to let our <mpath> children tell us when they've changed,
// so we can make sure our mAnimationFunction is marked as having changed.
void MpathChanged() { mAnimationFunction.MpathChanged(); }
};
--- a/dom/svg/SVGCircleElement.cpp
+++ b/dom/svg/SVGCircleElement.cpp
@@ -20,19 +20,19 @@ namespace dom {
JSObject*
SVGCircleElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGCircleElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGCircleElement::sLengthInfo[3] =
{
- { &nsGkAtoms::cx, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::cy, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::r, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::XY }
+ { nsGkAtoms::cx, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::cy, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::r, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::XY }
};
//----------------------------------------------------------------------
// Implementation
SVGCircleElement::SVGCircleElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGCircleElementBase(aNodeInfo)
{
--- a/dom/svg/SVGClipPathElement.cpp
+++ b/dom/svg/SVGClipPathElement.cpp
@@ -21,17 +21,17 @@ using namespace SVGUnitTypesBinding;
JSObject*
SVGClipPathElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGClipPathElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::EnumInfo SVGClipPathElement::sEnumInfo[1] =
{
- { &nsGkAtoms::clipPathUnits,
+ { nsGkAtoms::clipPathUnits,
sSVGUnitTypesMap,
SVG_UNIT_TYPE_USERSPACEONUSE
}
};
//----------------------------------------------------------------------
// Implementation
--- a/dom/svg/SVGEllipseElement.cpp
+++ b/dom/svg/SVGEllipseElement.cpp
@@ -21,20 +21,20 @@ namespace dom {
JSObject*
SVGEllipseElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGEllipseElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGEllipseElement::sLengthInfo[4] =
{
- { &nsGkAtoms::cx, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::cy, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::rx, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::ry, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::cx, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::cy, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::rx, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::ry, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
};
//----------------------------------------------------------------------
// Implementation
SVGEllipseElement::SVGEllipseElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGEllipseElementBase(aNodeInfo)
{
--- a/dom/svg/SVGFEBlendElement.cpp
+++ b/dom/svg/SVGFEBlendElement.cpp
@@ -38,27 +38,27 @@ nsSVGEnumMapping SVGFEBlendElement::sMod
{&nsGkAtoms::saturation, SVG_FEBLEND_MODE_SATURATION},
{&nsGkAtoms::color, SVG_FEBLEND_MODE_COLOR},
{&nsGkAtoms::luminosity, SVG_FEBLEND_MODE_LUMINOSITY},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGFEBlendElement::sEnumInfo[1] =
{
- { &nsGkAtoms::mode,
+ { nsGkAtoms::mode,
sModeMap,
SVG_FEBLEND_MODE_NORMAL
}
};
nsSVGElement::StringInfo SVGFEBlendElement::sStringInfo[3] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true },
- { &nsGkAtoms::in2, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true },
+ { nsGkAtoms::in2, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEBlendElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFEColorMatrixElement.cpp
+++ b/dom/svg/SVGFEColorMatrixElement.cpp
@@ -29,31 +29,31 @@ nsSVGEnumMapping SVGFEColorMatrixElement
{&nsGkAtoms::saturate, SVG_FECOLORMATRIX_TYPE_SATURATE},
{&nsGkAtoms::hueRotate, SVG_FECOLORMATRIX_TYPE_HUE_ROTATE},
{&nsGkAtoms::luminanceToAlpha, SVG_FECOLORMATRIX_TYPE_LUMINANCE_TO_ALPHA},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGFEColorMatrixElement::sEnumInfo[1] =
{
- { &nsGkAtoms::type,
+ { nsGkAtoms::type,
sTypeMap,
SVG_FECOLORMATRIX_TYPE_MATRIX
}
};
nsSVGElement::StringInfo SVGFEColorMatrixElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
nsSVGElement::NumberListInfo SVGFEColorMatrixElement::sNumberListInfo[1] =
{
- { &nsGkAtoms::values }
+ { nsGkAtoms::values }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEColorMatrixElement)
--- a/dom/svg/SVGFEComponentTransferElement.cpp
+++ b/dom/svg/SVGFEComponentTransferElement.cpp
@@ -20,18 +20,18 @@ namespace dom {
JSObject*
SVGFEComponentTransferElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEComponentTransferElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGFEComponentTransferElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEComponentTransferElement)
already_AddRefed<SVGAnimatedString>
--- a/dom/svg/SVGFECompositeElement.cpp
+++ b/dom/svg/SVGFECompositeElement.cpp
@@ -17,45 +17,45 @@ namespace dom {
JSObject*
SVGFECompositeElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFECompositeElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFECompositeElement::sNumberInfo[4] =
{
- { &nsGkAtoms::k1, 0, false },
- { &nsGkAtoms::k2, 0, false },
- { &nsGkAtoms::k3, 0, false },
- { &nsGkAtoms::k4, 0, false }
+ { nsGkAtoms::k1, 0, false },
+ { nsGkAtoms::k2, 0, false },
+ { nsGkAtoms::k3, 0, false },
+ { nsGkAtoms::k4, 0, false }
};
nsSVGEnumMapping SVGFECompositeElement::sOperatorMap[] = {
{&nsGkAtoms::over, SVG_FECOMPOSITE_OPERATOR_OVER},
{&nsGkAtoms::in, SVG_FECOMPOSITE_OPERATOR_IN},
{&nsGkAtoms::out, SVG_FECOMPOSITE_OPERATOR_OUT},
{&nsGkAtoms::atop, SVG_FECOMPOSITE_OPERATOR_ATOP},
{&nsGkAtoms::xor_, SVG_FECOMPOSITE_OPERATOR_XOR},
{&nsGkAtoms::arithmetic, SVG_FECOMPOSITE_OPERATOR_ARITHMETIC},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGFECompositeElement::sEnumInfo[1] =
{
- { &nsGkAtoms::_operator,
+ { nsGkAtoms::_operator,
sOperatorMap,
SVG_FECOMPOSITE_OPERATOR_OVER
}
};
nsSVGElement::StringInfo SVGFECompositeElement::sStringInfo[3] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true },
- { &nsGkAtoms::in2, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true },
+ { nsGkAtoms::in2, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFECompositeElement)
already_AddRefed<SVGAnimatedString>
--- a/dom/svg/SVGFEConvolveMatrixElement.cpp
+++ b/dom/svg/SVGFEConvolveMatrixElement.cpp
@@ -22,65 +22,65 @@ namespace dom {
JSObject*
SVGFEConvolveMatrixElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEConvolveMatrixElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFEConvolveMatrixElement::sNumberInfo[2] =
{
- { &nsGkAtoms::divisor, 1, false },
- { &nsGkAtoms::bias, 0, false }
+ { nsGkAtoms::divisor, 1, false },
+ { nsGkAtoms::bias, 0, false }
};
nsSVGElement::NumberPairInfo SVGFEConvolveMatrixElement::sNumberPairInfo[1] =
{
- { &nsGkAtoms::kernelUnitLength, 0, 0 }
+ { nsGkAtoms::kernelUnitLength, 0, 0 }
};
nsSVGElement::IntegerInfo SVGFEConvolveMatrixElement::sIntegerInfo[2] =
{
- { &nsGkAtoms::targetX, 0 },
- { &nsGkAtoms::targetY, 0 }
+ { nsGkAtoms::targetX, 0 },
+ { nsGkAtoms::targetY, 0 }
};
nsSVGElement::IntegerPairInfo SVGFEConvolveMatrixElement::sIntegerPairInfo[1] =
{
- { &nsGkAtoms::order, 3, 3 }
+ { nsGkAtoms::order, 3, 3 }
};
nsSVGElement::BooleanInfo SVGFEConvolveMatrixElement::sBooleanInfo[1] =
{
- { &nsGkAtoms::preserveAlpha, false }
+ { nsGkAtoms::preserveAlpha, false }
};
nsSVGEnumMapping SVGFEConvolveMatrixElement::sEdgeModeMap[] = {
{&nsGkAtoms::duplicate, SVG_EDGEMODE_DUPLICATE},
{&nsGkAtoms::wrap, SVG_EDGEMODE_WRAP},
{&nsGkAtoms::none, SVG_EDGEMODE_NONE},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGFEConvolveMatrixElement::sEnumInfo[1] =
{
- { &nsGkAtoms::edgeMode,
+ { nsGkAtoms::edgeMode,
sEdgeModeMap,
SVG_EDGEMODE_DUPLICATE
}
};
nsSVGElement::StringInfo SVGFEConvolveMatrixElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
nsSVGElement::NumberListInfo SVGFEConvolveMatrixElement::sNumberListInfo[1] =
{
- { &nsGkAtoms::kernelMatrix }
+ { nsGkAtoms::kernelMatrix }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEConvolveMatrixElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFEDisplacementMapElement.cpp
+++ b/dom/svg/SVGFEDisplacementMapElement.cpp
@@ -19,44 +19,44 @@ namespace dom {
JSObject*
SVGFEDisplacementMapElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEDisplacementMapElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFEDisplacementMapElement::sNumberInfo[1] =
{
- { &nsGkAtoms::scale, 0, false },
+ { nsGkAtoms::scale, 0, false },
};
nsSVGEnumMapping SVGFEDisplacementMapElement::sChannelMap[] = {
{&nsGkAtoms::R, SVG_CHANNEL_R},
{&nsGkAtoms::G, SVG_CHANNEL_G},
{&nsGkAtoms::B, SVG_CHANNEL_B},
{&nsGkAtoms::A, SVG_CHANNEL_A},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGFEDisplacementMapElement::sEnumInfo[2] =
{
- { &nsGkAtoms::xChannelSelector,
+ { nsGkAtoms::xChannelSelector,
sChannelMap,
SVG_CHANNEL_A
},
- { &nsGkAtoms::yChannelSelector,
+ { nsGkAtoms::yChannelSelector,
sChannelMap,
SVG_CHANNEL_A
}
};
nsSVGElement::StringInfo SVGFEDisplacementMapElement::sStringInfo[3] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true },
- { &nsGkAtoms::in2, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true },
+ { nsGkAtoms::in2, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEDisplacementMapElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFEDistantLightElement.cpp
+++ b/dom/svg/SVGFEDistantLightElement.cpp
@@ -18,18 +18,18 @@ namespace dom {
JSObject*
SVGFEDistantLightElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEDistantLightElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFEDistantLightElement::sNumberInfo[2] =
{
- { &nsGkAtoms::azimuth, 0, false },
- { &nsGkAtoms::elevation, 0, false }
+ { nsGkAtoms::azimuth, 0, false },
+ { nsGkAtoms::elevation, 0, false }
};
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEDistantLightElement)
--- a/dom/svg/SVGFEDropShadowElement.cpp
+++ b/dom/svg/SVGFEDropShadowElement.cpp
@@ -19,29 +19,29 @@ namespace dom {
JSObject*
SVGFEDropShadowElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEDropShadowElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFEDropShadowElement::sNumberInfo[2] =
{
- { &nsGkAtoms::dx, 2, false },
- { &nsGkAtoms::dy, 2, false }
+ { nsGkAtoms::dx, 2, false },
+ { nsGkAtoms::dy, 2, false }
};
nsSVGElement::NumberPairInfo SVGFEDropShadowElement::sNumberPairInfo[1] =
{
- { &nsGkAtoms::stdDeviation, 2, 2 }
+ { nsGkAtoms::stdDeviation, 2, 2 }
};
nsSVGElement::StringInfo SVGFEDropShadowElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEDropShadowElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFEFloodElement.cpp
+++ b/dom/svg/SVGFEFloodElement.cpp
@@ -21,17 +21,17 @@ namespace dom {
JSObject*
SVGFEFloodElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEFloodElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGFEFloodElement::sStringInfo[1] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEFloodElement)
FilterPrimitiveDescription
--- a/dom/svg/SVGFEGaussianBlurElement.cpp
+++ b/dom/svg/SVGFEGaussianBlurElement.cpp
@@ -19,23 +19,23 @@ namespace dom {
JSObject*
SVGFEGaussianBlurElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEGaussianBlurElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberPairInfo SVGFEGaussianBlurElement::sNumberPairInfo[1] =
{
- { &nsGkAtoms::stdDeviation, 0, 0 }
+ { nsGkAtoms::stdDeviation, 0, 0 }
};
nsSVGElement::StringInfo SVGFEGaussianBlurElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEGaussianBlurElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFEImageElement.cpp
+++ b/dom/svg/SVGFEImageElement.cpp
@@ -29,19 +29,19 @@ namespace dom {
JSObject*
SVGFEImageElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEImageElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGFEImageElement::sStringInfo[3] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_XLink, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_XLink, true }
};
//----------------------------------------------------------------------
// nsISupports methods
NS_IMPL_ISUPPORTS_INHERITED(SVGFEImageElement, SVGFEImageElementBase,
nsIDOMNode, nsIDOMElement,
imgINotificationObserver, nsIImageLoadingContent)
--- a/dom/svg/SVGFEMergeElement.cpp
+++ b/dom/svg/SVGFEMergeElement.cpp
@@ -18,17 +18,17 @@ namespace dom {
JSObject*
SVGFEMergeElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEMergeElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGFEMergeElement::sStringInfo[1] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true }
};
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEMergeElement)
FilterPrimitiveDescription
SVGFEMergeElement::GetPrimitiveDescription(nsSVGFilterInstance* aInstance,
const IntRect& aFilterSubregion,
const nsTArray<bool>& aInputsAreTainted,
--- a/dom/svg/SVGFEMergeNodeElement.cpp
+++ b/dom/svg/SVGFEMergeNodeElement.cpp
@@ -15,17 +15,17 @@ namespace dom {
JSObject*
SVGFEMergeNodeElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEMergeNodeElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGFEMergeNodeElement::sStringInfo[1] =
{
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEMergeNodeElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFEMorphologyElement.cpp
+++ b/dom/svg/SVGFEMorphologyElement.cpp
@@ -18,37 +18,37 @@ namespace dom {
JSObject*
SVGFEMorphologyElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEMorphologyElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberPairInfo SVGFEMorphologyElement::sNumberPairInfo[1] =
{
- { &nsGkAtoms::radius, 0, 0 }
+ { nsGkAtoms::radius, 0, 0 }
};
nsSVGEnumMapping SVGFEMorphologyElement::sOperatorMap[] = {
{&nsGkAtoms::erode, SVG_OPERATOR_ERODE},
{&nsGkAtoms::dilate, SVG_OPERATOR_DILATE},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGFEMorphologyElement::sEnumInfo[1] =
{
- { &nsGkAtoms::_operator,
+ { nsGkAtoms::_operator,
sOperatorMap,
SVG_OPERATOR_ERODE
}
};
nsSVGElement::StringInfo SVGFEMorphologyElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEMorphologyElement)
--- a/dom/svg/SVGFEOffsetElement.cpp
+++ b/dom/svg/SVGFEOffsetElement.cpp
@@ -18,24 +18,24 @@ namespace dom {
JSObject*
SVGFEOffsetElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEOffsetElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFEOffsetElement::sNumberInfo[2] =
{
- { &nsGkAtoms::dx, 0, false },
- { &nsGkAtoms::dy, 0, false }
+ { nsGkAtoms::dx, 0, false },
+ { nsGkAtoms::dy, 0, false }
};
nsSVGElement::StringInfo SVGFEOffsetElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEOffsetElement)
--- a/dom/svg/SVGFEPointLightElement.cpp
+++ b/dom/svg/SVGFEPointLightElement.cpp
@@ -18,19 +18,19 @@ namespace dom {
JSObject*
SVGFEPointLightElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFEPointLightElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFEPointLightElement::sNumberInfo[3] =
{
- { &nsGkAtoms::x, 0, false },
- { &nsGkAtoms::y, 0, false },
- { &nsGkAtoms::z, 0, false }
+ { nsGkAtoms::x, 0, false },
+ { nsGkAtoms::y, 0, false },
+ { nsGkAtoms::z, 0, false }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEPointLightElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFESpotLightElement.cpp
+++ b/dom/svg/SVGFESpotLightElement.cpp
@@ -18,24 +18,24 @@ namespace dom {
JSObject*
SVGFESpotLightElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFESpotLightElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFESpotLightElement::sNumberInfo[8] =
{
- { &nsGkAtoms::x, 0, false },
- { &nsGkAtoms::y, 0, false },
- { &nsGkAtoms::z, 0, false },
- { &nsGkAtoms::pointsAtX, 0, false },
- { &nsGkAtoms::pointsAtY, 0, false },
- { &nsGkAtoms::pointsAtZ, 0, false },
- { &nsGkAtoms::specularExponent, 1, false },
- { &nsGkAtoms::limitingConeAngle, 0, false }
+ { nsGkAtoms::x, 0, false },
+ { nsGkAtoms::y, 0, false },
+ { nsGkAtoms::z, 0, false },
+ { nsGkAtoms::pointsAtX, 0, false },
+ { nsGkAtoms::pointsAtY, 0, false },
+ { nsGkAtoms::pointsAtZ, 0, false },
+ { nsGkAtoms::specularExponent, 1, false },
+ { nsGkAtoms::limitingConeAngle, 0, false }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFESpotLightElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFETileElement.cpp
+++ b/dom/svg/SVGFETileElement.cpp
@@ -18,18 +18,18 @@ namespace dom {
JSObject*
SVGFETileElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFETileElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGFETileElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFETileElement)
--- a/dom/svg/SVGFETurbulenceElement.cpp
+++ b/dom/svg/SVGFETurbulenceElement.cpp
@@ -25,27 +25,27 @@ static const int32_t MAX_OCTAVES = 10;
JSObject*
SVGFETurbulenceElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFETurbulenceElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGFETurbulenceElement::sNumberInfo[1] =
{
- { &nsGkAtoms::seed, 0, false }
+ { nsGkAtoms::seed, 0, false }
};
nsSVGElement::NumberPairInfo SVGFETurbulenceElement::sNumberPairInfo[1] =
{
- { &nsGkAtoms::baseFrequency, 0, 0 }
+ { nsGkAtoms::baseFrequency, 0, 0 }
};
nsSVGElement::IntegerInfo SVGFETurbulenceElement::sIntegerInfo[1] =
{
- { &nsGkAtoms::numOctaves, 1 }
+ { nsGkAtoms::numOctaves, 1 }
};
nsSVGEnumMapping SVGFETurbulenceElement::sTypeMap[] = {
{&nsGkAtoms::fractalNoise,
SVG_TURBULENCE_TYPE_FRACTALNOISE},
{&nsGkAtoms::turbulence,
SVG_TURBULENCE_TYPE_TURBULENCE},
{nullptr, 0}
@@ -56,29 +56,29 @@ nsSVGEnumMapping SVGFETurbulenceElement:
SVG_STITCHTYPE_STITCH},
{&nsGkAtoms::noStitch,
SVG_STITCHTYPE_NOSTITCH},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGFETurbulenceElement::sEnumInfo[2] =
{
- { &nsGkAtoms::type,
+ { nsGkAtoms::type,
sTypeMap,
SVG_TURBULENCE_TYPE_TURBULENCE
},
- { &nsGkAtoms::stitchTiles,
+ { nsGkAtoms::stitchTiles,
sStitchTilesMap,
SVG_STITCHTYPE_NOSTITCH
}
};
nsSVGElement::StringInfo SVGFETurbulenceElement::sStringInfo[1] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFETurbulenceElement)
//----------------------------------------------------------------------
--- a/dom/svg/SVGFilterElement.cpp
+++ b/dom/svg/SVGFilterElement.cpp
@@ -24,38 +24,38 @@ using namespace SVGUnitTypesBinding;
JSObject*
SVGFilterElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGFilterElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGFilterElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x, -10, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::y, -10, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
- { &nsGkAtoms::width, 120, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::height, 120, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::x, -10, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::y, -10, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::width, 120, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::height, 120, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
};
nsSVGElement::EnumInfo SVGFilterElement::sEnumInfo[2] =
{
- { &nsGkAtoms::filterUnits,
+ { nsGkAtoms::filterUnits,
sSVGUnitTypesMap,
SVG_UNIT_TYPE_OBJECTBOUNDINGBOX
},
- { &nsGkAtoms::primitiveUnits,
+ { nsGkAtoms::primitiveUnits,
sSVGUnitTypesMap,
SVG_UNIT_TYPE_USERSPACEONUSE
}
};
nsSVGElement::StringInfo SVGFilterElement::sStringInfo[2] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_XLink, true }
+ { nsGkAtoms::href, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_XLink, true }
};
//----------------------------------------------------------------------
// Implementation
SVGFilterElement::SVGFilterElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGFilterElementBase(aNodeInfo)
{
--- a/dom/svg/SVGForeignObjectElement.cpp
+++ b/dom/svg/SVGForeignObjectElement.cpp
@@ -20,20 +20,20 @@ namespace dom {
JSObject*
SVGForeignObjectElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGForeignObjectElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGForeignObjectElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
};
//----------------------------------------------------------------------
// Implementation
SVGForeignObjectElement::SVGForeignObjectElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGGraphicsElement(aNodeInfo)
{
--- a/dom/svg/SVGGeometryElement.cpp
+++ b/dom/svg/SVGGeometryElement.cpp
@@ -15,17 +15,17 @@
#include "nsSVGLength2.h"
#include "SVGContentUtils.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::dom;
nsSVGElement::NumberInfo SVGGeometryElement::sNumberInfo =
-{ &nsGkAtoms::pathLength, 0, false };
+{ nsGkAtoms::pathLength, 0, false };
//----------------------------------------------------------------------
// Implementation
SVGGeometryElement::SVGGeometryElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGGeometryElementBase(aNodeInfo)
{
}
@@ -65,17 +65,17 @@ SVGGeometryElement::AttributeDefinesGeom
{
if (aName == nsGkAtoms::pathLength) {
return true;
}
// Check for nsSVGLength2 attribute
LengthAttributesInfo info = GetLengthInfo();
for (uint32_t i = 0; i < info.mLengthCount; i++) {
- if (aName == *info.mLengthInfo[i].mName) {
+ if (aName == info.mLengthInfo[i].mName) {
return true;
}
}
return false;
}
bool
--- a/dom/svg/SVGGradientElement.cpp
+++ b/dom/svg/SVGGradientElement.cpp
@@ -32,30 +32,30 @@ nsSVGEnumMapping SVGGradientElement::sSp
{&nsGkAtoms::pad, SVG_SPREADMETHOD_PAD},
{&nsGkAtoms::reflect, SVG_SPREADMETHOD_REFLECT},
{&nsGkAtoms::repeat, SVG_SPREADMETHOD_REPEAT},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGGradientElement::sEnumInfo[2] =
{
- { &nsGkAtoms::gradientUnits,
+ { nsGkAtoms::gradientUnits,
sSVGUnitTypesMap,
SVG_UNIT_TYPE_OBJECTBOUNDINGBOX
},
- { &nsGkAtoms::spreadMethod,
+ { nsGkAtoms::spreadMethod,
sSpreadMethodMap,
SVG_SPREADMETHOD_PAD
}
};
nsSVGElement::StringInfo SVGGradientElement::sStringInfo[2] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_XLink, true }
+ { nsGkAtoms::href, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_XLink, true }
};
//----------------------------------------------------------------------
// Implementation
SVGGradientElement::SVGGradientElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGGradientElementBase(aNodeInfo)
{
@@ -127,20 +127,20 @@ SVGGradientElement::IsAttributeMapped(co
JSObject*
SVGLinearGradientElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGLinearGradientElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGLinearGradientElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x1, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::y1, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
- { &nsGkAtoms::x2, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::y2, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::x1, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::y1, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::x2, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::y2, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
};
//----------------------------------------------------------------------
// Implementation
SVGLinearGradientElement::SVGLinearGradientElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGLinearGradientElementBase(aNodeInfo)
{
@@ -201,22 +201,22 @@ SVGLinearGradientElement::GetLengthInfo(
JSObject*
SVGRadialGradientElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGRadialGradientElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGRadialGradientElement::sLengthInfo[6] =
{
- { &nsGkAtoms::cx, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::cy, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
- { &nsGkAtoms::r, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::XY },
- { &nsGkAtoms::fx, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::fy, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
- { &nsGkAtoms::fr, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::XY },
+ { nsGkAtoms::cx, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::cy, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::r, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::XY },
+ { nsGkAtoms::fx, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::fy, 50, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::fr, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::XY },
};
//----------------------------------------------------------------------
// Implementation
SVGRadialGradientElement::SVGRadialGradientElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGRadialGradientElementBase(aNodeInfo)
{
--- a/dom/svg/SVGGradientElement.h
+++ b/dom/svg/SVGGradientElement.h
@@ -46,17 +46,17 @@ public:
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override = 0;
// nsIContent
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsSVGAnimatedTransformList*
GetAnimatedTransformList(uint32_t aFlags = 0) override;
- virtual nsAtom* GetTransformListAttrName() const override {
+ virtual nsStaticAtom* GetTransformListAttrName() const override {
return nsGkAtoms::gradientTransform;
}
// WebIDL
already_AddRefed<SVGAnimatedEnumeration> GradientUnits();
already_AddRefed<SVGAnimatedTransformList> GradientTransform();
already_AddRefed<SVGAnimatedEnumeration> SpreadMethod();
already_AddRefed<SVGAnimatedString> Href();
--- a/dom/svg/SVGImageElement.cpp
+++ b/dom/svg/SVGImageElement.cpp
@@ -28,26 +28,26 @@ namespace dom {
JSObject*
SVGImageElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGImageElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGImageElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
};
nsSVGElement::StringInfo SVGImageElement::sStringInfo[2] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_XLink, true }
+ { nsGkAtoms::href, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_XLink, true }
};
//----------------------------------------------------------------------
// nsISupports methods
NS_IMPL_ISUPPORTS_INHERITED(SVGImageElement, SVGImageElementBase,
nsIDOMNode, nsIDOMElement,
imgINotificationObserver,
--- a/dom/svg/SVGLineElement.cpp
+++ b/dom/svg/SVGLineElement.cpp
@@ -19,20 +19,20 @@ namespace dom {
JSObject*
SVGLineElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGLineElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGLineElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x1, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::y1, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::x2, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::y2, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::x1, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::y1, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::x2, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::y2, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
};
//----------------------------------------------------------------------
// Implementation
SVGLineElement::SVGLineElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGLineElementBase(aNodeInfo)
{
--- a/dom/svg/SVGMPathElement.cpp
+++ b/dom/svg/SVGMPathElement.cpp
@@ -22,18 +22,18 @@ namespace dom {
JSObject*
SVGMPathElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGMPathElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGMPathElement::sStringInfo[2] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, false },
- { &nsGkAtoms::href, kNameSpaceID_XLink, false }
+ { nsGkAtoms::href, kNameSpaceID_None, false },
+ { nsGkAtoms::href, kNameSpaceID_XLink, false }
};
// Cycle collection magic -- based on SVGUseElement
NS_IMPL_CYCLE_COLLECTION_CLASS(SVGMPathElement)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(SVGMPathElement,
SVGMPathElementBase)
tmp->UnlinkHrefTarget(false);
--- a/dom/svg/SVGMarkerElement.cpp
+++ b/dom/svg/SVGMarkerElement.cpp
@@ -32,39 +32,39 @@ using namespace SVGAngleBinding;
JSObject*
SVGMarkerElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGMarkerElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGMarkerElement::sLengthInfo[4] =
{
- { &nsGkAtoms::refX, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::refY, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::markerWidth, 3, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::markerHeight, 3, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::refX, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::refY, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::markerWidth, 3, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::markerHeight, 3, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
};
nsSVGEnumMapping SVGMarkerElement::sUnitsMap[] = {
{&nsGkAtoms::strokeWidth, SVG_MARKERUNITS_STROKEWIDTH},
{&nsGkAtoms::userSpaceOnUse, SVG_MARKERUNITS_USERSPACEONUSE},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGMarkerElement::sEnumInfo[1] =
{
- { &nsGkAtoms::markerUnits,
+ { nsGkAtoms::markerUnits,
sUnitsMap,
SVG_MARKERUNITS_STROKEWIDTH
}
};
nsSVGElement::AngleInfo SVGMarkerElement::sAngleInfo[1] =
{
- { &nsGkAtoms::orient, 0, SVG_ANGLETYPE_UNSPECIFIED }
+ { nsGkAtoms::orient, 0, SVG_ANGLETYPE_UNSPECIFIED }
};
//----------------------------------------------------------------------
// Implementation
nsresult
nsSVGOrientType::SetBaseValue(uint16_t aValue,
nsSVGElement *aSVGElement)
--- a/dom/svg/SVGMaskElement.cpp
+++ b/dom/svg/SVGMaskElement.cpp
@@ -25,29 +25,29 @@ SVGMaskElement::WrapNode(JSContext *aCx,
{
return SVGMaskElementBinding::Wrap(aCx, this, aGivenProto);
}
//--------------------- Masks ------------------------
nsSVGElement::LengthInfo SVGMaskElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x, -10, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::y, -10, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
- { &nsGkAtoms::width, 120, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::height, 120, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::x, -10, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::y, -10, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::width, 120, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::height, 120, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
};
nsSVGElement::EnumInfo SVGMaskElement::sEnumInfo[2] =
{
- { &nsGkAtoms::maskUnits,
+ { nsGkAtoms::maskUnits,
sSVGUnitTypesMap,
SVG_UNIT_TYPE_OBJECTBOUNDINGBOX
},
- { &nsGkAtoms::maskContentUnits,
+ { nsGkAtoms::maskContentUnits,
sSVGUnitTypesMap,
SVG_UNIT_TYPE_USERSPACEONUSE
}
};
//----------------------------------------------------------------------
// Implementation
--- a/dom/svg/SVGPathElement.h
+++ b/dom/svg/SVGPathElement.h
@@ -59,17 +59,17 @@ public:
// nsIContent interface
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
virtual SVGAnimatedPathSegList* GetAnimPathSegList() override {
return &mD;
}
- virtual nsAtom* GetPathDataAttrName() const override {
+ virtual nsStaticAtom* GetPathDataAttrName() const override {
return nsGkAtoms::d;
}
// WebIDL
uint32_t GetPathSegAtLength(float distance);
already_AddRefed<DOMSVGPathSegClosePath> CreateSVGPathSegClosePath();
already_AddRefed<DOMSVGPathSegMovetoAbs> CreateSVGPathSegMovetoAbs(float x, float y);
already_AddRefed<DOMSVGPathSegMovetoRel> CreateSVGPathSegMovetoRel(float x, float y);
--- a/dom/svg/SVGPatternElement.cpp
+++ b/dom/svg/SVGPatternElement.cpp
@@ -26,38 +26,38 @@ SVGPatternElement::WrapNode(JSContext *a
{
return SVGPatternElementBinding::Wrap(aCx, this, aGivenProto);
}
//--------------------- Patterns ------------------------
nsSVGElement::LengthInfo SVGPatternElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
- { &nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
};
nsSVGElement::EnumInfo SVGPatternElement::sEnumInfo[2] =
{
- { &nsGkAtoms::patternUnits,
+ { nsGkAtoms::patternUnits,
sSVGUnitTypesMap,
SVG_UNIT_TYPE_OBJECTBOUNDINGBOX
},
- { &nsGkAtoms::patternContentUnits,
+ { nsGkAtoms::patternContentUnits,
sSVGUnitTypesMap,
SVG_UNIT_TYPE_USERSPACEONUSE
}
};
nsSVGElement::StringInfo SVGPatternElement::sStringInfo[2] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_XLink, true }
+ { nsGkAtoms::href, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_XLink, true }
};
//----------------------------------------------------------------------
// Implementation
SVGPatternElement::SVGPatternElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGPatternElementBase(aNodeInfo)
{
--- a/dom/svg/SVGPatternElement.h
+++ b/dom/svg/SVGPatternElement.h
@@ -46,17 +46,17 @@ public:
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// nsSVGSVGElement methods:
virtual bool HasValidDimensions() const override;
virtual mozilla::nsSVGAnimatedTransformList*
GetAnimatedTransformList(uint32_t aFlags = 0) override;
- virtual nsAtom* GetTransformListAttrName() const override {
+ virtual nsStaticAtom* GetTransformListAttrName() const override {
return nsGkAtoms::patternTransform;
}
// WebIDL
already_AddRefed<SVGAnimatedRect> ViewBox();
already_AddRefed<DOMSVGAnimatedPreserveAspectRatio> PreserveAspectRatio();
already_AddRefed<SVGAnimatedEnumeration> PatternUnits();
already_AddRefed<SVGAnimatedEnumeration> PatternContentUnits();
--- a/dom/svg/SVGPolyElement.h
+++ b/dom/svg/SVGPolyElement.h
@@ -31,17 +31,17 @@ public:
NS_INLINE_DECL_REFCOUNTING_INHERITED(SVGPolyElement, SVGPolyElementBase)
// nsIContent interface
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* name) const override;
virtual SVGAnimatedPointList* GetAnimatedPointList() override {
return &mPoints;
}
- virtual nsAtom* GetPointListAttrName() const override {
+ virtual nsStaticAtom* GetPointListAttrName() const override {
return nsGkAtoms::points;
}
// nsSVGElement methods:
virtual bool HasValidDimensions() const override;
// SVGGeometryElement methods:
virtual bool AttributeDefinesGeometry(const nsAtom *aName) override;
--- a/dom/svg/SVGRectElement.cpp
+++ b/dom/svg/SVGRectElement.cpp
@@ -26,22 +26,22 @@ class SVGAnimatedLength;
JSObject*
SVGRectElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGRectElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGRectElement::sLengthInfo[6] =
{
- { &nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::rx, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::ry, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y }
+ { nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::rx, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::ry, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y }
};
//----------------------------------------------------------------------
// Implementation
SVGRectElement::SVGRectElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGRectElementBase(aNodeInfo)
{
--- a/dom/svg/SVGSVGElement.cpp
+++ b/dom/svg/SVGSVGElement.cpp
@@ -38,17 +38,17 @@ using namespace SVGSVGElementBinding;
nsSVGEnumMapping SVGSVGElement::sZoomAndPanMap[] = {
{&nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
{&nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGSVGElement::sEnumInfo[1] =
{
- { &nsGkAtoms::zoomAndPan,
+ { nsGkAtoms::zoomAndPan,
sZoomAndPanMap,
SVG_ZOOMANDPAN_MAGNIFY
}
};
NS_IMPL_CYCLE_COLLECTION_INHERITED(DOMSVGTranslatePoint, nsISVGPoint,
mElement)
--- a/dom/svg/SVGScriptElement.cpp
+++ b/dom/svg/SVGScriptElement.cpp
@@ -19,18 +19,18 @@ namespace dom {
JSObject*
SVGScriptElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGScriptElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringInfo SVGScriptElement::sStringInfo[2] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, false },
- { &nsGkAtoms::href, kNameSpaceID_XLink, false }
+ { nsGkAtoms::href, kNameSpaceID_None, false },
+ { nsGkAtoms::href, kNameSpaceID_XLink, false }
};
//----------------------------------------------------------------------
// nsISupports methods
NS_IMPL_ISUPPORTS_INHERITED(SVGScriptElement, SVGScriptElementBase,
nsIDOMNode, nsIDOMElement,
nsIScriptLoaderObserver,
--- a/dom/svg/SVGStopElement.cpp
+++ b/dom/svg/SVGStopElement.cpp
@@ -14,17 +14,17 @@ namespace dom {
JSObject*
SVGStopElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGStopElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::NumberInfo SVGStopElement::sNumberInfo =
-{ &nsGkAtoms::offset, 0, true };
+{ nsGkAtoms::offset, 0, true };
//----------------------------------------------------------------------
// Implementation
SVGStopElement::SVGStopElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGStopElementBase(aNodeInfo)
{
}
--- a/dom/svg/SVGTextContentElement.cpp
+++ b/dom/svg/SVGTextContentElement.cpp
@@ -24,22 +24,22 @@ using namespace SVGTextContentElementBin
nsSVGEnumMapping SVGTextContentElement::sLengthAdjustMap[] = {
{ &nsGkAtoms::spacing, LENGTHADJUST_SPACING },
{ &nsGkAtoms::spacingAndGlyphs, LENGTHADJUST_SPACINGANDGLYPHS },
{ nullptr, 0 }
};
nsSVGElement::EnumInfo SVGTextContentElement::sEnumInfo[1] =
{
- { &nsGkAtoms::lengthAdjust, sLengthAdjustMap, LENGTHADJUST_SPACING }
+ { nsGkAtoms::lengthAdjust, sLengthAdjustMap, LENGTHADJUST_SPACING }
};
nsSVGElement::LengthInfo SVGTextContentElement::sLengthInfo[1] =
{
- { &nsGkAtoms::textLength, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::XY }
+ { nsGkAtoms::textLength, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::XY }
};
SVGTextFrame*
SVGTextContentElement::GetSVGTextFrame()
{
nsIFrame* frame = GetPrimaryFrame(FlushType::Layout);
nsIFrame* textFrame =
nsLayoutUtils::GetClosestFrameOfType(frame, LayoutFrameType::SVGText);
--- a/dom/svg/SVGTextPathElement.cpp
+++ b/dom/svg/SVGTextPathElement.cpp
@@ -26,19 +26,19 @@ JSObject*
SVGTextPathElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGTextPathElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::LengthInfo SVGTextPathElement::sLengthInfo[2] =
{
// from SVGTextContentElement:
- { &nsGkAtoms::textLength, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::XY },
+ { nsGkAtoms::textLength, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::XY },
// from SVGTextPathElement:
- { &nsGkAtoms::startOffset, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X }
+ { nsGkAtoms::startOffset, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X }
};
nsSVGEnumMapping SVGTextPathElement::sMethodMap[] = {
{&nsGkAtoms::align, TEXTPATH_METHODTYPE_ALIGN},
{&nsGkAtoms::stretch, TEXTPATH_METHODTYPE_STRETCH},
{nullptr, 0}
};
@@ -52,39 +52,39 @@ nsSVGEnumMapping SVGTextPathElement::sSi
{&nsGkAtoms::left, TEXTPATH_SIDETYPE_LEFT},
{&nsGkAtoms::right, TEXTPATH_SIDETYPE_RIGHT},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGTextPathElement::sEnumInfo[4] =
{
// from SVGTextContentElement:
- { &nsGkAtoms::lengthAdjust,
+ { nsGkAtoms::lengthAdjust,
sLengthAdjustMap,
LENGTHADJUST_SPACING
},
// from SVGTextPathElement:
- { &nsGkAtoms::method,
+ { nsGkAtoms::method,
sMethodMap,
TEXTPATH_METHODTYPE_ALIGN
},
- { &nsGkAtoms::spacing,
+ { nsGkAtoms::spacing,
sSpacingMap,
TEXTPATH_SPACINGTYPE_EXACT
},
- { &nsGkAtoms::side_,
+ { nsGkAtoms::side_,
sSideMap,
TEXTPATH_SIDETYPE_LEFT
}
};
nsSVGElement::StringInfo SVGTextPathElement::sStringInfo[2] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_XLink, true }
+ { nsGkAtoms::href, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_XLink, true }
};
//----------------------------------------------------------------------
// Implementation
SVGTextPathElement::SVGTextPathElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGTextPathElementBase(aNodeInfo)
{
--- a/dom/svg/SVGTextPathElement.h
+++ b/dom/svg/SVGTextPathElement.h
@@ -44,17 +44,17 @@ public:
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
SVGAnimatedPathSegList* GetAnimPathSegList() override {
return &mPath;
}
- nsAtom* GetPathDataAttrName() const override {
+ nsStaticAtom* GetPathDataAttrName() const override {
return nsGkAtoms::path;
}
// WebIDL
already_AddRefed<SVGAnimatedLength> StartOffset();
already_AddRefed<SVGAnimatedEnumeration> Method();
already_AddRefed<SVGAnimatedEnumeration> Spacing();
already_AddRefed<SVGAnimatedEnumeration> Side();
--- a/dom/svg/SVGTextPositioningElement.cpp
+++ b/dom/svg/SVGTextPositioningElement.cpp
@@ -12,33 +12,33 @@
#include "DOMSVGAnimatedNumberList.h"
#include "SVGContentUtils.h"
namespace mozilla {
namespace dom {
nsSVGElement::LengthListInfo SVGTextPositioningElement::sLengthListInfo[4] =
{
- { &nsGkAtoms::x, SVGContentUtils::X, false },
- { &nsGkAtoms::y, SVGContentUtils::Y, false },
- { &nsGkAtoms::dx, SVGContentUtils::X, true },
- { &nsGkAtoms::dy, SVGContentUtils::Y, true }
+ { nsGkAtoms::x, SVGContentUtils::X, false },
+ { nsGkAtoms::y, SVGContentUtils::Y, false },
+ { nsGkAtoms::dx, SVGContentUtils::X, true },
+ { nsGkAtoms::dy, SVGContentUtils::Y, true }
};
nsSVGElement::LengthListAttributesInfo
SVGTextPositioningElement::GetLengthListInfo()
{
return LengthListAttributesInfo(mLengthListAttributes, sLengthListInfo,
ArrayLength(sLengthListInfo));
}
nsSVGElement::NumberListInfo SVGTextPositioningElement::sNumberListInfo[1] =
{
- { &nsGkAtoms::rotate }
+ { nsGkAtoms::rotate }
};
nsSVGElement::NumberListAttributesInfo
SVGTextPositioningElement::GetNumberListInfo()
{
return NumberListAttributesInfo(mNumberListAttributes, sNumberListInfo,
ArrayLength(sNumberListInfo));
}
--- a/dom/svg/SVGTransformableElement.h
+++ b/dom/svg/SVGTransformableElement.h
@@ -59,17 +59,17 @@ public:
virtual gfxMatrix PrependLocalTransformsTo(
const gfxMatrix &aMatrix,
SVGTransformTypes aWhich = eAllTransforms) const override;
virtual const gfx::Matrix* GetAnimateMotionTransform() const override;
virtual void SetAnimateMotionTransform(const gfx::Matrix* aMatrix) override;
virtual nsSVGAnimatedTransformList*
GetAnimatedTransformList(uint32_t aFlags = 0) override;
- virtual nsAtom* GetTransformListAttrName() const override {
+ virtual nsStaticAtom* GetTransformListAttrName() const override {
return nsGkAtoms::transform;
}
virtual bool IsTransformable() override { return true; }
protected:
/**
* Helper for overrides of PrependLocalTransformsTo. If both arguments are
--- a/dom/svg/SVGUseElement.cpp
+++ b/dom/svg/SVGUseElement.cpp
@@ -32,26 +32,26 @@ SVGUseElement::WrapNode(JSContext *aCx,
return SVGUseElementBinding::Wrap(aCx, this, aGivenProto);
}
////////////////////////////////////////////////////////////////////////
// implementation
nsSVGElement::LengthInfo SVGUseElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::width, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::height, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
};
nsSVGElement::StringInfo SVGUseElement::sStringInfo[2] =
{
- { &nsGkAtoms::href, kNameSpaceID_None, true },
- { &nsGkAtoms::href, kNameSpaceID_XLink, true }
+ { nsGkAtoms::href, kNameSpaceID_None, true },
+ { nsGkAtoms::href, kNameSpaceID_XLink, true }
};
//----------------------------------------------------------------------
// nsISupports methods
NS_IMPL_CYCLE_COLLECTION_CLASS(SVGUseElement)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(SVGUseElement,
@@ -324,17 +324,17 @@ SVGUseElement::SyncWidthOrHeight(nsAtom*
"The clue is in the function name");
NS_ASSERTION(OurWidthAndHeightAreUsed(), "Don't call this");
auto* frame = GetFrame();
nsIContent* clone = frame ? frame->GetContentClone() : nullptr;
if (OurWidthAndHeightAreUsed()) {
auto* target = static_cast<nsSVGElement*>(clone);
- uint32_t index = *sLengthInfo[ATTR_WIDTH].mName == aName ? ATTR_WIDTH : ATTR_HEIGHT;
+ uint32_t index = sLengthInfo[ATTR_WIDTH].mName == aName ? ATTR_WIDTH : ATTR_HEIGHT;
if (mLengthAttributes[index].IsExplicitlySet()) {
target->SetLength(aName, mLengthAttributes[index]);
return;
}
if (clone->IsSVGElement(nsGkAtoms::svg)) {
// Our width/height attribute is now no longer explicitly set, so we
// need to revert the clone's width/height to the width/height of the
--- a/dom/svg/SVGViewElement.cpp
+++ b/dom/svg/SVGViewElement.cpp
@@ -18,28 +18,28 @@ using namespace SVGViewElementBinding;
JSObject*
SVGViewElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
return SVGViewElementBinding::Wrap(aCx, this, aGivenProto);
}
nsSVGElement::StringListInfo SVGViewElement::sStringListInfo[1] =
{
- { &nsGkAtoms::viewTarget }
+ { nsGkAtoms::viewTarget }
};
nsSVGEnumMapping SVGViewElement::sZoomAndPanMap[] = {
{&nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
{&nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGViewElement::sEnumInfo[1] =
{
- { &nsGkAtoms::zoomAndPan,
+ { nsGkAtoms::zoomAndPan,
sZoomAndPanMap,
SVG_ZOOMANDPAN_MAGNIFY
}
};
//----------------------------------------------------------------------
// Implementation
--- a/dom/svg/SVGViewportElement.cpp
+++ b/dom/svg/SVGViewportElement.cpp
@@ -35,20 +35,20 @@
using namespace mozilla::gfx;
namespace mozilla {
namespace dom {
nsSVGElement::LengthInfo SVGViewportElement::sLengthInfo[4] =
{
- { &nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
- { &nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
- { &nsGkAtoms::width, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::height, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
+ { nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
+ { nsGkAtoms::width, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::height, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
};
//----------------------------------------------------------------------
// Implementation
SVGViewportElement::SVGViewportElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: SVGGraphicsElement(aNodeInfo),
mViewportWidth(0),
--- a/dom/svg/nsSVGElement.cpp
+++ b/dom/svg/nsSVGElement.cpp
@@ -331,34 +331,34 @@ nsSVGElement::ParseAttribute(int32_t aNa
bool didSetResult = false;
if (aNamespaceID == kNameSpaceID_None) {
// Check for nsSVGLength2 attribute
LengthAttributesInfo lengthInfo = GetLengthInfo();
uint32_t i;
for (i = 0; i < lengthInfo.mLengthCount; i++) {
- if (aAttribute == *lengthInfo.mLengthInfo[i].mName) {
+ if (aAttribute == lengthInfo.mLengthInfo[i].mName) {
rv = lengthInfo.mLengths[i].SetBaseValueString(aValue, this, false);
if (NS_FAILED(rv)) {
lengthInfo.Reset(i);
} else {
aResult.SetTo(lengthInfo.mLengths[i], &aValue);
didSetResult = true;
}
foundMatch = true;
break;
}
}
if (!foundMatch) {
// Check for SVGAnimatedLengthList attribute
LengthListAttributesInfo lengthListInfo = GetLengthListInfo();
for (i = 0; i < lengthListInfo.mLengthListCount; i++) {
- if (aAttribute == *lengthListInfo.mLengthListInfo[i].mName) {
+ if (aAttribute == lengthListInfo.mLengthListInfo[i].mName) {
rv = lengthListInfo.mLengthLists[i].SetBaseValueString(aValue);
if (NS_FAILED(rv)) {
lengthListInfo.Reset(i);
} else {
aResult.SetTo(lengthListInfo.mLengthLists[i].GetBaseValue(),
&aValue);
didSetResult = true;
}
@@ -367,17 +367,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
}
if (!foundMatch) {
// Check for SVGAnimatedNumberList attribute
NumberListAttributesInfo numberListInfo = GetNumberListInfo();
for (i = 0; i < numberListInfo.mNumberListCount; i++) {
- if (aAttribute == *numberListInfo.mNumberListInfo[i].mName) {
+ if (aAttribute == numberListInfo.mNumberListInfo[i].mName) {
rv = numberListInfo.mNumberLists[i].SetBaseValueString(aValue);
if (NS_FAILED(rv)) {
numberListInfo.Reset(i);
} else {
aResult.SetTo(numberListInfo.mNumberLists[i].GetBaseValue(),
&aValue);
didSetResult = true;
}
@@ -418,17 +418,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
}
if (!foundMatch) {
// Check for nsSVGNumber2 attribute
NumberAttributesInfo numberInfo = GetNumberInfo();
for (i = 0; i < numberInfo.mNumberCount; i++) {
- if (aAttribute == *numberInfo.mNumberInfo[i].mName) {
+ if (aAttribute == numberInfo.mNumberInfo[i].mName) {
rv = numberInfo.mNumbers[i].SetBaseValueString(aValue, this);
if (NS_FAILED(rv)) {
numberInfo.Reset(i);
} else {
aResult.SetTo(numberInfo.mNumbers[i].GetBaseValue(), &aValue);
didSetResult = true;
}
foundMatch = true;
@@ -436,17 +436,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
}
if (!foundMatch) {
// Check for nsSVGNumberPair attribute
NumberPairAttributesInfo numberPairInfo = GetNumberPairInfo();
for (i = 0; i < numberPairInfo.mNumberPairCount; i++) {
- if (aAttribute == *numberPairInfo.mNumberPairInfo[i].mName) {
+ if (aAttribute == numberPairInfo.mNumberPairInfo[i].mName) {
rv = numberPairInfo.mNumberPairs[i].SetBaseValueString(aValue, this);
if (NS_FAILED(rv)) {
numberPairInfo.Reset(i);
} else {
aResult.SetTo(numberPairInfo.mNumberPairs[i], &aValue);
didSetResult = true;
}
foundMatch = true;
@@ -454,17 +454,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
}
if (!foundMatch) {
// Check for nsSVGInteger attribute
IntegerAttributesInfo integerInfo = GetIntegerInfo();
for (i = 0; i < integerInfo.mIntegerCount; i++) {
- if (aAttribute == *integerInfo.mIntegerInfo[i].mName) {
+ if (aAttribute == integerInfo.mIntegerInfo[i].mName) {
rv = integerInfo.mIntegers[i].SetBaseValueString(aValue, this);
if (NS_FAILED(rv)) {
integerInfo.Reset(i);
} else {
aResult.SetTo(integerInfo.mIntegers[i].GetBaseValue(), &aValue);
didSetResult = true;
}
foundMatch = true;
@@ -472,17 +472,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
}
if (!foundMatch) {
// Check for nsSVGIntegerPair attribute
IntegerPairAttributesInfo integerPairInfo = GetIntegerPairInfo();
for (i = 0; i < integerPairInfo.mIntegerPairCount; i++) {
- if (aAttribute == *integerPairInfo.mIntegerPairInfo[i].mName) {
+ if (aAttribute == integerPairInfo.mIntegerPairInfo[i].mName) {
rv =
integerPairInfo.mIntegerPairs[i].SetBaseValueString(aValue, this);
if (NS_FAILED(rv)) {
integerPairInfo.Reset(i);
} else {
aResult.SetTo(integerPairInfo.mIntegerPairs[i], &aValue);
didSetResult = true;
}
@@ -491,17 +491,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
}
if (!foundMatch) {
// Check for nsSVGAngle attribute
AngleAttributesInfo angleInfo = GetAngleInfo();
for (i = 0; i < angleInfo.mAngleCount; i++) {
- if (aAttribute == *angleInfo.mAngleInfo[i].mName) {
+ if (aAttribute == angleInfo.mAngleInfo[i].mName) {
rv = angleInfo.mAngles[i].SetBaseValueString(aValue, this, false);
if (NS_FAILED(rv)) {
angleInfo.Reset(i);
} else {
aResult.SetTo(angleInfo.mAngles[i], &aValue);
didSetResult = true;
}
foundMatch = true;
@@ -509,17 +509,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
}
if (!foundMatch) {
// Check for nsSVGBoolean attribute
BooleanAttributesInfo booleanInfo = GetBooleanInfo();
for (i = 0; i < booleanInfo.mBooleanCount; i++) {
- if (aAttribute == *booleanInfo.mBooleanInfo[i].mName) {
+ if (aAttribute == booleanInfo.mBooleanInfo[i].mName) {
nsAtom *valAtom = NS_GetStaticAtom(aValue);
rv = valAtom ? booleanInfo.mBooleans[i].SetBaseValueAtom(valAtom, this) :
NS_ERROR_DOM_SYNTAX_ERR;
if (NS_FAILED(rv)) {
booleanInfo.Reset(i);
} else {
aResult.SetTo(valAtom);
didSetResult = true;
@@ -529,17 +529,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
}
if (!foundMatch) {
// Check for nsSVGEnum attribute
EnumAttributesInfo enumInfo = GetEnumInfo();
for (i = 0; i < enumInfo.mEnumCount; i++) {
- if (aAttribute == *enumInfo.mEnumInfo[i].mName) {
+ if (aAttribute == enumInfo.mEnumInfo[i].mName) {
RefPtr<nsAtom> valAtom = NS_Atomize(aValue);
rv = enumInfo.mEnums[i].SetBaseValueAtom(valAtom, this);
if (NS_FAILED(rv)) {
enumInfo.Reset(i);
} else {
aResult.SetTo(valAtom);
didSetResult = true;
}
@@ -557,17 +557,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
foundMatch = true;
}
}
if (!foundMatch) {
// Check for StringList attribute
StringListAttributesInfo stringListInfo = GetStringListInfo();
for (i = 0; i < stringListInfo.mStringListCount; i++) {
- if (aAttribute == *stringListInfo.mStringListInfo[i].mName) {
+ if (aAttribute == stringListInfo.mStringListInfo[i].mName) {
rv = stringListInfo.mStringLists[i].SetValue(aValue);
if (NS_FAILED(rv)) {
stringListInfo.Reset(i);
} else {
aResult.SetTo(stringListInfo.mStringLists[i], &aValue);
didSetResult = true;
}
foundMatch = true;
@@ -631,17 +631,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
}
if (!foundMatch) {
// Check for nsSVGString attribute
StringAttributesInfo stringInfo = GetStringInfo();
for (uint32_t i = 0; i < stringInfo.mStringCount; i++) {
if (aNamespaceID == stringInfo.mStringInfo[i].mNamespaceID &&
- aAttribute == *stringInfo.mStringInfo[i].mName) {
+ aAttribute == stringInfo.mStringInfo[i].mName) {
stringInfo.mStrings[i].SetBaseValue(aValue, this, false);
foundMatch = true;
break;
}
}
}
if (foundMatch) {
@@ -681,39 +681,39 @@ nsSVGElement::UnsetAttrInternal(int32_t
}
return;
}
// Check if this is a length attribute going away
LengthAttributesInfo lenInfo = GetLengthInfo();
for (uint32_t i = 0; i < lenInfo.mLengthCount; i++) {
- if (aName == *lenInfo.mLengthInfo[i].mName) {
+ if (aName == lenInfo.mLengthInfo[i].mName) {
MaybeSerializeAttrBeforeRemoval(aName, aNotify);
lenInfo.Reset(i);
return;
}
}
// Check if this is a length list attribute going away
LengthListAttributesInfo lengthListInfo = GetLengthListInfo();
for (uint32_t i = 0; i < lengthListInfo.mLengthListCount; i++) {
- if (aName == *lengthListInfo.mLengthListInfo[i].mName) {
+ if (aName == lengthListInfo.mLengthListInfo[i].mName) {
MaybeSerializeAttrBeforeRemoval(aName, aNotify);
lengthListInfo.Reset(i);
return;
}
}
// Check if this is a number list attribute going away
NumberListAttributesInfo numberListInfo = GetNumberListInfo();
for (uint32_t i = 0; i < numberListInfo.mNumberListCount; i++) {
- if (aName == *numberListInfo.mNumberListInfo[i].mName) {
+ if (aName == numberListInfo.mNumberListInfo[i].mName) {
MaybeSerializeAttrBeforeRemoval(aName, aNotify);
numberListInfo.Reset(i);
return;
}
}
// Check if this is a point list attribute going away
if (GetPointListAttrName() == aName) {
@@ -734,80 +734,80 @@ nsSVGElement::UnsetAttrInternal(int32_t
return;
}
}
// Check if this is a number attribute going away
NumberAttributesInfo numInfo = GetNumberInfo();
for (uint32_t i = 0; i < numInfo.mNumberCount; i++) {
- if (aName == *numInfo.mNumberInfo[i].mName) {
+ if (aName == numInfo.mNumberInfo[i].mName) {
numInfo.Reset(i);
return;
}
}
// Check if this is a number pair attribute going away
NumberPairAttributesInfo numPairInfo = GetNumberPairInfo();
for (uint32_t i = 0; i < numPairInfo.mNumberPairCount; i++) {
- if (aName == *numPairInfo.mNumberPairInfo[i].mName) {
+ if (aName == numPairInfo.mNumberPairInfo[i].mName) {
MaybeSerializeAttrBeforeRemoval(aName, aNotify);
numPairInfo.Reset(i);
return;
}
}
// Check if this is an integer attribute going away
IntegerAttributesInfo intInfo = GetIntegerInfo();
for (uint32_t i = 0; i < intInfo.mIntegerCount; i++) {
- if (aName == *intInfo.mIntegerInfo[i].mName) {
+ if (aName == intInfo.mIntegerInfo[i].mName) {
intInfo.Reset(i);
return;
}
}
// Check if this is an integer pair attribute going away
IntegerPairAttributesInfo intPairInfo = GetIntegerPairInfo();
for (uint32_t i = 0; i < intPairInfo.mIntegerPairCount; i++) {
- if (aName == *intPairInfo.mIntegerPairInfo[i].mName) {
+ if (aName == intPairInfo.mIntegerPairInfo[i].mName) {
MaybeSerializeAttrBeforeRemoval(aName, aNotify);
intPairInfo.Reset(i);
return;
}
}
// Check if this is an angle attribute going away
AngleAttributesInfo angleInfo = GetAngleInfo();
for (uint32_t i = 0; i < angleInfo.mAngleCount; i++) {
- if (aName == *angleInfo.mAngleInfo[i].mName) {
+ if (aName == angleInfo.mAngleInfo[i].mName) {
MaybeSerializeAttrBeforeRemoval(aName, aNotify);
angleInfo.Reset(i);
return;
}
}
// Check if this is a boolean attribute going away
BooleanAttributesInfo boolInfo = GetBooleanInfo();
for (uint32_t i = 0; i < boolInfo.mBooleanCount; i++) {
- if (aName == *boolInfo.mBooleanInfo[i].mName) {
+ if (aName == boolInfo.mBooleanInfo[i].mName) {
boolInfo.Reset(i);
return;
}
}
// Check if this is an enum attribute going away
EnumAttributesInfo enumInfo = GetEnumInfo();
for (uint32_t i = 0; i < enumInfo.mEnumCount; i++) {
- if (aName == *enumInfo.mEnumInfo[i].mName) {
+ if (aName == enumInfo.mEnumInfo[i].mName) {
enumInfo.Reset(i);
return;
}
}
// Check if this is a nsViewBox attribute going away
if (aName == nsGkAtoms::viewBox) {
nsSVGViewBox* viewBox = GetViewBox();
@@ -846,17 +846,17 @@ nsSVGElement::UnsetAttrInternal(int32_t
tests->UnsetAttr(aName);
return;
}
// Check if this is a string list attribute going away
StringListAttributesInfo stringListInfo = GetStringListInfo();
for (uint32_t i = 0; i < stringListInfo.mStringListCount; i++) {
- if (aName == *stringListInfo.mStringListInfo[i].mName) {
+ if (aName == stringListInfo.mStringListInfo[i].mName) {
MaybeSerializeAttrBeforeRemoval(aName, aNotify);
stringListInfo.Reset(i);
return;
}
}
if (aName == nsGkAtoms::_class) {
mClassAttribute.Init();
@@ -864,17 +864,17 @@ nsSVGElement::UnsetAttrInternal(int32_t
}
}
// Check if this is a string attribute going away
StringAttributesInfo stringInfo = GetStringInfo();
for (uint32_t i = 0; i < stringInfo.mStringCount; i++) {
if (aNamespaceID == stringInfo.mStringInfo[i].mNamespaceID &&
- aName == *stringInfo.mStringInfo[i].mName) {
+ aName == stringInfo.mStringInfo[i].mName) {
stringInfo.Reset(i);
return;
}
}
}
nsresult
nsSVGElement::BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
@@ -1516,70 +1516,70 @@ void nsSVGElement::LengthAttributesInfo:
}
void
nsSVGElement::SetLength(nsAtom* aName, const nsSVGLength2 &aLength)
{
LengthAttributesInfo lengthInfo = GetLengthInfo();
for (uint32_t i = 0; i < lengthInfo.mLengthCount; i++) {
- if (aName == *lengthInfo.mLengthInfo[i].mName) {
+ if (aName == lengthInfo.mLengthInfo[i].mName) {
lengthInfo.mLengths[i] = aLength;
DidAnimateLength(i);
return;
}
}
MOZ_ASSERT(false, "no length found to set");
}
nsAttrValue
nsSVGElement::WillChangeLength(uint8_t aAttrEnum)
{
- return WillChangeValue(*GetLengthInfo().mLengthInfo[aAttrEnum].mName);
+ return WillChangeValue(GetLengthInfo().mLengthInfo[aAttrEnum].mName);
}
void
nsSVGElement::DidChangeLength(uint8_t aAttrEnum,
const nsAttrValue& aEmptyOrOldValue)
{
LengthAttributesInfo info = GetLengthInfo();
NS_ASSERTION(info.mLengthCount > 0,
"DidChangeLength on element with no length attribs");
NS_ASSERTION(aAttrEnum < info.mLengthCount, "aAttrEnum out of range");
nsAttrValue newValue;
newValue.SetTo(info.mLengths[aAttrEnum], nullptr);
- DidChangeValue(*info.mLengthInfo[aAttrEnum].mName, aEmptyOrOldValue,
+ DidChangeValue(info.mLengthInfo[aAttrEnum].mName, aEmptyOrOldValue,
newValue);
}
void
nsSVGElement::DidAnimateLength(uint8_t aAttrEnum)
{
ClearAnyCachedPath();
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
LengthAttributesInfo info = GetLengthInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mLengthInfo[aAttrEnum].mName,
+ info.mLengthInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
nsSVGLength2*
nsSVGElement::GetAnimatedLength(const nsAtom *aAttrName)
{
LengthAttributesInfo lengthInfo = GetLengthInfo();
for (uint32_t i = 0; i < lengthInfo.mLengthCount; i++) {
- if (aAttrName == *lengthInfo.mLengthInfo[i].mName) {
+ if (aAttrName == lengthInfo.mLengthInfo[i].mName) {
return &lengthInfo.mLengths[i];
}
}
MOZ_ASSERT(false, "no matching length found");
return nullptr;
}
void
@@ -1627,45 +1627,45 @@ nsSVGElement::LengthListAttributesInfo::
{
mLengthLists[aAttrEnum].ClearBaseValue(aAttrEnum);
// caller notifies
}
nsAttrValue
nsSVGElement::WillChangeLengthList(uint8_t aAttrEnum)
{
- return WillChangeValue(*GetLengthListInfo().mLengthListInfo[aAttrEnum].mName);
+ return WillChangeValue(GetLengthListInfo().mLengthListInfo[aAttrEnum].mName);
}
void
nsSVGElement::DidChangeLengthList(uint8_t aAttrEnum,
const nsAttrValue& aEmptyOrOldValue)
{
LengthListAttributesInfo info = GetLengthListInfo();
NS_ASSERTION(info.mLengthListCount > 0,
"DidChangeLengthList on element with no length list attribs");
NS_ASSERTION(aAttrEnum < info.mLengthListCount, "aAttrEnum out of range");
nsAttrValue newValue;
newValue.SetTo(info.mLengthLists[aAttrEnum].GetBaseValue(), nullptr);
- DidChangeValue(*info.mLengthListInfo[aAttrEnum].mName, aEmptyOrOldValue,
+ DidChangeValue(info.mLengthListInfo[aAttrEnum].mName, aEmptyOrOldValue,
newValue);
}
void
nsSVGElement::DidAnimateLengthList(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
LengthListAttributesInfo info = GetLengthListInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mLengthListInfo[aAttrEnum].mName,
+ info.mLengthListInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
void
nsSVGElement::GetAnimatedLengthListValues(SVGUserUnitList *aFirst, ...)
{
LengthListAttributesInfo info = GetLengthListInfo();
@@ -1712,48 +1712,48 @@ nsSVGElement::NumberListAttributesInfo::
MOZ_ASSERT(aAttrEnum < mNumberListCount, "Bad attr enum");
mNumberLists[aAttrEnum].ClearBaseValue(aAttrEnum);
// caller notifies
}
nsAttrValue
nsSVGElement::WillChangeNumberList(uint8_t aAttrEnum)
{
- return WillChangeValue(*GetNumberListInfo().mNumberListInfo[aAttrEnum].mName);
+ return WillChangeValue(GetNumberListInfo().mNumberListInfo[aAttrEnum].mName);
}
void
nsSVGElement::DidChangeNumberList(uint8_t aAttrEnum,
const nsAttrValue& aEmptyOrOldValue)
{
NumberListAttributesInfo info = GetNumberListInfo();
MOZ_ASSERT(info.mNumberListCount > 0,
"DidChangeNumberList on element with no number list attribs");
MOZ_ASSERT(aAttrEnum < info.mNumberListCount,
"aAttrEnum out of range");
nsAttrValue newValue;
newValue.SetTo(info.mNumberLists[aAttrEnum].GetBaseValue(), nullptr);
- DidChangeValue(*info.mNumberListInfo[aAttrEnum].mName, aEmptyOrOldValue,
+ DidChangeValue(info.mNumberListInfo[aAttrEnum].mName, aEmptyOrOldValue,
newValue);
}
void
nsSVGElement::DidAnimateNumberList(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
NumberListAttributesInfo info = GetNumberListInfo();
MOZ_ASSERT(aAttrEnum < info.mNumberListCount, "aAttrEnum out of range");
frame->AttributeChanged(kNameSpaceID_None,
- *info.mNumberListInfo[aAttrEnum].mName,
+ info.mNumberListInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
SVGAnimatedNumberList*
nsSVGElement::GetAnimatedNumberList(uint8_t aAttrEnum)
{
NumberListAttributesInfo info = GetNumberListInfo();
@@ -1764,17 +1764,17 @@ nsSVGElement::GetAnimatedNumberList(uint
return nullptr;
}
SVGAnimatedNumberList*
nsSVGElement::GetAnimatedNumberList(nsAtom *aAttrName)
{
NumberListAttributesInfo info = GetNumberListInfo();
for (uint32_t i = 0; i < info.mNumberListCount; i++) {
- if (aAttrName == *info.mNumberListInfo[i].mName) {
+ if (aAttrName == info.mNumberListInfo[i].mName) {
return &info.mNumberLists[i];
}
}
MOZ_ASSERT(false, "Bad caller");
return nullptr;
}
nsAttrValue
@@ -1870,29 +1870,29 @@ nsSVGElement::DidChangeNumber(uint8_t aA
NS_ASSERTION(info.mNumberCount > 0,
"DidChangeNumber on element with no number attribs");
NS_ASSERTION(aAttrEnum < info.mNumberCount, "aAttrEnum out of range");
nsAttrValue attrValue;
attrValue.SetTo(info.mNumbers[aAttrEnum].GetBaseValue(), nullptr);
- SetParsedAttr(kNameSpaceID_None, *info.mNumberInfo[aAttrEnum].mName, nullptr,
+ SetParsedAttr(kNameSpaceID_None, info.mNumberInfo[aAttrEnum].mName, nullptr,
attrValue, true);
}
void
nsSVGElement::DidAnimateNumber(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
NumberAttributesInfo info = GetNumberInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mNumberInfo[aAttrEnum].mName,
+ info.mNumberInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
void
nsSVGElement::GetAnimatedNumberValues(float *aFirst, ...)
{
NumberAttributesInfo info = GetNumberInfo();
@@ -1924,45 +1924,45 @@ void nsSVGElement::NumberPairAttributesI
mNumberPairs[aAttrEnum].Init(aAttrEnum,
mNumberPairInfo[aAttrEnum].mDefaultValue1,
mNumberPairInfo[aAttrEnum].mDefaultValue2);
}
nsAttrValue
nsSVGElement::WillChangeNumberPair(uint8_t aAttrEnum)
{
- return WillChangeValue(*GetNumberPairInfo().mNumberPairInfo[aAttrEnum].mName);
+ return WillChangeValue(GetNumberPairInfo().mNumberPairInfo[aAttrEnum].mName);
}
void
nsSVGElement::DidChangeNumberPair(uint8_t aAttrEnum,
const nsAttrValue& aEmptyOrOldValue)
{
NumberPairAttributesInfo info = GetNumberPairInfo();
NS_ASSERTION(info.mNumberPairCount > 0,
"DidChangePairNumber on element with no number pair attribs");
NS_ASSERTION(aAttrEnum < info.mNumberPairCount, "aAttrEnum out of range");
nsAttrValue newValue;
newValue.SetTo(info.mNumberPairs[aAttrEnum], nullptr);
- DidChangeValue(*info.mNumberPairInfo[aAttrEnum].mName, aEmptyOrOldValue,
+ DidChangeValue(info.mNumberPairInfo[aAttrEnum].mName, aEmptyOrOldValue,
newValue);
}
void
nsSVGElement::DidAnimateNumberPair(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
NumberPairAttributesInfo info = GetNumberPairInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mNumberPairInfo[aAttrEnum].mName,
+ info.mNumberPairInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
nsSVGElement::IntegerAttributesInfo
nsSVGElement::GetIntegerInfo()
{
return IntegerAttributesInfo(nullptr, nullptr, 0);
@@ -1981,29 +1981,29 @@ nsSVGElement::DidChangeInteger(uint8_t a
NS_ASSERTION(info.mIntegerCount > 0,
"DidChangeInteger on element with no integer attribs");
NS_ASSERTION(aAttrEnum < info.mIntegerCount, "aAttrEnum out of range");
nsAttrValue attrValue;
attrValue.SetTo(info.mIntegers[aAttrEnum].GetBaseValue(), nullptr);
- SetParsedAttr(kNameSpaceID_None, *info.mIntegerInfo[aAttrEnum].mName, nullptr,
+ SetParsedAttr(kNameSpaceID_None, info.mIntegerInfo[aAttrEnum].mName, nullptr,
attrValue, true);
}
void
nsSVGElement::DidAnimateInteger(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
IntegerAttributesInfo info = GetIntegerInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mIntegerInfo[aAttrEnum].mName,
+ info.mIntegerInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
void
nsSVGElement::GetAnimatedIntegerValues(int32_t *aFirst, ...)
{
IntegerAttributesInfo info = GetIntegerInfo();
@@ -2036,45 +2036,45 @@ void nsSVGElement::IntegerPairAttributes
mIntegerPairInfo[aAttrEnum].mDefaultValue1,
mIntegerPairInfo[aAttrEnum].mDefaultValue2);
}
nsAttrValue
nsSVGElement::WillChangeIntegerPair(uint8_t aAttrEnum)
{
return WillChangeValue(
- *GetIntegerPairInfo().mIntegerPairInfo[aAttrEnum].mName);
+ GetIntegerPairInfo().mIntegerPairInfo[aAttrEnum].mName);
}
void
nsSVGElement::DidChangeIntegerPair(uint8_t aAttrEnum,
const nsAttrValue& aEmptyOrOldValue)
{
IntegerPairAttributesInfo info = GetIntegerPairInfo();
NS_ASSERTION(info.mIntegerPairCount > 0,
"DidChangeIntegerPair on element with no integer pair attribs");
NS_ASSERTION(aAttrEnum < info.mIntegerPairCount, "aAttrEnum out of range");
nsAttrValue newValue;
newValue.SetTo(info.mIntegerPairs[aAttrEnum], nullptr);
- DidChangeValue(*info.mIntegerPairInfo[aAttrEnum].mName, aEmptyOrOldValue,
+ DidChangeValue(info.mIntegerPairInfo[aAttrEnum].mName, aEmptyOrOldValue,
newValue);
}
void
nsSVGElement::DidAnimateIntegerPair(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
IntegerPairAttributesInfo info = GetIntegerPairInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mIntegerPairInfo[aAttrEnum].mName,
+ info.mIntegerPairInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
nsSVGElement::AngleAttributesInfo
nsSVGElement::GetAngleInfo()
{
return AngleAttributesInfo(nullptr, nullptr, 0);
@@ -2085,44 +2085,44 @@ void nsSVGElement::AngleAttributesInfo::
mAngles[aAttrEnum].Init(aAttrEnum,
mAngleInfo[aAttrEnum].mDefaultValue,
mAngleInfo[aAttrEnum].mDefaultUnitType);
}
nsAttrValue
nsSVGElement::WillChangeAngle(uint8_t aAttrEnum)
{
- return WillChangeValue(*GetAngleInfo().mAngleInfo[aAttrEnum].mName);
+ return WillChangeValue(GetAngleInfo().mAngleInfo[aAttrEnum].mName);
}
void
nsSVGElement::DidChangeAngle(uint8_t aAttrEnum,
const nsAttrValue& aEmptyOrOldValue)
{
AngleAttributesInfo info = GetAngleInfo();
NS_ASSERTION(info.mAngleCount > 0,
"DidChangeAngle on element with no angle attribs");
NS_ASSERTION(aAttrEnum < info.mAngleCount, "aAttrEnum out of range");
nsAttrValue newValue;
newValue.SetTo(info.mAngles[aAttrEnum], nullptr);
- DidChangeValue(*info.mAngleInfo[aAttrEnum].mName, aEmptyOrOldValue, newValue);
+ DidChangeValue(info.mAngleInfo[aAttrEnum].mName, aEmptyOrOldValue, newValue);
}
void
nsSVGElement::DidAnimateAngle(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
AngleAttributesInfo info = GetAngleInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mAngleInfo[aAttrEnum].mName,
+ info.mAngleInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
nsSVGElement::BooleanAttributesInfo
nsSVGElement::GetBooleanInfo()
{
return BooleanAttributesInfo(nullptr, nullptr, 0);
@@ -2139,29 +2139,29 @@ nsSVGElement::DidChangeBoolean(uint8_t a
{
BooleanAttributesInfo info = GetBooleanInfo();
NS_ASSERTION(info.mBooleanCount > 0,
"DidChangeBoolean on element with no boolean attribs");
NS_ASSERTION(aAttrEnum < info.mBooleanCount, "aAttrEnum out of range");
nsAttrValue attrValue(info.mBooleans[aAttrEnum].GetBaseValueAtom());
- SetParsedAttr(kNameSpaceID_None, *info.mBooleanInfo[aAttrEnum].mName, nullptr,
+ SetParsedAttr(kNameSpaceID_None, info.mBooleanInfo[aAttrEnum].mName, nullptr,
attrValue, true);
}
void
nsSVGElement::DidAnimateBoolean(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
BooleanAttributesInfo info = GetBooleanInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mBooleanInfo[aAttrEnum].mName,
+ info.mBooleanInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
nsSVGElement::EnumAttributesInfo
nsSVGElement::GetEnumInfo()
{
return EnumAttributesInfo(nullptr, nullptr, 0);
@@ -2178,29 +2178,29 @@ nsSVGElement::DidChangeEnum(uint8_t aAtt
{
EnumAttributesInfo info = GetEnumInfo();
NS_ASSERTION(info.mEnumCount > 0,
"DidChangeEnum on element with no enum attribs");
NS_ASSERTION(aAttrEnum < info.mEnumCount, "aAttrEnum out of range");
nsAttrValue attrValue(info.mEnums[aAttrEnum].GetBaseValueAtom(this));
- SetParsedAttr(kNameSpaceID_None, *info.mEnumInfo[aAttrEnum].mName, nullptr,
+ SetParsedAttr(kNameSpaceID_None, info.mEnumInfo[aAttrEnum].mName, nullptr,
attrValue, true);
}
void
nsSVGElement::DidAnimateEnum(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
EnumAttributesInfo info = GetEnumInfo();
frame->AttributeChanged(kNameSpaceID_None,
- *info.mEnumInfo[aAttrEnum].mName,
+ info.mEnumInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
nsSVGViewBox *
nsSVGElement::GetViewBox()
{
return nullptr;
@@ -2341,41 +2341,41 @@ void nsSVGElement::GetStringBaseValue(ui
nsSVGElement::StringAttributesInfo info = const_cast<nsSVGElement*>(this)->GetStringInfo();
NS_ASSERTION(info.mStringCount > 0,
"GetBaseValue on element with no string attribs");
NS_ASSERTION(aAttrEnum < info.mStringCount, "aAttrEnum out of range");
GetAttr(info.mStringInfo[aAttrEnum].mNamespaceID,
- *info.mStringInfo[aAttrEnum].mName, aResult);
+ info.mStringInfo[aAttrEnum].mName, aResult);
}
void nsSVGElement::SetStringBaseValue(uint8_t aAttrEnum, const nsAString& aValue)
{
nsSVGElement::StringAttributesInfo info = GetStringInfo();
NS_ASSERTION(info.mStringCount > 0,
"SetBaseValue on element with no string attribs");
NS_ASSERTION(aAttrEnum < info.mStringCount, "aAttrEnum out of range");
SetAttr(info.mStringInfo[aAttrEnum].mNamespaceID,
- *info.mStringInfo[aAttrEnum].mName, aValue, true);
+ info.mStringInfo[aAttrEnum].mName, aValue, true);
}
void
nsSVGElement::DidAnimateString(uint8_t aAttrEnum)
{
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
StringAttributesInfo info = GetStringInfo();
frame->AttributeChanged(info.mStringInfo[aAttrEnum].mNamespaceID,
- *info.mStringInfo[aAttrEnum].mName,
+ info.mStringInfo[aAttrEnum].mName,
MutationEventBinding::SMIL);
}
}
nsSVGElement::StringListAttributesInfo
nsSVGElement::GetStringListInfo()
{
return StringListAttributesInfo(nullptr, nullptr, 0);
@@ -2385,17 +2385,17 @@ nsAttrValue
nsSVGElement::WillChangeStringList(bool aIsConditionalProcessingAttribute,
uint8_t aAttrEnum)
{
nsAtom* name;
if (aIsConditionalProcessingAttribute) {
nsCOMPtr<SVGTests> tests(do_QueryInterface(static_cast<nsIDOMElement*>(this)));
name = tests->GetAttrName(aAttrEnum);
} else {
- name = *GetStringListInfo().mStringListInfo[aAttrEnum].mName;
+ name = GetStringListInfo().mStringListInfo[aAttrEnum].mName;
}
return WillChangeValue(name);
}
void
nsSVGElement::DidChangeStringList(bool aIsConditionalProcessingAttribute,
uint8_t aAttrEnum,
const nsAttrValue& aEmptyOrOldValue)
@@ -2410,17 +2410,17 @@ nsSVGElement::DidChangeStringList(bool a
tests->GetAttrValue(aAttrEnum, newValue);
} else {
StringListAttributesInfo info = GetStringListInfo();
NS_ASSERTION(info.mStringListCount > 0,
"DidChangeStringList on element with no string list attribs");
NS_ASSERTION(aAttrEnum < info.mStringListCount, "aAttrEnum out of range");
- name = *info.mStringListInfo[aAttrEnum].mName;
+ name = info.mStringListInfo[aAttrEnum].mName;
newValue.SetTo(info.mStringLists[aAttrEnum], nullptr);
}
DidChangeValue(name, aEmptyOrOldValue, newValue);
if (aIsConditionalProcessingAttribute) {
tests->MaybeInvalidate();
}
@@ -2483,86 +2483,86 @@ nsSVGElement::GetAnimatedAttr(int32_t aN
// Motion (fake 'attribute' for animateMotion)
if (aName == nsGkAtoms::mozAnimateMotionDummyAttr) {
return MakeUnique<SVGMotionSMILAttr>(this);
}
// Lengths:
LengthAttributesInfo info = GetLengthInfo();
for (uint32_t i = 0; i < info.mLengthCount; i++) {
- if (aName == *info.mLengthInfo[i].mName) {
+ if (aName == info.mLengthInfo[i].mName) {
return info.mLengths[i].ToSMILAttr(this);
}
}
// Numbers:
{
NumberAttributesInfo info = GetNumberInfo();
for (uint32_t i = 0; i < info.mNumberCount; i++) {
- if (aName == *info.mNumberInfo[i].mName) {
+ if (aName == info.mNumberInfo[i].mName) {
return info.mNumbers[i].ToSMILAttr(this);
}
}
}
// Number Pairs:
{
NumberPairAttributesInfo info = GetNumberPairInfo();
for (uint32_t i = 0; i < info.mNumberPairCount; i++) {
- if (aName == *info.mNumberPairInfo[i].mName) {
+ if (aName == info.mNumberPairInfo[i].mName) {
return info.mNumberPairs[i].ToSMILAttr(this);
}
}
}
// Integers:
{
IntegerAttributesInfo info = GetIntegerInfo();
for (uint32_t i = 0; i < info.mIntegerCount; i++) {
- if (aName == *info.mIntegerInfo[i].mName) {
+ if (aName == info.mIntegerInfo[i].mName) {
return info.mIntegers[i].ToSMILAttr(this);
}
}
}
// Integer Pairs:
{
IntegerPairAttributesInfo info = GetIntegerPairInfo();
for (uint32_t i = 0; i < info.mIntegerPairCount; i++) {
- if (aName == *info.mIntegerPairInfo[i].mName) {
+ if (aName == info.mIntegerPairInfo[i].mName) {
return info.mIntegerPairs[i].ToSMILAttr(this);
}
}
}
// Enumerations:
{
EnumAttributesInfo info = GetEnumInfo();
for (uint32_t i = 0; i < info.mEnumCount; i++) {
- if (aName == *info.mEnumInfo[i].mName) {
+ if (aName == info.mEnumInfo[i].mName) {
return info.mEnums[i].ToSMILAttr(this);
}
}
}
// Booleans:
{
BooleanAttributesInfo info = GetBooleanInfo();
for (uint32_t i = 0; i < info.mBooleanCount; i++) {
- if (aName == *info.mBooleanInfo[i].mName) {
+ if (aName == info.mBooleanInfo[i].mName) {
return info.mBooleans[i].ToSMILAttr(this);
}
}
}
// Angles:
{
AngleAttributesInfo info = GetAngleInfo();
for (uint32_t i = 0; i < info.mAngleCount; i++) {
- if (aName == *info.mAngleInfo[i].mName) {
+ if (aName == info.mAngleInfo[i].mName) {
return info.mAngles[i].ToSMILAttr(this);
}
}
}
// viewBox:
if (aName == nsGkAtoms::viewBox) {
nsSVGViewBox *viewBox = GetViewBox();
@@ -2576,28 +2576,28 @@ nsSVGElement::GetAnimatedAttr(int32_t aN
return preserveAspectRatio ?
preserveAspectRatio->ToSMILAttr(this) : nullptr;
}
// NumberLists:
{
NumberListAttributesInfo info = GetNumberListInfo();
for (uint32_t i = 0; i < info.mNumberListCount; i++) {
- if (aName == *info.mNumberListInfo[i].mName) {
+ if (aName == info.mNumberListInfo[i].mName) {
MOZ_ASSERT(i <= UCHAR_MAX, "Too many attributes");
return info.mNumberLists[i].ToSMILAttr(this, uint8_t(i));
}
}
}
// LengthLists:
{
LengthListAttributesInfo info = GetLengthListInfo();
for (uint32_t i = 0; i < info.mLengthListCount; i++) {
- if (aName == *info.mLengthListInfo[i].mName) {
+ if (aName == info.mLengthListInfo[i].mName) {
MOZ_ASSERT(i <= UCHAR_MAX, "Too many attributes");
return info.mLengthLists[i].ToSMILAttr(this,
uint8_t(i),
info.mLengthListInfo[i].mAxis,
info.mLengthListInfo[i].mCouldZeroPadList);
}
}
}
@@ -2627,17 +2627,17 @@ nsSVGElement::GetAnimatedAttr(int32_t aN
}
}
// Strings
{
StringAttributesInfo info = GetStringInfo();
for (uint32_t i = 0; i < info.mStringCount; i++) {
if (aNamespaceID == info.mStringInfo[i].mNamespaceID &&
- aName == *info.mStringInfo[i].mName) {
+ aName == info.mStringInfo[i].mName) {
return info.mStrings[i].ToSMILAttr(this);
}
}
}
return nullptr;
}
--- a/dom/svg/nsSVGElement.h
+++ b/dom/svg/nsSVGElement.h
@@ -285,23 +285,23 @@ public:
void AnimationNeedsResample();
void FlushAnimations();
virtual void RecompileScriptEventListeners() override;
void GetStringBaseValue(uint8_t aAttrEnum, nsAString& aResult) const;
void SetStringBaseValue(uint8_t aAttrEnum, const nsAString& aValue);
- virtual nsAtom* GetPointListAttrName() const {
+ virtual nsStaticAtom* GetPointListAttrName() const {
return nullptr;
}
- virtual nsAtom* GetPathDataAttrName() const {
+ virtual nsStaticAtom* GetPathDataAttrName() const {
return nullptr;
}
- virtual nsAtom* GetTransformListAttrName() const {
+ virtual nsStaticAtom* GetTransformListAttrName() const {
return nullptr;
}
const nsAttrValue* GetAnimatedClassName() const
{
if (!mClassAttribute.IsAnimated()) {
return nullptr;
}
return mClassAnimAttr;
@@ -344,265 +344,266 @@ protected:
nsAttrValue& aResult) override;
static nsresult ReportAttributeParseFailure(nsIDocument* aDocument,
nsAtom* aAttribute,
const nsAString& aValue);
nsAttrValue WillChangeValue(nsAtom* aName);
// aNewValue is set to the old value. This value may be invalid if
// !StoresOwnData.
- void DidChangeValue(nsAtom* aName, const nsAttrValue& aEmptyOrOldValue,
+ void DidChangeValue(nsAtom* aName,
+ const nsAttrValue& aEmptyOrOldValue,
nsAttrValue& aNewValue);
void MaybeSerializeAttrBeforeRemoval(nsAtom* aName, bool aNotify);
static nsAtom* GetEventNameForAttr(nsAtom* aAttr);
struct LengthInfo {
- nsStaticAtom** mName;
- float mDefaultValue;
- uint8_t mDefaultUnitType;
- uint8_t mCtxType;
+ nsStaticAtom* const mName;
+ const float mDefaultValue;
+ const uint8_t mDefaultUnitType;
+ const uint8_t mCtxType;
};
struct LengthAttributesInfo {
- nsSVGLength2* mLengths;
- LengthInfo* mLengthInfo;
- uint32_t mLengthCount;
+ nsSVGLength2* const mLengths;
+ const LengthInfo* const mLengthInfo;
+ const uint32_t mLengthCount;
LengthAttributesInfo(nsSVGLength2 *aLengths,
LengthInfo *aLengthInfo,
uint32_t aLengthCount) :
mLengths(aLengths), mLengthInfo(aLengthInfo), mLengthCount(aLengthCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct NumberInfo {
- nsStaticAtom** mName;
- float mDefaultValue;
- bool mPercentagesAllowed;
+ nsStaticAtom* const mName;
+ const float mDefaultValue;
+ const bool mPercentagesAllowed;
};
struct NumberAttributesInfo {
- nsSVGNumber2* mNumbers;
- NumberInfo* mNumberInfo;
- uint32_t mNumberCount;
+ nsSVGNumber2* const mNumbers;
+ const NumberInfo* const mNumberInfo;
+ const uint32_t mNumberCount;
NumberAttributesInfo(nsSVGNumber2 *aNumbers,
NumberInfo *aNumberInfo,
uint32_t aNumberCount) :
mNumbers(aNumbers), mNumberInfo(aNumberInfo), mNumberCount(aNumberCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct NumberPairInfo {
- nsStaticAtom** mName;
- float mDefaultValue1;
- float mDefaultValue2;
+ nsStaticAtom* const mName;
+ const float mDefaultValue1;
+ const float mDefaultValue2;
};
struct NumberPairAttributesInfo {
- nsSVGNumberPair* mNumberPairs;
- NumberPairInfo* mNumberPairInfo;
- uint32_t mNumberPairCount;
+ nsSVGNumberPair* const mNumberPairs;
+ const NumberPairInfo* const mNumberPairInfo;
+ const uint32_t mNumberPairCount;
NumberPairAttributesInfo(nsSVGNumberPair *aNumberPairs,
NumberPairInfo *aNumberPairInfo,
uint32_t aNumberPairCount) :
mNumberPairs(aNumberPairs), mNumberPairInfo(aNumberPairInfo),
mNumberPairCount(aNumberPairCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct IntegerInfo {
- nsStaticAtom** mName;
- int32_t mDefaultValue;
+ nsStaticAtom* const mName;
+ const int32_t mDefaultValue;
};
struct IntegerAttributesInfo {
- nsSVGInteger* mIntegers;
- IntegerInfo* mIntegerInfo;
- uint32_t mIntegerCount;
+ nsSVGInteger* const mIntegers;
+ const IntegerInfo* const mIntegerInfo;
+ const uint32_t mIntegerCount;
IntegerAttributesInfo(nsSVGInteger *aIntegers,
IntegerInfo *aIntegerInfo,
uint32_t aIntegerCount) :
mIntegers(aIntegers), mIntegerInfo(aIntegerInfo), mIntegerCount(aIntegerCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct IntegerPairInfo {
- nsStaticAtom** mName;
- int32_t mDefaultValue1;
- int32_t mDefaultValue2;
+ nsStaticAtom* const mName;
+ const int32_t mDefaultValue1;
+ const int32_t mDefaultValue2;
};
struct IntegerPairAttributesInfo {
- nsSVGIntegerPair* mIntegerPairs;
- IntegerPairInfo* mIntegerPairInfo;
- uint32_t mIntegerPairCount;
+ nsSVGIntegerPair* const mIntegerPairs;
+ const IntegerPairInfo* const mIntegerPairInfo;
+ const uint32_t mIntegerPairCount;
IntegerPairAttributesInfo(nsSVGIntegerPair *aIntegerPairs,
IntegerPairInfo *aIntegerPairInfo,
uint32_t aIntegerPairCount) :
mIntegerPairs(aIntegerPairs), mIntegerPairInfo(aIntegerPairInfo),
mIntegerPairCount(aIntegerPairCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct AngleInfo {
- nsStaticAtom** mName;
- float mDefaultValue;
- uint8_t mDefaultUnitType;
+ nsStaticAtom* const mName;
+ const float mDefaultValue;
+ const uint8_t mDefaultUnitType;
};
struct AngleAttributesInfo {
- nsSVGAngle* mAngles;
- AngleInfo* mAngleInfo;
- uint32_t mAngleCount;
+ nsSVGAngle* const mAngles;
+ const AngleInfo* const mAngleInfo;
+ const uint32_t mAngleCount;
AngleAttributesInfo(nsSVGAngle *aAngles,
AngleInfo *aAngleInfo,
uint32_t aAngleCount) :
mAngles(aAngles), mAngleInfo(aAngleInfo), mAngleCount(aAngleCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct BooleanInfo {
- nsStaticAtom** mName;
- bool mDefaultValue;
+ nsStaticAtom* const mName;
+ const bool mDefaultValue;
};
struct BooleanAttributesInfo {
- nsSVGBoolean* mBooleans;
- BooleanInfo* mBooleanInfo;
- uint32_t mBooleanCount;
+ nsSVGBoolean* const mBooleans;
+ const BooleanInfo* const mBooleanInfo;
+ const uint32_t mBooleanCount;
BooleanAttributesInfo(nsSVGBoolean *aBooleans,
BooleanInfo *aBooleanInfo,
uint32_t aBooleanCount) :
mBooleans(aBooleans), mBooleanInfo(aBooleanInfo), mBooleanCount(aBooleanCount)
{}
void Reset(uint8_t aAttrEnum);
};
friend class nsSVGEnum;
struct EnumInfo {
- nsStaticAtom** mName;
- nsSVGEnumMapping* mMapping;
- uint16_t mDefaultValue;
+ nsStaticAtom* const mName;
+ const nsSVGEnumMapping* const mMapping;
+ const uint16_t mDefaultValue;
};
struct EnumAttributesInfo {
- nsSVGEnum* mEnums;
- EnumInfo* mEnumInfo;
- uint32_t mEnumCount;
+ nsSVGEnum* const mEnums;
+ const EnumInfo* const mEnumInfo;
+ const uint32_t mEnumCount;
EnumAttributesInfo(nsSVGEnum *aEnums,
EnumInfo *aEnumInfo,
uint32_t aEnumCount) :
mEnums(aEnums), mEnumInfo(aEnumInfo), mEnumCount(aEnumCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct NumberListInfo {
- nsStaticAtom** mName;
+ nsStaticAtom* const mName;
};
struct NumberListAttributesInfo {
- SVGAnimatedNumberList* mNumberLists;
- NumberListInfo* mNumberListInfo;
- uint32_t mNumberListCount;
+ SVGAnimatedNumberList* const mNumberLists;
+ const NumberListInfo* const mNumberListInfo;
+ const uint32_t mNumberListCount;
NumberListAttributesInfo(SVGAnimatedNumberList *aNumberLists,
NumberListInfo *aNumberListInfo,
uint32_t aNumberListCount)
: mNumberLists(aNumberLists)
, mNumberListInfo(aNumberListInfo)
, mNumberListCount(aNumberListCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct LengthListInfo {
- nsStaticAtom** mName;
- uint8_t mAxis;
+ nsStaticAtom* const mName;
+ const uint8_t mAxis;
/**
* Flag to indicate whether appending zeros to the end of the list would
* change the rendering of the SVG for the attribute in question. For x and
* y on the <text> element this is true, but for dx and dy on <text> this
* is false. This flag is fed down to SVGLengthListSMILType so it can
* determine if it can sensibly animate from-to lists of different lengths,
* which is desirable in the case of dx and dy.
*/
- bool mCouldZeroPadList;
+ const bool mCouldZeroPadList;
};
struct LengthListAttributesInfo {
- SVGAnimatedLengthList* mLengthLists;
- LengthListInfo* mLengthListInfo;
- uint32_t mLengthListCount;
+ SVGAnimatedLengthList* const mLengthLists;
+ const LengthListInfo* const mLengthListInfo;
+ const uint32_t mLengthListCount;
LengthListAttributesInfo(SVGAnimatedLengthList *aLengthLists,
LengthListInfo *aLengthListInfo,
uint32_t aLengthListCount)
: mLengthLists(aLengthLists)
, mLengthListInfo(aLengthListInfo)
, mLengthListCount(aLengthListCount)
{}
void Reset(uint8_t aAttrEnum);
};
struct StringInfo {
- nsStaticAtom** mName;
- int32_t mNamespaceID;
- bool mIsAnimatable;
+ nsStaticAtom* const mName;
+ const int32_t mNamespaceID;
+ const bool mIsAnimatable;
};
struct StringAttributesInfo {
- nsSVGString* mStrings;
- StringInfo* mStringInfo;
- uint32_t mStringCount;
+ nsSVGString* const mStrings;
+ const StringInfo* const mStringInfo;
+ const uint32_t mStringCount;
StringAttributesInfo(nsSVGString *aStrings,
StringInfo *aStringInfo,
uint32_t aStringCount) :
mStrings(aStrings), mStringInfo(aStringInfo), mStringCount(aStringCount)
{}
void Reset(uint8_t aAttrEnum);
};
friend class mozilla::DOMSVGStringList;
struct StringListInfo {
- nsStaticAtom** mName;
+ nsStaticAtom* const mName;
};
struct StringListAttributesInfo {
- SVGStringList* mStringLists;
- StringListInfo* mStringListInfo;
- uint32_t mStringListCount;
+ SVGStringList* const mStringLists;
+ const StringListInfo* const mStringListInfo;
+ const uint32_t mStringListCount;
StringListAttributesInfo(SVGStringList *aStringLists,
StringListInfo *aStringListInfo,
uint32_t aStringListCount) :
mStringLists(aStringLists), mStringListInfo(aStringListInfo),
mStringListCount(aStringListCount)
{}
--- a/dom/svg/nsSVGEnum.cpp
+++ b/dom/svg/nsSVGEnum.cpp
@@ -13,31 +13,31 @@
#include "SMILEnumType.h"
using namespace mozilla;
using namespace mozilla::dom;
static nsSVGAttrTearoffTable<nsSVGEnum, nsSVGEnum::DOMAnimatedEnum>
sSVGAnimatedEnumTearoffTable;
-nsSVGEnumMapping *
+const nsSVGEnumMapping*
nsSVGEnum::GetMapping(nsSVGElement *aSVGElement)
{
nsSVGElement::EnumAttributesInfo info = aSVGElement->GetEnumInfo();
NS_ASSERTION(info.mEnumCount > 0 && mAttrEnum < info.mEnumCount,
"mapping request for a non-attrib enum");
return info.mEnumInfo[mAttrEnum].mMapping;
}
nsresult
nsSVGEnum::SetBaseValueAtom(const nsAtom* aValue, nsSVGElement *aSVGElement)
{
- nsSVGEnumMapping *mapping = GetMapping(aSVGElement);
+ const nsSVGEnumMapping* mapping = GetMapping(aSVGElement);
while (mapping && mapping->mKey) {
if (aValue == *(mapping->mKey)) {
mIsBaseSet = true;
if (mBaseVal != mapping->mVal) {
mBaseVal = mapping->mVal;
if (!mIsAnimated) {
mAnimVal = mBaseVal;
@@ -57,33 +57,33 @@ nsSVGEnum::SetBaseValueAtom(const nsAtom
// only a warning since authors may mistype attribute values
NS_WARNING("unknown enumeration key");
return NS_ERROR_DOM_SYNTAX_ERR;
}
nsAtom*
nsSVGEnum::GetBaseValueAtom(nsSVGElement *aSVGElement)
{
- nsSVGEnumMapping *mapping = GetMapping(aSVGElement);
+ const nsSVGEnumMapping* mapping = GetMapping(aSVGElement);
while (mapping && mapping->mKey) {
if (mBaseVal == mapping->mVal) {
return *mapping->mKey;
}
mapping++;
}
NS_ERROR("unknown enumeration value");
return nsGkAtoms::_empty;
}
nsresult
nsSVGEnum::SetBaseValue(uint16_t aValue,
nsSVGElement *aSVGElement)
{
- nsSVGEnumMapping *mapping = GetMapping(aSVGElement);
+ const nsSVGEnumMapping* mapping = GetMapping(aSVGElement);
while (mapping && mapping->mKey) {
if (mapping->mVal == aValue) {
mIsBaseSet = true;
if (mBaseVal != uint8_t(aValue)) {
mBaseVal = uint8_t(aValue);
if (!mIsAnimated) {
mAnimVal = mBaseVal;
@@ -138,17 +138,17 @@ nsSVGEnum::ToSMILAttr(nsSVGElement *aSVG
nsresult
nsSVGEnum::SMILEnum::ValueFromString(const nsAString& aStr,
const dom::SVGAnimationElement* /*aSrcElement*/,
nsSMILValue& aValue,
bool& aPreventCachingOfSandwich) const
{
nsAtom *valAtom = NS_GetStaticAtom(aStr);
if (valAtom) {
- nsSVGEnumMapping *mapping = mVal->GetMapping(mSVGElement);
+ const nsSVGEnumMapping* mapping = mVal->GetMapping(mSVGElement);
while (mapping && mapping->mKey) {
if (valAtom == *(mapping->mKey)) {
nsSMILValue val(SMILEnumType::Singleton());
val.mU.mUint = mapping->mVal;
aValue = val;
aPreventCachingOfSandwich = false;
return NS_OK;
--- a/dom/svg/nsSVGEnum.h
+++ b/dom/svg/nsSVGEnum.h
@@ -61,17 +61,17 @@ public:
private:
nsSVGEnumValue mAnimVal;
nsSVGEnumValue mBaseVal;
uint8_t mAttrEnum; // element specified tracking for attribute
bool mIsAnimated;
bool mIsBaseSet;
- nsSVGEnumMapping *GetMapping(nsSVGElement *aSVGElement);
+ const nsSVGEnumMapping* GetMapping(nsSVGElement *aSVGElement);
public:
struct DOMAnimatedEnum final : public mozilla::dom::SVGAnimatedEnumeration
{
DOMAnimatedEnum(nsSVGEnum* aVal, nsSVGElement *aSVGElement)
: mozilla::dom::SVGAnimatedEnumeration(aSVGElement)
, mVal(aVal)
{}
--- a/dom/svg/nsSVGFilters.cpp
+++ b/dom/svg/nsSVGFilters.cpp
@@ -48,20 +48,20 @@
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::gfx;
//--------------------Filter Element Base Class-----------------------
nsSVGElement::LengthInfo nsSVGFE::sLengthInfo[4] =
{
- { &nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
- { &nsGkAtoms::width, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
- { &nsGkAtoms::height, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y }
+ { nsGkAtoms::x, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::y, 0, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
+ { nsGkAtoms::width, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
+ { nsGkAtoms::height, 100, SVGLengthBinding::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y }
};
//----------------------------------------------------------------------
// nsISupports methods
NS_IMPL_ADDREF_INHERITED(nsSVGFE,nsSVGFEBase)
NS_IMPL_RELEASE_INHERITED(nsSVGFE,nsSVGFEBase)
@@ -199,26 +199,26 @@ nsSVGFE::GetLengthInfo()
ArrayLength(sLengthInfo));
}
namespace mozilla {
namespace dom {
nsSVGElement::NumberListInfo SVGComponentTransferFunctionElement::sNumberListInfo[1] =
{
- { &nsGkAtoms::tableValues }
+ { nsGkAtoms::tableValues }
};
nsSVGElement::NumberInfo SVGComponentTransferFunctionElement::sNumberInfo[5] =
{
- { &nsGkAtoms::slope, 1, false },
- { &nsGkAtoms::intercept, 0, false },
- { &nsGkAtoms::amplitude, 1, false },
- { &nsGkAtoms::exponent, 1, false },
- { &nsGkAtoms::offset, 0, false }
+ { nsGkAtoms::slope, 1, false },
+ { nsGkAtoms::intercept, 0, false },
+ { nsGkAtoms::amplitude, 1, false },
+ { nsGkAtoms::exponent, 1, false },
+ { nsGkAtoms::offset, 0, false }
};
nsSVGEnumMapping SVGComponentTransferFunctionElement::sTypeMap[] = {
{&nsGkAtoms::identity,
SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY},
{&nsGkAtoms::table,
SVG_FECOMPONENTTRANSFER_TYPE_TABLE},
{&nsGkAtoms::discrete,
@@ -227,17 +227,17 @@ nsSVGEnumMapping SVGComponentTransferFun
SVG_FECOMPONENTTRANSFER_TYPE_LINEAR},
{&nsGkAtoms::gamma,
SVG_FECOMPONENTTRANSFER_TYPE_GAMMA},
{nullptr, 0}
};
nsSVGElement::EnumInfo SVGComponentTransferFunctionElement::sEnumInfo[1] =
{
- { &nsGkAtoms::type,
+ { nsGkAtoms::type,
sTypeMap,
SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY
}
};
//----------------------------------------------------------------------
// nsISupports methods
@@ -432,31 +432,31 @@ NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGFEFun
} // namespace dom
} // namespace mozilla
//--------------------------------------------------------------------
//
nsSVGElement::NumberInfo nsSVGFELightingElement::sNumberInfo[4] =
{
- { &nsGkAtoms::surfaceScale, 1, false },
- { &nsGkAtoms::diffuseConstant, 1, false },
- { &nsGkAtoms::specularConstant, 1, false },
- { &nsGkAtoms::specularExponent, 1, false }
+ { nsGkAtoms::surfaceScale, 1, false },
+ { nsGkAtoms::diffuseConstant, 1, false },
+ { nsGkAtoms::specularConstant, 1, false },
+ { nsGkAtoms::specularExponent, 1, false }
};
nsSVGElement::NumberPairInfo nsSVGFELightingElement::sNumberPairInfo[1] =
{
- { &nsGkAtoms::kernelUnitLength, 0, 0 }
+ { nsGkAtoms::kernelUnitLength, 0, 0 }
};
nsSVGElement::StringInfo nsSVGFELightingElement::sStringInfo[2] =
{
- { &nsGkAtoms::result, kNameSpaceID_None, true },
- { &nsGkAtoms::in, kNameSpaceID_None, true }
+ { nsGkAtoms::result, kNameSpaceID_None, true },
+ { nsGkAtoms::in, kNameSpaceID_None, true }
};
//----------------------------------------------------------------------
// Implementation
NS_IMETHODIMP_(bool)
nsSVGFELightingElement::IsAttributeMapped(const nsAtom* name) const
{