Merge mozilla-inbound to mozilla-central a=merge
authorRazvan Maries <rmaries@mozilla.com>
Tue, 01 Jan 2019 11:44:07 +0200
changeset 509336 34970df80385
parent 509328 da77d34af701 (current diff)
parent 509335 389460801c5c (diff)
child 509338 9264db4a8607
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)
reviewersmerge
milestone66.0a1
first release with
nightly linux32
34970df80385 / 66.0a1 / 20190101094742 / files
nightly linux64
34970df80385 / 66.0a1 / 20190101094742 / files
nightly mac
34970df80385 / 66.0a1 / 20190101094742 / files
nightly win32
34970df80385 / 66.0a1 / 20190101094742 / files
nightly win64
34970df80385 / 66.0a1 / 20190101094742 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge mozilla-inbound to mozilla-central a=merge
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',
--- a/taskcluster/ci/test/compiled.yml
+++ b/taskcluster/ci/test/compiled.yml
@@ -56,17 +56,17 @@ jittest:
     suite: jittest/jittest-chunked
     treeherder-symbol: Jit
     instance-size:
         by-test-platform:
             android-em.*: xlarge
             default: default
     run-on-projects:
         by-test-platform:
-            android-hw.*: ['try']
+            android-hw.*: ['try', 'mozilla-central']
             # Turn off for all linux and windows platforms, since it is
             # redundant with SM(...) jobs -- except for code coverage builds,
             # which are still needed since ccov doesn't yet work with
             # spidermonkey jobs.
             #
             # The regex is essentially /linux.*/ but with a negative match for
             # the last 5 characters being "-ccov". The terminal ..... is needed
             # because otherwise the .* could match the full string and the