Bug 1516727 - Part 3 rename nsSVGAngle to SVGAngle r=jwatt
authorlongsonr <longsonr@gmail.com>
Mon, 31 Dec 2018 19:00:42 +0000
changeset 509331 5e43ba4cbf931962e0779b39aee35d2029a695e4
parent 509330 f2dc090551f076387b984a670fe9eb7be9c8d460
child 509332 8d7a5d1ab4d8fd3a4cb753e094aee6c25f7f75f4
push id10547
push userffxbld-merge
push dateMon, 21 Jan 2019 13:03:58 +0000
treeherdermozilla-beta@24ec1916bffe [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjwatt
bugs1516727
milestone66.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1516727 - Part 3 rename nsSVGAngle to SVGAngle r=jwatt
dom/base/nsAttrValue.cpp
dom/base/nsAttrValue.h
dom/base/nsAttrValueInlines.h
dom/svg/DOMSVGAngle.cpp
dom/svg/DOMSVGAngle.h
dom/svg/SVGAngle.cpp
dom/svg/SVGAngle.h
dom/svg/SVGAnimatedAngle.cpp
dom/svg/SVGAnimatedAngle.h
dom/svg/SVGAttrValueWrapper.cpp
dom/svg/SVGAttrValueWrapper.h
dom/svg/SVGElement.cpp
dom/svg/SVGElement.h
dom/svg/SVGMarkerElement.h
dom/svg/SVGMotionSMILAnimationFunction.cpp
dom/svg/SVGOrientSMILType.cpp
dom/svg/moz.build
dom/svg/nsSVGAngle.cpp
dom/svg/nsSVGAngle.h
--- a/dom/base/nsAttrValue.cpp
+++ b/dom/base/nsAttrValue.cpp
@@ -393,18 +393,17 @@ void nsAttrValue::SetToSerialized(const 
     nsAutoString val;
     aOther.ToString(val);
     SetTo(val);
   } else {
     SetTo(aOther);
   }
 }
 
