Add m-esr52 at 52.6.0

1 files changed, 724 insertions, 0 deletions

diff --git a/dom/svg/nsSVGElement.h b/dom/svg/nsSVGElement.h
new file mode 100644
index 000000000..42bc05746
--- /dev/null
+++ b/dom/svg/nsSVGElement.h
@@ -0,0 +1,724 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __NS_SVGELEMENT_H__
+#define __NS_SVGELEMENT_H__
+
+/*
+  nsSVGElement is the base class for all SVG content elements.
+  It implements all the common DOM interfaces and handles attributes.
+*/
+
+#include "mozilla/Attributes.h"
+#include "mozilla/css/StyleRule.h"
+#include "nsAutoPtr.h"
+#include "nsChangeHint.h"
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsError.h"
+#include "mozilla/dom/DOMRect.h"
+#include "mozilla/dom/ElementInlines.h"
+#include "nsISupportsImpl.h"
+#include "nsStyledElement.h"
+#include "nsSVGClass.h"
+#include "nsIDOMSVGElement.h"
+#include "SVGContentUtils.h"
+
+class nsSVGAngle;
+class nsSVGBoolean;
+class nsSVGEnum;
+class nsSVGInteger;
+class nsSVGIntegerPair;
+class nsSVGLength2;
+class nsSVGNumber2;
+class nsSVGNumberPair;
+class nsSVGString;
+class nsSVGViewBox;
+
+namespace mozilla {
+namespace dom {
+class SVGSVGElement;
+
+static const unsigned short SVG_UNIT_TYPE_UNKNOWN           = 0;
+static const unsigned short SVG_UNIT_TYPE_USERSPACEONUSE    = 1;
+static const unsigned short SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2;
+
+} // namespace dom
+
+class SVGAnimatedNumberList;
+class SVGNumberList;
+class SVGAnimatedLengthList;
+class SVGUserUnitList;
+class SVGAnimatedPointList;
+class SVGAnimatedPathSegList;
+class SVGAnimatedPreserveAspectRatio;
+class nsSVGAnimatedTransformList;
+class SVGStringList;
+class DOMSVGStringList;
+
+namespace gfx {
+class Matrix;
+} // namespace gfx
+
+} // namespace mozilla
+
+class gfxMatrix;
+struct nsSVGEnumMapping;
+
+typedef nsStyledElement nsSVGElementBase;
+
+class nsSVGElement : public nsSVGElementBase    // nsIContent
+                   , public nsIDOMSVGElement
+{
+protected:
+  explicit nsSVGElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
+  friend nsresult NS_NewSVGElement(mozilla::dom::Element **aResult,
+                                   already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
+  nsresult Init();
+  virtual ~nsSVGElement(){}
+
+public:
+
+  virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const MOZ_MUST_OVERRIDE override;
+
+  typedef mozilla::SVGNumberList SVGNumberList;
+  typedef mozilla::SVGAnimatedNumberList SVGAnimatedNumberList;
+  typedef mozilla::SVGUserUnitList SVGUserUnitList;
+  typedef mozilla::SVGAnimatedLengthList SVGAnimatedLengthList;
+  typedef mozilla::SVGAnimatedPointList SVGAnimatedPointList;
+  typedef mozilla::SVGAnimatedPathSegList SVGAnimatedPathSegList;
+  typedef mozilla::SVGAnimatedPreserveAspectRatio SVGAnimatedPreserveAspectRatio;
+  typedef mozilla::nsSVGAnimatedTransformList nsSVGAnimatedTransformList;
+  typedef mozilla::SVGStringList SVGStringList;
+
+  // nsISupports
+  NS_DECL_ISUPPORTS_INHERITED
+
+  void DidAnimateClass();
+
+  // nsIContent interface methods
+
+  virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
+                              nsIContent* aBindingParent,
+                              bool aCompileEventHandlers) override;
+
+  virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
+                             bool aNotify) override;
+
+  virtual nsChangeHint GetAttributeChangeHint(const nsIAtom* aAttribute,
+                                              int32_t aModType) const override;
+
+  virtual bool IsNodeOfType(uint32_t aFlags) const override;
+
+  NS_IMETHOD WalkContentStyleRules(nsRuleWalker* aRuleWalker) override;
+  void WalkAnimatedContentStyleRules(nsRuleWalker* aRuleWalker);
+
+  NS_IMETHOD_(bool) IsAttributeMapped(const nsIAtom* aAttribute) const override;
+
+  static const MappedAttributeEntry sFillStrokeMap[];
+  static const MappedAttributeEntry sGraphicsMap[];
+  static const MappedAttributeEntry sTextContentElementsMap[];
+  static const MappedAttributeEntry sFontSpecificationMap[];
+  static const MappedAttributeEntry sGradientStopMap[];
+  static const MappedAttributeEntry sViewportsMap[];
+  static const MappedAttributeEntry sMarkersMap[];
+  static const MappedAttributeEntry sColorMap[];
+  static const MappedAttributeEntry sFiltersMap[];
+  static const MappedAttributeEntry sFEFloodMap[];
+  static const MappedAttributeEntry sLightingEffectsMap[];
+  static const MappedAttributeEntry sMaskMap[];
+
+  NS_FORWARD_NSIDOMNODE_TO_NSINODE
+  NS_FORWARD_NSIDOMELEMENT_TO_GENERIC
+  NS_DECL_NSIDOMSVGELEMENT
+
+  // Gets the element that establishes the rectangular viewport against which
+  // we should resolve percentage lengths (our "coordinate context"). Returns
+  // nullptr for outer <svg> or SVG without an <svg> parent (invalid SVG).
+  mozilla::dom::SVGSVGElement* GetCtx() const;
+
+  /**
+   * Returns aMatrix pre-multiplied by (explicit or implicit) transforms that
+   * are introduced by attributes on this element.
+   *
+   * If aWhich is eAllTransforms, then all the transforms from the coordinate
+   * space established by this element for its children to the coordinate
+   * space established by this element's parent element for this element, are
+   * included.
+   *
+   * If aWhich is eUserSpaceToParent, then only the transforms from this
+   * element's userspace to the coordinate space established by its parent is
+   * included. This includes any transforms introduced by the 'transform'
+   * attribute, transform animations and animateMotion, but not any offsets
+   * due to e.g. 'x'/'y' attributes, or any transform due to a 'viewBox'
+   * attribute. (SVG userspace is defined to be the coordinate space in which
+   * coordinates on an element apply.)
+   *
+   * If aWhich is eChildToUserSpace, then only the transforms from the
+   * coordinate space established by this element for its childre to this
+   * elements userspace are included. This includes any offsets due to e.g.
+   * 'x'/'y' attributes, and any transform due to a 'viewBox' attribute, but
+   * does not include any transforms due to the 'transform' attribute.
+   */
+  virtual gfxMatrix PrependLocalTransformsTo(
+    const gfxMatrix &aMatrix, SVGTransformTypes aWhich = eAllTransforms) const;
+
+  // Setter for to set the current <animateMotion> transformation
+  // Only visible for nsSVGGraphicElement, so it's a no-op here, and that
+  // subclass has the useful implementation.
+  virtual void SetAnimateMotionTransform(const mozilla::gfx::Matrix* aMatrix) {/*no-op*/}
+  virtual const mozilla::gfx::Matrix* GetAnimateMotionTransform() const { return nullptr; }
+
+  bool IsStringAnimatable(uint8_t aAttrEnum) {
+    return GetStringInfo().mStringInfo[aAttrEnum].mIsAnimatable;
+  }
+  bool NumberAttrAllowsPercentage(uint8_t aAttrEnum) {
+    return GetNumberInfo().mNumberInfo[aAttrEnum].mPercentagesAllowed;
+  }
+  virtual bool HasValidDimensions() const {
+    return true;
+  }
+  void SetLength(nsIAtom* aName, const nsSVGLength2 &aLength);
+
+  nsAttrValue WillChangeLength(uint8_t aAttrEnum);
+  nsAttrValue WillChangeNumberPair(uint8_t aAttrEnum);
+  nsAttrValue WillChangeIntegerPair(uint8_t aAttrEnum);
+  nsAttrValue WillChangeAngle(uint8_t aAttrEnum);
+  nsAttrValue WillChangeViewBox();
+  nsAttrValue WillChangePreserveAspectRatio();
+  nsAttrValue WillChangeNumberList(uint8_t aAttrEnum);
+  nsAttrValue WillChangeLengthList(uint8_t aAttrEnum);
+  nsAttrValue WillChangePointList();
+  nsAttrValue WillChangePathSegList();
+  nsAttrValue WillChangeTransformList();
+  nsAttrValue WillChangeStringList(bool aIsConditionalProcessingAttribute,
+                                   uint8_t aAttrEnum);
+
+  void DidChangeLength(uint8_t aAttrEnum, const nsAttrValue& aEmptyOrOldValue);
+  void DidChangeNumber(uint8_t aAttrEnum);
+  void DidChangeNumberPair(uint8_t aAttrEnum,
+                           const nsAttrValue& aEmptyOrOldValue);
+  void DidChangeInteger(uint8_t aAttrEnum);
+  void DidChangeIntegerPair(uint8_t aAttrEnum,
+                            const nsAttrValue& aEmptyOrOldValue);
+  void DidChangeAngle(uint8_t aAttrEnum, const nsAttrValue& aEmptyOrOldValue);
+  void DidChangeBoolean(uint8_t aAttrEnum);
+  void DidChangeEnum(uint8_t aAttrEnum);
+  void DidChangeViewBox(const nsAttrValue& aEmptyOrOldValue);
+  void DidChangePreserveAspectRatio(const nsAttrValue& aEmptyOrOldValue);
+  void DidChangeNumberList(uint8_t aAttrEnum,
+                           const nsAttrValue& aEmptyOrOldValue);
+  void DidChangeLengthList(uint8_t aAttrEnum,
+                           const nsAttrValue& aEmptyOrOldValue);
+  void DidChangePointList(const nsAttrValue& aEmptyOrOldValue);
+  void DidChangePathSegList(const nsAttrValue& aEmptyOrOldValue);
+  void DidChangeTransformList(const nsAttrValue& aEmptyOrOldValue);
+  void DidChangeString(uint8_t aAttrEnum) {}
+  void DidChangeStringList(bool aIsConditionalProcessingAttribute,
+                           uint8_t aAttrEnum,
+                           const nsAttrValue& aEmptyOrOldValue);
+
+  void DidAnimateLength(uint8_t aAttrEnum);
+  void DidAnimateNumber(uint8_t aAttrEnum);
+  void DidAnimateNumberPair(uint8_t aAttrEnum);
+  void DidAnimateInteger(uint8_t aAttrEnum);
+  void DidAnimateIntegerPair(uint8_t aAttrEnum);
+  void DidAnimateAngle(uint8_t aAttrEnum);
+  void DidAnimateBoolean(uint8_t aAttrEnum);
+  void DidAnimateEnum(uint8_t aAttrEnum);
+  void DidAnimateViewBox();
+  void DidAnimatePreserveAspectRatio();
+  void DidAnimateNumberList(uint8_t aAttrEnum);
+  void DidAnimateLengthList(uint8_t aAttrEnum);
+  void DidAnimatePointList();
+  void DidAnimatePathSegList();
+  void DidAnimateTransformList(int32_t aModType);
+  void DidAnimateString(uint8_t aAttrEnum);
+
+  enum {
+    /**
+     * Flag to indicate to GetAnimatedXxx() methods that the object being
+     * requested should be allocated if it hasn't already been allocated, and
+     * that the method should not return null. Only applicable to methods that
+     * need to allocate the object that they return.
+     */
+    DO_ALLOCATE = 0x1
+  };
+
+  nsSVGLength2* GetAnimatedLength(const nsIAtom *aAttrName);
+  void GetAnimatedLengthValues(float *aFirst, ...);
+  void GetAnimatedNumberValues(float *aFirst, ...);
+  void GetAnimatedIntegerValues(int32_t *aFirst, ...);
+  SVGAnimatedNumberList* GetAnimatedNumberList(uint8_t aAttrEnum);
+  SVGAnimatedNumberList* GetAnimatedNumberList(nsIAtom *aAttrName);
+  void GetAnimatedLengthListValues(SVGUserUnitList *aFirst, ...);
+  SVGAnimatedLengthList* GetAnimatedLengthList(uint8_t aAttrEnum);
+  virtual SVGAnimatedPointList* GetAnimatedPointList() {
+    return nullptr;
+  }
+  virtual SVGAnimatedPathSegList* GetAnimPathSegList() {
+    // DOM interface 'SVGAnimatedPathData' (*inherited* by nsSVGPathElement)
+    // has a member called 'animatedPathSegList' member, so we have a shorter
+    // name so we don't get hidden by the GetAnimatedPathSegList declared by
+    // NS_DECL_NSIDOMSVGANIMATEDPATHDATA.
+    return nullptr;
+  }
+  /**
+   * Get the nsSVGAnimatedTransformList for this element.
+   *
+   * Despite the fact that animated transform lists are used for a variety of
+   * attributes, no SVG element uses more than one.
+   *
+   * It's relatively uncommon for elements to have their transform attribute
+   * set, so to save memory the nsSVGAnimatedTransformList is not allocated until
+   * the attribute is set/animated or its DOM wrapper is created. Callers that
+   * require the nsSVGAnimatedTransformList to be allocated and for this method
+   * to return non-null must pass the DO_ALLOCATE flag.
+   */
+  virtual nsSVGAnimatedTransformList* GetAnimatedTransformList(
+                                                        uint32_t aFlags = 0) {
+    return nullptr;
+  }
+
+  virtual nsISMILAttr* GetAnimatedAttr(int32_t aNamespaceID, nsIAtom* aName) override;
+  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 nsIAtom* GetPointListAttrName() const {
+    return nullptr;
+  }
+  virtual nsIAtom* GetPathDataAttrName() const {
+    return nullptr;
+  }
+  virtual nsIAtom* GetTransformListAttrName() const {
+    return nullptr;
+  }
+  const nsAttrValue* GetAnimatedClassName() const
+  {
+    if (!mClassAttribute.IsAnimated()) {
+      return nullptr;
+    }
+    return mClassAnimAttr;
+  }
+
+  virtual void ClearAnyCachedPath() {}
+  virtual nsIDOMNode* AsDOMNode() final override { return this; }
+  virtual bool IsTransformable() { return false; }
+
+  // WebIDL
+  mozilla::dom::SVGSVGElement* GetOwnerSVGElement();
+  nsSVGElement* GetViewportElement();
+  already_AddRefed<mozilla::dom::SVGAnimatedString> ClassName();
+  virtual bool IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse) override;
+
+protected:
+  virtual JSObject* WrapNode(JSContext *cx, JS::Handle<JSObject*> aGivenProto) override;
+
+#ifdef DEBUG
+  // We define BeforeSetAttr here and mark it final to ensure it is NOT used
+  // by SVG elements.
+  // This is because we're not currently passing the correct value for aValue to
+  // BeforeSetAttr since it would involve allocating extra SVG value types.
+  // See the comment in nsSVGElement::WillChangeValue.
+  virtual nsresult BeforeSetAttr(int32_t aNamespaceID, nsIAtom* aName,
+                                 nsAttrValueOrString* aValue,
+                                 bool aNotify) override final
+  {
+    return nsSVGElementBase::BeforeSetAttr(aNamespaceID, aName, aValue, aNotify);
+  }
+#endif // DEBUG
+  virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName,
+                                const nsAttrValue* aValue, bool aNotify) override;
+  virtual bool ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute,
+                                const nsAString& aValue, nsAttrValue& aResult) override;
+  static nsresult ReportAttributeParseFailure(nsIDocument* aDocument,
+                                              nsIAtom* aAttribute,
+                                              const nsAString& aValue);
+
+  void UpdateContentStyleRule();
+  void UpdateAnimatedContentStyleRule();
+  mozilla::css::StyleRule* GetAnimatedContentStyleRule();
+
+  nsAttrValue WillChangeValue(nsIAtom* aName);
+  // aNewValue is set to the old value. This value may be invalid if
+  // !StoresOwnData.
+  void DidChangeValue(nsIAtom* aName, const nsAttrValue& aEmptyOrOldValue,
+                      nsAttrValue& aNewValue);
+  void MaybeSerializeAttrBeforeRemoval(nsIAtom* aName, bool aNotify);
+
+  static nsIAtom* GetEventNameForAttr(nsIAtom* aAttr);
+
+  struct LengthInfo {
+    nsIAtom** mName;
+    float     mDefaultValue;
+    uint8_t   mDefaultUnitType;
+    uint8_t   mCtxType;
+  };
+
+  struct LengthAttributesInfo {
+    nsSVGLength2* mLengths;
+    LengthInfo*   mLengthInfo;
+    uint32_t      mLengthCount;
+
+    LengthAttributesInfo(nsSVGLength2 *aLengths,
+                         LengthInfo *aLengthInfo,
+                         uint32_t aLengthCount) :
+      mLengths(aLengths), mLengthInfo(aLengthInfo), mLengthCount(aLengthCount)
+      {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct NumberInfo {
+    nsIAtom** mName;
+    float     mDefaultValue;
+    bool mPercentagesAllowed;
+  };
+
+  struct NumberAttributesInfo {
+    nsSVGNumber2* mNumbers;
+    NumberInfo*   mNumberInfo;
+    uint32_t      mNumberCount;
+
+    NumberAttributesInfo(nsSVGNumber2 *aNumbers,
+                         NumberInfo *aNumberInfo,
+                         uint32_t aNumberCount) :
+      mNumbers(aNumbers), mNumberInfo(aNumberInfo), mNumberCount(aNumberCount)
+      {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct NumberPairInfo {
+    nsIAtom** mName;
+    float     mDefaultValue1;
+    float     mDefaultValue2;
+  };
+
+  struct NumberPairAttributesInfo {
+    nsSVGNumberPair* mNumberPairs;
+    NumberPairInfo*  mNumberPairInfo;
+    uint32_t         mNumberPairCount;
+
+    NumberPairAttributesInfo(nsSVGNumberPair *aNumberPairs,
+                             NumberPairInfo *aNumberPairInfo,
+                             uint32_t aNumberPairCount) :
+      mNumberPairs(aNumberPairs), mNumberPairInfo(aNumberPairInfo),
+      mNumberPairCount(aNumberPairCount)
+      {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct IntegerInfo {
+    nsIAtom** mName;
+    int32_t   mDefaultValue;
+  };
+
+  struct IntegerAttributesInfo {
+    nsSVGInteger* mIntegers;
+    IntegerInfo*  mIntegerInfo;
+    uint32_t      mIntegerCount;
+
+    IntegerAttributesInfo(nsSVGInteger *aIntegers,
+                          IntegerInfo *aIntegerInfo,
+                          uint32_t aIntegerCount) :
+      mIntegers(aIntegers), mIntegerInfo(aIntegerInfo), mIntegerCount(aIntegerCount)
+      {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct IntegerPairInfo {
+    nsIAtom** mName;
+    int32_t   mDefaultValue1;
+    int32_t   mDefaultValue2;
+  };
+
+  struct IntegerPairAttributesInfo {
+    nsSVGIntegerPair* mIntegerPairs;
+    IntegerPairInfo*  mIntegerPairInfo;
+    uint32_t          mIntegerPairCount;
+
+    IntegerPairAttributesInfo(nsSVGIntegerPair *aIntegerPairs,
+                              IntegerPairInfo *aIntegerPairInfo,
+                              uint32_t aIntegerPairCount) :
+      mIntegerPairs(aIntegerPairs), mIntegerPairInfo(aIntegerPairInfo),
+      mIntegerPairCount(aIntegerPairCount)
+      {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct AngleInfo {
+    nsIAtom** mName;
+    float     mDefaultValue;
+    uint8_t   mDefaultUnitType;
+  };
+
+  struct AngleAttributesInfo {
+    nsSVGAngle* mAngles;
+    AngleInfo*  mAngleInfo;
+    uint32_t    mAngleCount;
+
+    AngleAttributesInfo(nsSVGAngle *aAngles,
+                        AngleInfo *aAngleInfo,
+                        uint32_t aAngleCount) :
+      mAngles(aAngles), mAngleInfo(aAngleInfo), mAngleCount(aAngleCount)
+      {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct BooleanInfo {
+    nsIAtom**    mName;
+    bool mDefaultValue;
+  };
+
+  struct BooleanAttributesInfo {
+    nsSVGBoolean* mBooleans;
+    BooleanInfo*  mBooleanInfo;
+    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 {
+    nsIAtom**         mName;
+    nsSVGEnumMapping* mMapping;
+    uint16_t          mDefaultValue;
+  };
+
+  struct EnumAttributesInfo {
+    nsSVGEnum* mEnums;
+    EnumInfo*  mEnumInfo;
+    uint32_t   mEnumCount;
+
+    EnumAttributesInfo(nsSVGEnum *aEnums,
+                       EnumInfo *aEnumInfo,
+                       uint32_t aEnumCount) :
+      mEnums(aEnums), mEnumInfo(aEnumInfo), mEnumCount(aEnumCount)
+      {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct NumberListInfo {
+    nsIAtom** mName;
+  };
+
+  struct NumberListAttributesInfo {
+    SVGAnimatedNumberList* mNumberLists;
+    NumberListInfo*        mNumberListInfo;
+    uint32_t               mNumberListCount;
+
+    NumberListAttributesInfo(SVGAnimatedNumberList *aNumberLists,
+                             NumberListInfo *aNumberListInfo,
+                             uint32_t aNumberListCount)
+      : mNumberLists(aNumberLists)
+      , mNumberListInfo(aNumberListInfo)
+      , mNumberListCount(aNumberListCount)
+    {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct LengthListInfo {
+    nsIAtom** mName;
+    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;
+  };
+
+  struct LengthListAttributesInfo {
+    SVGAnimatedLengthList* mLengthLists;
+    LengthListInfo*        mLengthListInfo;
+    uint32_t               mLengthListCount;
+
+    LengthListAttributesInfo(SVGAnimatedLengthList *aLengthLists,
+                             LengthListInfo *aLengthListInfo,
+                             uint32_t aLengthListCount)
+      : mLengthLists(aLengthLists)
+      , mLengthListInfo(aLengthListInfo)
+      , mLengthListCount(aLengthListCount)
+    {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  struct StringInfo {
+    nsIAtom**    mName;
+    int32_t      mNamespaceID;
+    bool mIsAnimatable;
+  };
+
+  struct StringAttributesInfo {
+    nsSVGString*  mStrings;
+    StringInfo*   mStringInfo;
+    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 {
+    nsIAtom**    mName;
+  };
+
+  struct StringListAttributesInfo {
+    SVGStringList*    mStringLists;
+    StringListInfo*   mStringListInfo;
+    uint32_t          mStringListCount;
+
+    StringListAttributesInfo(SVGStringList  *aStringLists,
+                             StringListInfo *aStringListInfo,
+                             uint32_t aStringListCount) :
+      mStringLists(aStringLists), mStringListInfo(aStringListInfo),
+      mStringListCount(aStringListCount)
+      {}
+
+    void Reset(uint8_t aAttrEnum);
+  };
+
+  virtual LengthAttributesInfo GetLengthInfo();
+  virtual NumberAttributesInfo GetNumberInfo();
+  virtual NumberPairAttributesInfo GetNumberPairInfo();
+  virtual IntegerAttributesInfo GetIntegerInfo();
+  virtual IntegerPairAttributesInfo GetIntegerPairInfo();
+  virtual AngleAttributesInfo GetAngleInfo();
+  virtual BooleanAttributesInfo GetBooleanInfo();
+  virtual EnumAttributesInfo GetEnumInfo();
+  // We assume all viewboxes and preserveAspectRatios are alike
+  // so we don't need to wrap the class
+  virtual nsSVGViewBox *GetViewBox();
+  virtual SVGAnimatedPreserveAspectRatio *GetPreserveAspectRatio();
+  virtual NumberListAttributesInfo GetNumberListInfo();
+  virtual LengthListAttributesInfo GetLengthListInfo();
+  virtual StringAttributesInfo GetStringInfo();
+  virtual StringListAttributesInfo GetStringListInfo();
+
+  static nsSVGEnumMapping sSVGUnitTypesMap[];
+
+private:
+  void UnsetAttrInternal(int32_t aNameSpaceID, nsIAtom* aAttribute,
+                         bool aNotify);
+
+  nsSVGClass mClassAttribute;
+  nsAutoPtr<nsAttrValue> mClassAnimAttr;
+  RefPtr<mozilla::css::StyleRule> mContentStyleRule;
+};
+
+/**
+ * A macro to implement the NS_NewSVGXXXElement() functions.
+ */
+#define NS_IMPL_NS_NEW_SVG_ELEMENT(_elementName)                             \
+nsresult                                                                     \
+NS_NewSVG##_elementName##Element(nsIContent **aResult,                       \
+                                 already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)  \
+{                                                                            \
+  RefPtr<nsSVG##_elementName##Element> it =                                \
+    new nsSVG##_elementName##Element(aNodeInfo);                             \
+                                                                             \
+  nsresult rv = it->Init();                                                  \
+                                                                             \
+  if (NS_FAILED(rv)) {                                                       \
+    return rv;                                                               \
+  }                                                                          \
+                                                                             \
+  it.forget(aResult);                                                        \
+                                                                             \
+  return rv;                                                                 \
+}
+
+#define NS_IMPL_NS_NEW_NAMESPACED_SVG_ELEMENT(_elementName)                  \
+nsresult                                                                     \
+NS_NewSVG##_elementName##Element(nsIContent **aResult,                       \
+                                 already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)  \
+{                                                                            \
+  RefPtr<mozilla::dom::SVG##_elementName##Element> it =                    \
+    new mozilla::dom::SVG##_elementName##Element(aNodeInfo);                 \
+                                                                             \
+  nsresult rv = it->Init();                                                  \
+                                                                             \
+  if (NS_FAILED(rv)) {                                                       \
+    return rv;                                                               \
+  }                                                                          \
+                                                                             \
+  it.forget(aResult);                                                        \
+                                                                             \
+  return rv;                                                                 \
+}
+
+#define NS_IMPL_NS_NEW_NAMESPACED_SVG_ELEMENT_CHECK_PARSER(_elementName)     \
+nsresult                                                                     \
+NS_NewSVG##_elementName##Element(nsIContent **aResult,                       \
+                                 already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,  \
+                                 mozilla::dom::FromParser aFromParser)       \
+{                                                                            \
+  RefPtr<mozilla::dom::SVG##_elementName##Element> it =                    \
+    new mozilla::dom::SVG##_elementName##Element(aNodeInfo, aFromParser);    \
+                                                                             \
+  nsresult rv = it->Init();                                                  \
+                                                                             \
+  if (NS_FAILED(rv)) {                                                       \
+    return rv;                                                               \
+  }                                                                          \
+                                                                             \
+  it.forget(aResult);                                                        \
+                                                                             \
+  return rv;                                                                 \
+}
+
+// No unlinking, we'd need to null out the value pointer (the object it
+// points to is held by the element) and null-check it everywhere.
+#define NS_SVG_VAL_IMPL_CYCLE_COLLECTION(_val, _element)                     \
+NS_IMPL_CYCLE_COLLECTION_CLASS(_val)                                         \
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_val)                                \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(_element) \
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END                                        \
+NS_IMPL_CYCLE_COLLECTION_UNLINK_0(_val)
+
+#define NS_SVG_VAL_IMPL_CYCLE_COLLECTION_WRAPPERCACHED(_val, _element)       \
+NS_IMPL_CYCLE_COLLECTION_CLASS(_val)                                         \
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_val)                                  \
+NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER                            \
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END                                          \
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_val)                                \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(_element)                                \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS                           \
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END                                        \
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(_val)                                   \
+NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER                             \
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+#endif // __NS_SVGELEMENT_H__