-void nsAttrValue::SetTo(const nsSVGAngle& aValue,
-                        const nsAString* aSerialized) {
+void nsAttrValue::SetTo(const SVGAngle& aValue, const nsAString* aSerialized) {
   SetSVGType(eSVGAngle, &aValue, aSerialized);
 }
 
 void nsAttrValue::SetTo(const nsSVGIntegerPair& aValue,
                         const nsAString* aSerialized) {
   SetSVGType(eSVGIntegerPair, &aValue, aSerialized);
 }
 
@@ -1603,17 +1602,17 @@ void nsAttrValue::SetSVGType(ValueType a
                              const nsAString* aSerialized) {
   MOZ_ASSERT(IsSVGType(aType), "Not an SVG type");
 
   MiscContainer* cont = EnsureEmptyMiscContainer();
   // All SVG types are just pointers to classes so just setting any of them
   // will do. We'll lose type-safety but the signature of the calling
   // function should ensure we don't get anything unexpected, and once we
   // stick aValue in a union we lose type information anyway.
-  cont->mValue.mSVGAngle = static_cast<const nsSVGAngle*>(aValue);
+  cont->mValue.mSVGAngle = static_cast<const SVGAngle*>(aValue);
   cont->mType = aType;
   SetMiscAtomOrString(aSerialized);
 }
 
 MiscContainer* nsAttrValue::ClearMiscContainer() {
   MiscContainer* cont = nullptr;
   if (BaseType() == eOtherBase) {
     cont = GetMiscContainer();
--- a/dom/base/nsAttrValue.h
+++ b/dom/base/nsAttrValue.h
@@ -147,17 +147,17 @@ class nsAttrValue {
   void SetTo(nsAtom* aValue);
   void SetTo(int16_t aInt);
   void SetTo(int32_t aInt, const nsAString* aSerialized);
   void SetTo(double aValue, const nsAString* aSerialized);
   void SetTo(already_AddRefed<mozilla::DeclarationBlock> aValue,
              const nsAString* aSerialized);
   void SetTo(nsIURI* aValue, const nsAString* aSerialized);
   void SetTo(const nsIntMargin& aValue);
-  void SetTo(const nsSVGAngle& aValue, const nsAString* aSerialized);
+  void SetTo(const SVGAngle& aValue, const nsAString* aSerialized);
   void SetTo(const nsSVGIntegerPair& aValue, const nsAString* aSerialized);
   void SetTo(const nsSVGLength2& aValue, const nsAString* aSerialized);
   void SetTo(const mozilla::SVGLengthList& aValue,
              const nsAString* aSerialized);
   void SetTo(const mozilla::SVGNumberList& aValue,
              const nsAString* aSerialized);
   void SetTo(const nsSVGNumberPair& aValue, const nsAString* aSerialized);
   void SetTo(const mozilla::SVGPathData& aValue, const nsAString* aSerialized);
--- a/dom/base/nsAttrValueInlines.h
+++ b/dom/base/nsAttrValueInlines.h
@@ -39,17 +39,17 @@ struct MiscContainer final {
         int32_t mInteger;
         nscolor mColor;
         uint32_t mEnumValue;
         int32_t mPercent;
         mozilla::DeclarationBlock* mCSSDeclaration;
         nsIURI* mURL;
         mozilla::AtomArray* mAtomArray;
         nsIntMargin* mIntMargin;
-        const nsSVGAngle* mSVGAngle;
+        const SVGAngle* mSVGAngle;
         const nsSVGIntegerPair* mSVGIntegerPair;
         const nsSVGLength2* mSVGLength;
         const mozilla::SVGLengthList* mSVGLengthList;
         const mozilla::SVGNumberList* mSVGNumberList;
         const nsSVGNumberPair* mSVGNumberPair;
         const mozilla::SVGPathData* mSVGPathData;
         const mozilla::SVGPointList* mSVGPointList;
         const mozilla::SVGAnimatedPreserveAspectRatio* mSVGPreserveAspectRatio;
--- a/dom/svg/DOMSVGAngle.cpp
+++ b/dom/svg/DOMSVGAngle.cpp
@@ -1,29 +1,29 @@
 /* -*- 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/. */
 
 #include "DOMSVGAngle.h"
-#include "nsSVGAngle.h"
+#include "SVGAngle.h"
 #include "mozilla/dom/SVGAngleBinding.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
 NS_SVG_VAL_IMPL_CYCLE_COLLECTION_WRAPPERCACHED(DOMSVGAngle, mSVGElement)
 
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(DOMSVGAngle, AddRef)
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(DOMSVGAngle, Release)
 
 DOMSVGAngle::DOMSVGAngle(SVGElement* aSVGElement)
     : mSVGElement(aSVGElement), mType(DOMSVGAngle::CreatedValue) {
-  mVal = new nsSVGAngle();
+  mVal = new SVGAngle();
   mVal->Init();
 }
 
 JSObject* DOMSVGAngle::WrapObject(JSContext* aCx,
                                   JS::Handle<JSObject*> aGivenProto) {
   return SVGAngle_Binding::Wrap(aCx, this, aGivenProto);
 }
 
--- a/dom/svg/DOMSVGAngle.h
+++ b/dom/svg/DOMSVGAngle.h
@@ -6,32 +6,32 @@
 
 #ifndef mozilla_dom_SVGAngle_h
 #define mozilla_dom_SVGAngle_h
 
 #include "nsWrapperCache.h"
 #include "SVGElement.h"
 #include "mozilla/Attributes.h"
 
-class nsSVGAngle;
+class SVGAngle;
 
 namespace mozilla {
 namespace dom {
 
 class DOMSVGAngle final : public nsWrapperCache {
  public:
   typedef enum { BaseValue, AnimValue, CreatedValue } AngleType;
 
   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(DOMSVGAngle)
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(DOMSVGAngle)
 
   /**
    * Generic ctor for DOMSVGAngle objects that are created for an attribute.
    */
-  DOMSVGAngle(nsSVGAngle* aVal, SVGElement* aSVGElement, AngleType aType)
+  DOMSVGAngle(SVGAngle* aVal, SVGElement* aSVGElement, AngleType aType)
       : mVal(aVal), mSVGElement(aSVGElement), mType(aType) {}
 
   /**
    * Ctor for creating the objects returned by SVGSVGElement.createSVGAngle(),
    * which do not initially belong to an attribute.
    */
   explicit DOMSVGAngle(SVGElement* aSVGElement);
 
@@ -47,18 +47,18 @@ class DOMSVGAngle final : public nsWrapp
   void SetValueInSpecifiedUnits(float aValue, ErrorResult& rv);
   void SetValueAsString(const nsAString& aValue, ErrorResult& rv);
   void NewValueSpecifiedUnits(uint16_t unitType, float value, ErrorResult& rv);
   void ConvertToSpecifiedUnits(uint16_t unitType, ErrorResult& rv);
 
  protected:
   ~DOMSVGAngle();
 
-  nsSVGAngle* mVal;  // if mType is CreatedValue, we own the angle.  Otherwise,
-                     // the element does.
+  SVGAngle* mVal;  // if mType is CreatedValue, we own the angle.  Otherwise,
+                   // the element does.
   RefPtr<SVGElement> mSVGElement;
   AngleType mType;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif  // mozilla_dom_SVGAngle_h
rename from dom/svg/nsSVGAngle.cpp
rename to dom/svg/SVGAngle.cpp
--- a/dom/svg/nsSVGAngle.cpp
+++ b/dom/svg/SVGAngle.cpp
@@ -1,15 +1,15 @@
 /* -*- 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/. */
 
-#include "nsSVGAngle.h"
+#include "SVGAngle.h"
 
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/dom/SVGMarkerElement.h"
 #include "mozilla/Move.h"
 #include "nsContentUtils.h"  // NS_ENSURE_FINITE
 #include "DOMSVGAngle.h"
 #include "nsSMILValue.h"
 #include "nsSVGAttrTearoffTable.h"
@@ -22,20 +22,20 @@ using namespace mozilla::dom;
 using namespace mozilla::dom::SVGAngle_Binding;
 using namespace mozilla::dom::SVGMarkerElement_Binding;
 
 static const nsStaticAtom* const angleUnitMap[] = {
     nullptr, /* SVG_ANGLETYPE_UNKNOWN */
     nullptr, /* SVG_ANGLETYPE_UNSPECIFIED */
     nsGkAtoms::deg, nsGkAtoms::rad, nsGkAtoms::grad};
 
-static nsSVGAttrTearoffTable<nsSVGAngle, SVGAnimatedAngle>
+static nsSVGAttrTearoffTable<SVGAngle, SVGAnimatedAngle>
     sSVGAnimatedAngleTearoffTable;
-static nsSVGAttrTearoffTable<nsSVGAngle, DOMSVGAngle> sBaseSVGAngleTearoffTable;
-static nsSVGAttrTearoffTable<nsSVGAngle, DOMSVGAngle> sAnimSVGAngleTearoffTable;
+static nsSVGAttrTearoffTable<SVGAngle, DOMSVGAngle> sBaseSVGAngleTearoffTable;
+static nsSVGAttrTearoffTable<SVGAngle, DOMSVGAngle> sAnimSVGAngleTearoffTable;
 
 /* Helper functions */
 
 static bool IsValidAngleUnitType(uint16_t unit) {
   if (unit > SVG_ANGLETYPE_UNKNOWN && unit <= SVG_ANGLETYPE_GRAD) return true;
 
   return false;
 }
@@ -71,65 +71,65 @@ static void GetAngleValueString(nsAStrin
                                 uint16_t aUnitType) {
   nsTextFormatter::ssprintf(aValueAsString, u"%g", (double)aValue);
 
   nsAutoString unitString;
   GetAngleUnitString(unitString, aUnitType);
   aValueAsString.Append(unitString);
 }
 
-/* static */ bool nsSVGAngle::GetValueFromString(const nsAString& aString,
-                                                 float& aValue,
-                                                 uint16_t* aUnitType) {
+/* static */ bool SVGAngle::GetValueFromString(const nsAString& aString,
+                                               float& aValue,
+                                               uint16_t* aUnitType) {
   RangedPtr<const char16_t> iter = SVGContentUtils::GetStartRangedPtr(aString);
   const RangedPtr<const char16_t> end =
       SVGContentUtils::GetEndRangedPtr(aString);
 
   if (!SVGContentUtils::ParseNumber(iter, end, aValue)) {
     return false;
   }
 
   const nsAString& units = Substring(iter.get(), end.get());
   *aUnitType = GetAngleUnitTypeForString(units);
   return IsValidAngleUnitType(*aUnitType);
 }
 
-/* static */ float nsSVGAngle::GetDegreesPerUnit(uint8_t aUnit) {
+/* static */ float SVGAngle::GetDegreesPerUnit(uint8_t aUnit) {
   switch (aUnit) {
     case SVG_ANGLETYPE_UNSPECIFIED:
     case SVG_ANGLETYPE_DEG:
       return 1;
     case SVG_ANGLETYPE_RAD:
       return static_cast<float>(180.0 / M_PI);
     case SVG_ANGLETYPE_GRAD:
       return 90.0f / 100.0f;
     default:
       MOZ_ASSERT_UNREACHABLE("Unknown unit type");
       return 0;
   }
 }
 
-void nsSVGAngle::SetBaseValueInSpecifiedUnits(float aValue,
-                                              SVGElement* aSVGElement) {
+void SVGAngle::SetBaseValueInSpecifiedUnits(float aValue,
+                                            SVGElement* aSVGElement) {
   if (mBaseVal == aValue) {
     return;
   }
 
   nsAttrValue emptyOrOldValue = aSVGElement->WillChangeAngle(mAttrEnum);
   mBaseVal = aValue;
   if (!mIsAnimated) {
     mAnimVal = mBaseVal;
   } else {
     aSVGElement->AnimationNeedsResample();
   }
   aSVGElement->DidChangeAngle(mAttrEnum, emptyOrOldValue);
 }
 
-nsresult nsSVGAngle::ConvertToSpecifiedUnits(uint16_t unitType,
-                                             SVGElement* aSVGElement) {
+nsresult SVGAngle::ConvertToSpecifiedUnits(uint16_t unitType,
+                                           SVGElement* aSVGElement) {
   if (!IsValidAngleUnitType(unitType)) return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
 
   if (mBaseValUnit == uint8_t(unitType)) return NS_OK;
 
   nsAttrValue emptyOrOldValue;
   if (aSVGElement) {
     emptyOrOldValue = aSVGElement->WillChangeAngle(mAttrEnum);
   }
@@ -141,19 +141,19 @@ nsresult nsSVGAngle::ConvertToSpecifiedU
 
   if (aSVGElement) {
     aSVGElement->DidChangeAngle(mAttrEnum, emptyOrOldValue);
   }
 
   return NS_OK;
 }
 
-nsresult nsSVGAngle::NewValueSpecifiedUnits(uint16_t unitType,
-                                            float valueInSpecifiedUnits,
-                                            SVGElement* aSVGElement) {
+nsresult SVGAngle::NewValueSpecifiedUnits(uint16_t unitType,
+                                          float valueInSpecifiedUnits,
+                                          SVGElement* aSVGElement) {
   NS_ENSURE_FINITE(valueInSpecifiedUnits, NS_ERROR_ILLEGAL_VALUE);
 
   if (!IsValidAngleUnitType(unitType)) return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
 
   if (mBaseVal == valueInSpecifiedUnits && mBaseValUnit == uint8_t(unitType))
     return NS_OK;
 
   nsAttrValue emptyOrOldValue;
@@ -169,29 +169,27 @@ nsresult nsSVGAngle::NewValueSpecifiedUn
     aSVGElement->AnimationNeedsResample();
   }
   if (aSVGElement) {
     aSVGElement->DidChangeAngle(mAttrEnum, emptyOrOldValue);
   }
   return NS_OK;
 }
 
-already_AddRefed<DOMSVGAngle> nsSVGAngle::ToDOMBaseVal(
-    SVGElement* aSVGElement) {
+already_AddRefed<DOMSVGAngle> SVGAngle::ToDOMBaseVal(SVGElement* aSVGElement) {
   RefPtr<DOMSVGAngle> domBaseVal = sBaseSVGAngleTearoffTable.GetTearoff(this);
   if (!domBaseVal) {
     domBaseVal = new DOMSVGAngle(this, aSVGElement, DOMSVGAngle::BaseValue);
     sBaseSVGAngleTearoffTable.AddTearoff(this, domBaseVal);
   }
 
   return domBaseVal.forget();
 }
 
-already_AddRefed<DOMSVGAngle> nsSVGAngle::ToDOMAnimVal(
-    SVGElement* aSVGElement) {
+already_AddRefed<DOMSVGAngle> SVGAngle::ToDOMAnimVal(SVGElement* aSVGElement) {
   RefPtr<DOMSVGAngle> domAnimVal = sAnimSVGAngleTearoffTable.GetTearoff(this);
   if (!domAnimVal) {
     domAnimVal = new DOMSVGAngle(this, aSVGElement, DOMSVGAngle::AnimValue);
     sAnimSVGAngleTearoffTable.AddTearoff(this, domAnimVal);
   }
 
   return domAnimVal.forget();
 }
@@ -203,19 +201,19 @@ DOMSVGAngle::~DOMSVGAngle() {
     sAnimSVGAngleTearoffTable.RemoveTearoff(mVal);
   } else {
     delete mVal;
   }
 }
 
 /* Implementation */
 
-nsresult nsSVGAngle::SetBaseValueString(const nsAString& aValueAsString,
-                                        SVGElement* aSVGElement,
-                                        bool aDoSetAttr) {
+nsresult SVGAngle::SetBaseValueString(const nsAString& aValueAsString,
+                                      SVGElement* aSVGElement,
+                                      bool aDoSetAttr) {
   float value;
   uint16_t unitType;
 
   if (!GetValueFromString(aValueAsString, value, &unitType)) {
     return NS_ERROR_DOM_SYNTAX_ERR;
   }
   if (mBaseVal == value && mBaseValUnit == uint8_t(unitType)) {
     return NS_OK;
@@ -235,26 +233,26 @@ nsresult nsSVGAngle::SetBaseValueString(
   }
 
   if (aDoSetAttr) {
     aSVGElement->DidChangeAngle(mAttrEnum, emptyOrOldValue);
   }
   return NS_OK;
 }
 
-void nsSVGAngle::GetBaseValueString(nsAString& aValueAsString) const {
+void SVGAngle::GetBaseValueString(nsAString& aValueAsString) const {
   GetAngleValueString(aValueAsString, mBaseVal, mBaseValUnit);
 }
 
-void nsSVGAngle::GetAnimValueString(nsAString& aValueAsString) const {
+void SVGAngle::GetAnimValueString(nsAString& aValueAsString) const {
   GetAngleValueString(aValueAsString, mAnimVal, mAnimValUnit);
 }
 
-void nsSVGAngle::SetBaseValue(float aValue, uint8_t aUnit,
-                              SVGElement* aSVGElement, bool aDoSetAttr) {
+void SVGAngle::SetBaseValue(float aValue, uint8_t aUnit,
+                            SVGElement* aSVGElement, bool aDoSetAttr) {
   float valueInSpecifiedUnits = aValue / GetDegreesPerUnit(aUnit);
   if (aUnit == mBaseValUnit && mBaseVal == valueInSpecifiedUnits) {
     return;
   }
   nsAttrValue emptyOrOldValue;
   if (aSVGElement && aDoSetAttr) {
     emptyOrOldValue = aSVGElement->WillChangeAngle(mAttrEnum);
   }
@@ -266,55 +264,55 @@ void nsSVGAngle::SetBaseValue(float aVal
   } else {
     aSVGElement->AnimationNeedsResample();
   }
   if (aSVGElement && aDoSetAttr) {
     aSVGElement->DidChangeAngle(mAttrEnum, emptyOrOldValue);
   }
 }
 
-void nsSVGAngle::SetAnimValue(float aValue, uint8_t aUnit,
-                              SVGElement* aSVGElement) {
+void SVGAngle::SetAnimValue(float aValue, uint8_t aUnit,
+                            SVGElement* aSVGElement) {
   if (mIsAnimated && mAnimVal == aValue && mAnimValUnit == aUnit) {
     return;
   }
   mAnimVal = aValue;
   mAnimValUnit = aUnit;
   mIsAnimated = true;
   aSVGElement->DidAnimateAngle(mAttrEnum);
 }
 
-already_AddRefed<SVGAnimatedAngle> nsSVGAngle::ToDOMAnimatedAngle(
+already_AddRefed<SVGAnimatedAngle> SVGAngle::ToDOMAnimatedAngle(
     SVGElement* aSVGElement) {
   RefPtr<SVGAnimatedAngle> domAnimatedAngle =
       sSVGAnimatedAngleTearoffTable.GetTearoff(this);
   if (!domAnimatedAngle) {
     domAnimatedAngle = new SVGAnimatedAngle(this, aSVGElement);
     sSVGAnimatedAngleTearoffTable.AddTearoff(this, domAnimatedAngle);
   }
 
   return domAnimatedAngle.forget();
 }
 
 SVGAnimatedAngle::~SVGAnimatedAngle() {
   sSVGAnimatedAngleTearoffTable.RemoveTearoff(mVal);
 }
 
-UniquePtr<nsISMILAttr> nsSVGAngle::ToSMILAttr(SVGElement* aSVGElement) {
+UniquePtr<nsISMILAttr> SVGAngle::ToSMILAttr(SVGElement* aSVGElement) {
   if (aSVGElement->NodeInfo()->Equals(nsGkAtoms::marker, kNameSpaceID_SVG)) {
     SVGMarkerElement* marker = static_cast<SVGMarkerElement*>(aSVGElement);
     return MakeUnique<SMILOrient>(marker->GetOrientType(), this, aSVGElement);
   }
   // SMILOrient would not be useful for general angle attributes (also,
   // "orient" is the only animatable <angle>-valued attribute in SVG 1.1).
   MOZ_ASSERT_UNREACHABLE("Trying to animate unknown angle attribute.");
   return nullptr;
 }
 
-nsresult nsSVGAngle::SMILOrient::ValueFromString(
+nsresult SVGAngle::SMILOrient::ValueFromString(
     const nsAString& aStr, const SVGAnimationElement* /*aSrcElement*/,
     nsSMILValue& aValue, bool& aPreventCachingOfSandwich) const {
   nsSMILValue val(&SVGOrientSMILType::sSingleton);
   if (aStr.EqualsLiteral("auto")) {
     val.mU.mOrient.mOrientType = SVG_MARKER_ORIENT_AUTO;
   } else if (aStr.EqualsLiteral("auto-start-reverse")) {
     val.mU.mOrient.mOrientType = SVG_MARKER_ORIENT_AUTO_START_REVERSE;
   } else {
@@ -328,35 +326,35 @@ nsresult nsSVGAngle::SMILOrient::ValueFr
     val.mU.mOrient.mOrientType = SVG_MARKER_ORIENT_ANGLE;
   }
   aValue = std::move(val);
   aPreventCachingOfSandwich = false;
 
   return NS_OK;
 }
 
-nsSMILValue nsSVGAngle::SMILOrient::GetBaseValue() const {
+nsSMILValue SVGAngle::SMILOrient::GetBaseValue() const {
   nsSMILValue val(&SVGOrientSMILType::sSingleton);
   val.mU.mOrient.mAngle = mAngle->GetBaseValInSpecifiedUnits();
   val.mU.mOrient.mUnit = mAngle->GetBaseValueUnit();
   val.mU.mOrient.mOrientType = mOrientType->GetBaseValue();
   return val;
 }
 
-void nsSVGAngle::SMILOrient::ClearAnimValue() {
+void SVGAngle::SMILOrient::ClearAnimValue() {
   if (mAngle->mIsAnimated) {
     mOrientType->SetAnimValue(mOrientType->GetBaseValue());
     mAngle->mIsAnimated = false;
     mAngle->mAnimVal = mAngle->mBaseVal;
     mAngle->mAnimValUnit = mAngle->mBaseValUnit;
     mSVGElement->DidAnimateAngle(mAngle->mAttrEnum);
   }
 }
 
-nsresult nsSVGAngle::SMILOrient::SetAnimValue(const nsSMILValue& aValue) {
+nsresult SVGAngle::SMILOrient::SetAnimValue(const nsSMILValue& aValue) {
   NS_ASSERTION(aValue.mType == &SVGOrientSMILType::sSingleton,
                "Unexpected type to assign animated value");
 
   if (aValue.mType == &SVGOrientSMILType::sSingleton) {
     mOrientType->SetAnimValue(aValue.mU.mOrient.mOrientType);
     if (aValue.mU.mOrient.mOrientType == SVG_MARKER_ORIENT_AUTO ||
         aValue.mU.mOrient.mOrientType == SVG_MARKER_ORIENT_AUTO_START_REVERSE) {
       mAngle->SetAnimValue(0.0f, SVG_ANGLETYPE_UNSPECIFIED, mSVGElement);
rename from dom/svg/nsSVGAngle.h
rename to dom/svg/SVGAngle.h
--- a/dom/svg/nsSVGAngle.h
+++ b/dom/svg/SVGAngle.h
@@ -23,17 +23,17 @@ namespace dom {
 class nsSVGOrientType;
 class DOMSVGAngle;
 class SVGAnimatedAngle;
 class SVGAnimationElement;
 class SVGElement;
 }  // namespace dom
 }  // namespace mozilla
 
-class nsSVGAngle {
+class SVGAngle {
   friend class mozilla::dom::DOMSVGAngle;
   friend class mozilla::dom::SVGAnimatedAngle;
   typedef mozilla::dom::SVGElement SVGElement;
 
  public:
   void Init(uint8_t aAttrEnum = 0xff, float aValue = 0,
             uint8_t aUnitType =
                 mozilla::dom::SVGAngle_Binding::SVG_ANGLETYPE_UNSPECIFIED) {
@@ -93,25 +93,25 @@ class nsSVGAngle {
  public:
   // We do not currently implemente a SMILAngle struct because in SVG 1.1 the
   // only *animatable* attribute that takes an <angle> is 'orient', on the
   // 'marker' element, and 'orient' must be special cased since it can also
   // take the value 'auto', making it a more complex type.
 
   struct SMILOrient final : public nsISMILAttr {
    public:
-    SMILOrient(mozilla::dom::nsSVGOrientType* aOrientType, nsSVGAngle* aAngle,
+    SMILOrient(mozilla::dom::nsSVGOrientType* aOrientType, SVGAngle* aAngle,
                SVGElement* aSVGElement)
         : mOrientType(aOrientType), mAngle(aAngle), mSVGElement(aSVGElement) {}
 
     // These will stay alive because a nsISMILAttr only lives as long
     // as the Compositing step, and DOM elements don't get a chance to
     // die during that.
     mozilla::dom::nsSVGOrientType* mOrientType;
-    nsSVGAngle* mAngle;
+    SVGAngle* mAngle;
     SVGElement* mSVGElement;
 
     // nsISMILAttr methods
     virtual nsresult ValueFromString(
         const nsAString& aStr,
         const mozilla::dom::SVGAnimationElement* aSrcElement,
         nsSMILValue& aValue, bool& aPreventCachingOfSandwich) const override;
     virtual nsSMILValue GetBaseValue() const override;
--- a/dom/svg/SVGAnimatedAngle.cpp
+++ b/dom/svg/SVGAnimatedAngle.cpp
@@ -1,16 +1,16 @@
 /* -*- 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/. */
 
 #include "SVGAnimatedAngle.h"
-#include "nsSVGAngle.h"
+#include "SVGAngle.h"
 #include "mozilla/dom/SVGAnimatedAngleBinding.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
 NS_SVG_VAL_IMPL_CYCLE_COLLECTION_WRAPPERCACHED(SVGAnimatedAngle, mSVGElement)
 
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(SVGAnimatedAngle, AddRef)
--- a/dom/svg/SVGAnimatedAngle.h
+++ b/dom/svg/SVGAnimatedAngle.h
@@ -6,41 +6,41 @@
 
 #ifndef mozilla_dom_SVGAnimatedAngle_h
 #define mozilla_dom_SVGAnimatedAngle_h
 
 #include "nsWrapperCache.h"
 #include "SVGElement.h"
 #include "mozilla/Attributes.h"
 
-class nsSVGAngle;
+class SVGAngle;
 
 namespace mozilla {
 namespace dom {
 
 class DOMSVGAngle;
 
 class SVGAnimatedAngle final : public nsWrapperCache {
  public:
   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(SVGAnimatedAngle)
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(SVGAnimatedAngle)
 
-  SVGAnimatedAngle(nsSVGAngle* aVal, SVGElement* aSVGElement)
+  SVGAnimatedAngle(SVGAngle* aVal, SVGElement* aSVGElement)
       : mVal(aVal), mSVGElement(aSVGElement) {}
 
   // WebIDL
   SVGElement* GetParentObject() { return mSVGElement; }
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
   already_AddRefed<DOMSVGAngle> BaseVal();
   already_AddRefed<DOMSVGAngle> AnimVal();
 
  protected:
   ~SVGAnimatedAngle();
 
-  nsSVGAngle* mVal;  // kept alive because it belongs to content
+  SVGAngle* mVal;  // kept alive because it belongs to content
   RefPtr<SVGElement> mSVGElement;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif  // mozilla_dom_SVGAnimatedAngle_h
--- a/dom/svg/SVGAttrValueWrapper.cpp
+++ b/dom/svg/SVGAttrValueWrapper.cpp
@@ -1,31 +1,31 @@
 /* -*- 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/. */
 
 #include "SVGAttrValueWrapper.h"
-#include "nsSVGAngle.h"
+#include "SVGAngle.h"
 #include "nsSVGIntegerPair.h"
 #include "nsSVGLength2.h"
 #include "nsSVGNumberPair.h"
 #include "nsSVGViewBox.h"
 #include "SVGAnimatedPreserveAspectRatio.h"
 #include "SVGLengthList.h"
 #include "SVGNumberList.h"
 #include "SVGPathData.h"
 #include "SVGPointList.h"
 #include "SVGStringList.h"
 #include "SVGTransformList.h"
 
 using namespace mozilla;
 
-/*static*/ void SVGAttrValueWrapper::ToString(const nsSVGAngle* aAngle,
+/*static*/ void SVGAttrValueWrapper::ToString(const SVGAngle* aAngle,
                                               nsAString& aResult) {
   aAngle->GetBaseValueString(aResult);
 }
 
 /*static*/ void SVGAttrValueWrapper::ToString(
     const nsSVGIntegerPair* aIntegerPair, nsAString& aResult) {
   aIntegerPair->GetBaseValueString(aResult);
 }
--- a/dom/svg/SVGAttrValueWrapper.h
+++ b/dom/svg/SVGAttrValueWrapper.h
@@ -9,17 +9,17 @@
 
 /**
  * Utility wrapper for handling SVG types used inside nsAttrValue so that these
  * types don't need to be exported outside the SVG module.
  */
 
 #include "nsString.h"
 
-class nsSVGAngle;
+class SVGAngle;
 class nsSVGIntegerPair;
 class nsSVGLength2;
 class nsSVGNumberPair;
 class nsSVGViewBox;
 
 namespace mozilla {
 class SVGLengthList;
 class SVGNumberList;
@@ -29,17 +29,17 @@ class SVGAnimatedPreserveAspectRatio;
 class SVGStringList;
 class SVGTransformList;
 }  // namespace mozilla
 
 namespace mozilla {
 
 class SVGAttrValueWrapper {
  public:
-  static void ToString(const nsSVGAngle* aAngle, nsAString& aResult);
+  static void ToString(const SVGAngle* aAngle, nsAString& aResult);
   static void ToString(const nsSVGIntegerPair* aIntegerPair,
                        nsAString& aResult);
   static void ToString(const nsSVGLength2* aLength, nsAString& aResult);
   static void ToString(const mozilla::SVGLengthList* aLengthList,
                        nsAString& aResult);
   static void ToString(const mozilla::SVGNumberList* aNumberList,
                        nsAString& aResult);
   static void ToString(const nsSVGNumberPair* aNumberPair, nsAString& aResult);
--- a/dom/svg/SVGElement.cpp
+++ b/dom/svg/SVGElement.cpp
@@ -30,17 +30,17 @@
 #include "nsICSSDeclaration.h"
 #include "nsIContentInlines.h"
 #include "nsIDocument.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsIPresShell.h"
 #include "nsIFrame.h"
 #include "nsLayoutUtils.h"
-#include "nsSVGAngle.h"
+#include "SVGAngle.h"
 #include "nsSVGBoolean.h"
 #include "nsSVGEnum.h"
 #include "nsSVGInteger.h"
 #include "nsSVGIntegerPair.h"
 #include "nsSVGLength2.h"
 #include "nsSVGNumber2.h"
 #include "nsSVGNumberPair.h"
 #include "nsSVGString.h"
@@ -457,17 +457,17 @@ bool SVGElement::ParseAttribute(int32_t 
           }
           foundMatch = true;
           break;
         }
       }
     }
 
     if (!foundMatch) {
-      // Check for nsSVGAngle attribute
+      // Check for SVGAngle attribute
       AngleAttributesInfo angleInfo = GetAngleInfo();
       for (i = 0; i < angleInfo.mAngleCount; i++) {
         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);
--- a/dom/svg/SVGElement.h
+++ b/dom/svg/SVGElement.h
@@ -22,17 +22,17 @@
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsError.h"
 #include "nsISupportsImpl.h"
 #include "nsStyledElement.h"
 #include "nsSVGClass.h"
 #include "gfxMatrix.h"
 
-class nsSVGAngle;
+class SVGAngle;
 class nsSVGBoolean;
 class nsSVGEnum;
 class nsSVGInteger;
 class nsSVGIntegerPair;
 class nsSVGLength2;
 class nsSVGNumber2;
 class nsSVGNumberPair;
 class nsSVGString;
@@ -443,21 +443,21 @@ class SVGElement : public SVGElementBase
 
   struct AngleInfo {
     nsStaticAtom* const mName;
     const float mDefaultValue;
     const uint8_t mDefaultUnitType;
   };
 
   struct AngleAttributesInfo {
-    nsSVGAngle* const mAngles;
+    SVGAngle* const mAngles;
     const AngleInfo* const mAngleInfo;
     const uint32_t mAngleCount;
 
-    AngleAttributesInfo(nsSVGAngle* aAngles, AngleInfo* aAngleInfo,
+    AngleAttributesInfo(SVGAngle* aAngles, AngleInfo* aAngleInfo,
                         uint32_t aAngleCount)
         : mAngles(aAngles), mAngleInfo(aAngleInfo), mAngleCount(aAngleCount) {}
 
     void Reset(uint8_t aAttrEnum);
   };
 
   struct BooleanInfo {
     nsStaticAtom* const mName;
--- a/dom/svg/SVGMarkerElement.h
+++ b/dom/svg/SVGMarkerElement.h
@@ -3,17 +3,17 @@
 /* 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 mozilla_dom_SVGMarkerElement_h
 #define mozilla_dom_SVGMarkerElement_h
 
 #include "nsAutoPtr.h"
-#include "nsSVGAngle.h"
+#include "SVGAngle.h"
 #include "nsSVGEnum.h"
 #include "nsSVGLength2.h"
 #include "nsSVGViewBox.h"
 #include "SVGAnimatedPreserveAspectRatio.h"
 #include "SVGElement.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/dom/SVGAnimatedEnumeration.h"
 #include "mozilla/dom/SVGMarkerElementBinding.h"
@@ -36,17 +36,17 @@ class nsSVGOrientType {
       : mAnimVal(SVGMarkerElement_Binding::SVG_MARKER_ORIENT_ANGLE),
         mBaseVal(SVGMarkerElement_Binding::SVG_MARKER_ORIENT_ANGLE) {}
 
   nsresult SetBaseValue(uint16_t aValue, SVGElement* aSVGElement);
 
   // XXX FIXME like https://bugzilla.mozilla.org/show_bug.cgi?id=545550 but
   // without adding an mIsAnimated member...?
   void SetBaseValue(uint16_t aValue) { mAnimVal = mBaseVal = uint8_t(aValue); }
-  // no need to notify, since nsSVGAngle does that
+  // no need to notify, since SVGAngle does that
   void SetAnimValue(uint16_t aValue) { mAnimVal = uint8_t(aValue); }
 
   // we want to avoid exposing SVG_MARKER_ORIENT_AUTO_START_REVERSE to
   // Web content
   uint16_t GetBaseValue() const {
     return mAnimVal == SVG_MARKER_ORIENT_AUTO_START_REVERSE
                ? SVGMarkerElement_Binding::SVG_MARKER_ORIENT_UNKNOWN
                : mBaseVal;
@@ -148,17 +148,17 @@ class SVGMarkerElement : public SVGMarke
   static LengthInfo sLengthInfo[4];
 
   enum { MARKERUNITS };
   nsSVGEnum mEnumAttributes[1];
   static nsSVGEnumMapping sUnitsMap[];
   static EnumInfo sEnumInfo[1];
 
   enum { ORIENT };
-  nsSVGAngle mAngleAttributes[1];
+  SVGAngle mAngleAttributes[1];
   static AngleInfo sAngleInfo[1];
 
   nsSVGViewBox mViewBox;
   SVGAnimatedPreserveAspectRatio mPreserveAspectRatio;
 
   // derived properties (from 'orient') handled separately
   nsSVGOrientType mOrientType;
 
--- a/dom/svg/SVGMotionSMILAnimationFunction.cpp
+++ b/dom/svg/SVGMotionSMILAnimationFunction.cpp
@@ -7,17 +7,17 @@
 #include "SVGMotionSMILAnimationFunction.h"
 #include "mozilla/dom/SVGAnimationElement.h"
 #include "mozilla/dom/SVGPathElement.h"  // for nsSVGPathList
 #include "mozilla/dom/SVGMPathElement.h"
 #include "mozilla/gfx/2D.h"
 #include "nsAttrValue.h"
 #include "nsAttrValueInlines.h"
 #include "nsSMILParserUtils.h"
-#include "nsSVGAngle.h"
+#include "SVGAngle.h"
 #include "SVGPathDataParser.h"
 #include "SVGMotionSMILType.h"
 #include "SVGMotionSMILPathUtils.h"
 
 using namespace mozilla::dom;
 using namespace mozilla::dom::SVGAngle_Binding;
 using namespace mozilla::gfx;
 
@@ -385,26 +385,26 @@ nsresult SVGMotionSMILAnimationFunction:
   if (aRotate.EqualsLiteral("auto")) {
     mRotateType = eRotateType_Auto;
   } else if (aRotate.EqualsLiteral("auto-reverse")) {
     mRotateType = eRotateType_AutoReverse;
   } else {
     mRotateType = eRotateType_Explicit;
 
     uint16_t angleUnit;
-    if (!nsSVGAngle::GetValueFromString(aRotate, mRotateAngle, &angleUnit)) {
+    if (!SVGAngle::GetValueFromString(aRotate, mRotateAngle, &angleUnit)) {
       mRotateAngle = 0.0f;  // set default rotate angle
       // XXX report to console?
       return NS_ERROR_DOM_SYNTAX_ERR;
     }
 
     // Convert to radian units, if we're not already in radians.
     if (angleUnit != SVG_ANGLETYPE_RAD) {
-      mRotateAngle *= nsSVGAngle::GetDegreesPerUnit(angleUnit) /
-                      nsSVGAngle::GetDegreesPerUnit(SVG_ANGLETYPE_RAD);
+      mRotateAngle *= SVGAngle::GetDegreesPerUnit(angleUnit) /
+                      SVGAngle::GetDegreesPerUnit(SVG_ANGLETYPE_RAD);
     }
   }
   return NS_OK;
 }
 
 void SVGMotionSMILAnimationFunction::UnsetRotate() {
   mRotateAngle = 0.0f;  // default value
   mRotateType = eRotateType_Explicit;
--- a/dom/svg/SVGOrientSMILType.cpp
+++ b/dom/svg/SVGOrientSMILType.cpp
@@ -1,17 +1,17 @@
 /* -*- 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/. */
 
 #include "SVGOrientSMILType.h"
 #include "nsSMILValue.h"
-#include "nsSVGAngle.h"
+#include "SVGAngle.h"
 #include "nsDebug.h"
 #include "mozilla/dom/SVGMarkerElement.h"
 #include <math.h>
 
 namespace mozilla {
 
 using namespace dom::SVGAngle_Binding;
 using namespace dom::SVGMarkerElement_Binding;
@@ -64,26 +64,26 @@ nsresult SVGOrientSMILType::Add(nsSMILVa
       aValueToAdd.mU.mOrient.mOrientType != SVG_MARKER_ORIENT_ANGLE) {
     // TODO: it would be nice to be able to add to auto angles
     return NS_ERROR_FAILURE;
   }
 
   // We may be dealing with two different angle units, so we normalize to
   // degrees for the add:
   float currentAngle = aDest.mU.mOrient.mAngle *
-                       nsSVGAngle::GetDegreesPerUnit(aDest.mU.mOrient.mUnit);
-  float angleToAdd =
-      aValueToAdd.mU.mOrient.mAngle *
-      nsSVGAngle::GetDegreesPerUnit(aValueToAdd.mU.mOrient.mUnit) * aCount;
+                       SVGAngle::GetDegreesPerUnit(aDest.mU.mOrient.mUnit);
+  float angleToAdd = aValueToAdd.mU.mOrient.mAngle *
+                     SVGAngle::GetDegreesPerUnit(aValueToAdd.mU.mOrient.mUnit) *
+                     aCount;
 
   // And then we give the resulting animated value the same units as the value
   // that we're animating to/by (i.e. the same as aValueToAdd):
   aDest.mU.mOrient.mAngle =
       (currentAngle + angleToAdd) /
-      nsSVGAngle::GetDegreesPerUnit(aValueToAdd.mU.mOrient.mUnit);
+      SVGAngle::GetDegreesPerUnit(aValueToAdd.mU.mOrient.mUnit);
   aDest.mU.mOrient.mUnit = aValueToAdd.mU.mOrient.mUnit;
 
   return NS_OK;
 }
 
 nsresult SVGOrientSMILType::ComputeDistance(const nsSMILValue& aFrom,
                                             const nsSMILValue& aTo,
                                             double& aDistance) const {
@@ -93,19 +93,19 @@ nsresult SVGOrientSMILType::ComputeDista
   if (aFrom.mU.mOrient.mOrientType != SVG_MARKER_ORIENT_ANGLE ||
       aTo.mU.mOrient.mOrientType != SVG_MARKER_ORIENT_ANGLE) {
     // TODO: it would be nice to be able to compute distance with auto angles
     return NS_ERROR_FAILURE;
   }
 
   // Normalize both to degrees in case they're different angle units:
   double from = aFrom.mU.mOrient.mAngle *
-                nsSVGAngle::GetDegreesPerUnit(aFrom.mU.mOrient.mUnit);
-  double to = aTo.mU.mOrient.mAngle *
-              nsSVGAngle::GetDegreesPerUnit(aTo.mU.mOrient.mUnit);
+                SVGAngle::GetDegreesPerUnit(aFrom.mU.mOrient.mUnit);
+  double to =
+      aTo.mU.mOrient.mAngle * SVGAngle::GetDegreesPerUnit(aTo.mU.mOrient.mUnit);
 
   aDistance = fabs(to - from);
 
   return NS_OK;
 }
 
 nsresult SVGOrientSMILType::Interpolate(const nsSMILValue& aStartVal,
                                         const nsSMILValue& aEndVal,
@@ -118,22 +118,22 @@ nsresult SVGOrientSMILType::Interpolate(
 
   if (aStartVal.mU.mOrient.mOrientType != SVG_MARKER_ORIENT_ANGLE ||
       aEndVal.mU.mOrient.mOrientType != SVG_MARKER_ORIENT_ANGLE) {
     // TODO: it would be nice to be able to handle auto angles too.
     return NS_ERROR_FAILURE;
   }
 
   float start = aStartVal.mU.mOrient.mAngle *
-                nsSVGAngle::GetDegreesPerUnit(aStartVal.mU.mOrient.mUnit);
+                SVGAngle::GetDegreesPerUnit(aStartVal.mU.mOrient.mUnit);
   float end = aEndVal.mU.mOrient.mAngle *
-              nsSVGAngle::GetDegreesPerUnit(aEndVal.mU.mOrient.mUnit);
+              SVGAngle::GetDegreesPerUnit(aEndVal.mU.mOrient.mUnit);
   float result = (start + (end - start) * aUnitDistance);
 
   // Again, we use the unit of the to/by value for the result:
   aResult.mU.mOrient.mAngle =
-      result / nsSVGAngle::GetDegreesPerUnit(aEndVal.mU.mOrient.mUnit);
+      result / SVGAngle::GetDegreesPerUnit(aEndVal.mU.mOrient.mUnit);
   aResult.mU.mOrient.mUnit = aEndVal.mU.mOrient.mUnit;
 
   return NS_OK;
 }
 
 }  // namespace mozilla
--- a/dom/svg/moz.build
+++ b/dom/svg/moz.build
@@ -121,28 +121,28 @@ UNIFIED_SOURCES += [
     'DOMSVGPathSeg.cpp',
     'DOMSVGPathSegList.cpp',
     'DOMSVGPoint.cpp',
     'DOMSVGPointList.cpp',
     'DOMSVGStringList.cpp',
     'DOMSVGTransform.cpp',
     'DOMSVGTransformList.cpp',
     'nsISVGPoint.cpp',
-    'nsSVGAngle.cpp',
     'nsSVGBoolean.cpp',
     'nsSVGClass.cpp',
     'nsSVGEnum.cpp',
     'nsSVGInteger.cpp',
     'nsSVGIntegerPair.cpp',
     'nsSVGLength2.cpp',
     'nsSVGNumber2.cpp',
     'nsSVGNumberPair.cpp',
     'nsSVGString.cpp',
     'nsSVGViewBox.cpp',
     'SVGAElement.cpp',
+    'SVGAngle.cpp',
     'SVGAnimatedAngle.cpp',
     'SVGAnimatedBoolean.cpp',
     'SVGAnimatedEnumeration.cpp',
     'SVGAnimatedInteger.cpp',
     'SVGAnimatedLength.cpp',
     'SVGAnimatedLengthList.cpp',
     'SVGAnimatedNumber.cpp',
     'SVGAnimatedNumberList.cpp',