Merge inbound to mozilla-central. a=merge
authorBogdan Tara <btara@mozilla.com>
Sun, 23 Dec 2018 23:51:31 +0200
changeset 508964 f3e91e53e185
parent 508958 223604c02a0c (current diff)
parent 508963 a3ddcde3d72c (diff)
child 508966 5d8e428324c6
child 508980 c4fce709fbcf
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
f3e91e53e185 / 66.0a1 / 20181223215209 / files
nightly linux64
f3e91e53e185 / 66.0a1 / 20181223215209 / files
nightly mac
f3e91e53e185 / 66.0a1 / 20181223215209 / files
nightly win64
f3e91e53e185 / 66.0a1 / 20181223215209 / files
nightly win32
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win64
Merge inbound to mozilla-central. a=merge
dom/svg/SVGAnimatedTransformList.cpp
dom/svg/SVGAnimatedTransformList.h
--- a/devtools/client/inspector/grids/test/browser.ini
+++ b/devtools/client/inspector/grids/test/browser.ini
@@ -25,17 +25,17 @@ support-files =
 skip-if = (verify && (os == 'win' || os == 'linux'))
 [browser_grids_grid-list-on-mutation-element-added.js]
 [browser_grids_grid-list-on-mutation-element-removed.js]
 [browser_grids_grid-list-toggle-grids_01.js]
 [browser_grids_grid-list-toggle-grids_02.js]
 [browser_grids_grid-list-toggle-multiple-grids.js]
 [browser_grids_grid-outline-cannot-show-outline.js]
 [browser_grids_grid-outline-highlight-area.js]
-skip-if = (verify && (os == 'win'))
+skip-if = (verify && (os == 'win')) || (os == "win" && os_version == "10.0" && !debug) #Bug 1501760
 [browser_grids_grid-outline-highlight-cell.js]
 skip-if = (verify && (os == 'win'))
 [browser_grids_grid-outline-multiple-grids.js]
 [browser_grids_grid-outline-selected-grid.js]
 [browser_grids_grid-outline-updates-on-grid-change.js]
 [browser_grids_grid-outline-writing-mode.js]
 skip-if = (verify && (os == 'win'))
 [browser_grids_highlighter-setting-rules-grid-toggle.js]
--- a/dom/bindings/Bindings.conf
+++ b/dom/bindings/Bindings.conf
@@ -776,16 +776,21 @@ DOMInterfaces = {
     'headerFile': 'DOMSVGAnimatedLengthList.h',
 },
 
 'SVGAnimatedNumberList': {
     'nativeType': 'mozilla::DOMSVGAnimatedNumberList',
     'headerFile': 'DOMSVGAnimatedNumberList.h'
 },
 
+'SVGAnimatedTransformList': {
+    'nativeType': 'mozilla::dom::DOMSVGAnimatedTransformList',
+    'headerFile': 'DOMSVGAnimatedTransformList.h'
+},
+
 'SVGAnimatedPreserveAspectRatio': {
     'nativeType': 'mozilla::dom::DOMSVGAnimatedPreserveAspectRatio',
     'headerFile': 'SVGAnimatedPreserveAspectRatio.h'
 },
 
 'SVGAnimationElement': {
     'concrete': False
 },
rename from dom/svg/SVGAnimatedTransformList.cpp
rename to dom/svg/DOMSVGAnimatedTransformList.cpp
--- a/dom/svg/SVGAnimatedTransformList.cpp
+++ b/dom/svg/DOMSVGAnimatedTransformList.cpp
@@ -1,89 +1,89 @@
 /* -*- 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 "mozilla/dom/SVGAnimatedTransformList.h"
+#include "DOMSVGAnimatedTransformList.h"
 #include "DOMSVGTransformList.h"
 #include "nsSVGAnimatedTransformList.h"
 #include "nsSVGAttrTearoffTable.h"
 #include "mozilla/dom/SVGAnimatedTransformListBinding.h"
 
 namespace mozilla {
 namespace dom {
 
 static nsSVGAttrTearoffTable<nsSVGAnimatedTransformList,
-                             SVGAnimatedTransformList>
+                             DOMSVGAnimatedTransformList>
     sSVGAnimatedTransformListTearoffTable;
 
-NS_SVG_VAL_IMPL_CYCLE_COLLECTION_WRAPPERCACHED(SVGAnimatedTransformList,
+NS_SVG_VAL_IMPL_CYCLE_COLLECTION_WRAPPERCACHED(DOMSVGAnimatedTransformList,
                                                mElement)
 
-NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(SVGAnimatedTransformList, AddRef)
-NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(SVGAnimatedTransformList, Release)
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(DOMSVGAnimatedTransformList, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(DOMSVGAnimatedTransformList, Release)
 
-JSObject* SVGAnimatedTransformList::WrapObject(
+JSObject* DOMSVGAnimatedTransformList::WrapObject(
     JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
   return SVGAnimatedTransformList_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 //----------------------------------------------------------------------
-already_AddRefed<DOMSVGTransformList> SVGAnimatedTransformList::BaseVal() {
+already_AddRefed<DOMSVGTransformList> DOMSVGAnimatedTransformList::BaseVal() {
   if (!mBaseVal) {
     mBaseVal = new DOMSVGTransformList(this, InternalAList().GetBaseValue());
   }
   RefPtr<DOMSVGTransformList> baseVal = mBaseVal;
   return baseVal.forget();
 }
 
-already_AddRefed<DOMSVGTransformList> SVGAnimatedTransformList::AnimVal() {
+already_AddRefed<DOMSVGTransformList> DOMSVGAnimatedTransformList::AnimVal() {
   if (!mAnimVal) {
     mAnimVal = new DOMSVGTransformList(this, InternalAList().GetAnimValue());
   }
   RefPtr<DOMSVGTransformList> animVal = mAnimVal;
   return animVal.forget();
 }
 
-/* static */ already_AddRefed<SVGAnimatedTransformList>
-SVGAnimatedTransformList::GetDOMWrapper(nsSVGAnimatedTransformList* aList,
-                                        SVGElement* aElement) {
-  RefPtr<SVGAnimatedTransformList> wrapper =
+/* static */ already_AddRefed<DOMSVGAnimatedTransformList>
+DOMSVGAnimatedTransformList::GetDOMWrapper(nsSVGAnimatedTransformList* aList,
+                                           SVGElement* aElement) {
+  RefPtr<DOMSVGAnimatedTransformList> wrapper =
       sSVGAnimatedTransformListTearoffTable.GetTearoff(aList);
   if (!wrapper) {
-    wrapper = new SVGAnimatedTransformList(aElement);
+    wrapper = new DOMSVGAnimatedTransformList(aElement);
     sSVGAnimatedTransformListTearoffTable.AddTearoff(aList, wrapper);
   }
   return wrapper.forget();
 }
 
-/* static */ SVGAnimatedTransformList*
-SVGAnimatedTransformList::GetDOMWrapperIfExists(
+/* static */ DOMSVGAnimatedTransformList*
+DOMSVGAnimatedTransformList::GetDOMWrapperIfExists(
     nsSVGAnimatedTransformList* aList) {
   return sSVGAnimatedTransformListTearoffTable.GetTearoff(aList);
 }
 
-SVGAnimatedTransformList::~SVGAnimatedTransformList() {
+DOMSVGAnimatedTransformList::~DOMSVGAnimatedTransformList() {
   // Script no longer has any references to us, to our base/animVal objects, or
   // to any of their list items.
   sSVGAnimatedTransformListTearoffTable.RemoveTearoff(&InternalAList());
 }
 
-void SVGAnimatedTransformList::InternalBaseValListWillChangeLengthTo(
+void DOMSVGAnimatedTransformList::InternalBaseValListWillChangeLengthTo(
     uint32_t aNewLength) {
   // When the number of items in our internal counterpart's baseVal changes,
   // we MUST keep our baseVal in sync. If we don't, script will either see a
   // list that is too short and be unable to access indexes that should be
   // valid, or else, MUCH WORSE, script will see a list that is too long and be
   // able to access "items" at indexes that are out of bounds (read/write to
   // bad memory)!!
 
-  RefPtr<SVGAnimatedTransformList> kungFuDeathGrip;
+  RefPtr<DOMSVGAnimatedTransformList> kungFuDeathGrip;
   if (mBaseVal) {
     if (aNewLength < mBaseVal->LengthNoFlush()) {
       // InternalListLengthWillChange might clear last reference to |this|.
       // Retain a temporary reference to keep from dying before returning.
       kungFuDeathGrip = this;
     }
     mBaseVal->InternalListLengthWillChange(aNewLength);
   }
@@ -93,30 +93,30 @@ void SVGAnimatedTransformList::InternalB
   // SMIL engine takes care of calling InternalAnimValListWillChangeLengthTo()
   // if necessary.)
 
   if (!IsAnimating()) {
     InternalAnimValListWillChangeLengthTo(aNewLength);
   }
 }
 
-void SVGAnimatedTransformList::InternalAnimValListWillChangeLengthTo(
+void DOMSVGAnimatedTransformList::InternalAnimValListWillChangeLengthTo(
     uint32_t aNewLength) {
   if (mAnimVal) {
     mAnimVal->InternalListLengthWillChange(aNewLength);
   }
 }
 
-bool SVGAnimatedTransformList::IsAnimating() const {
+bool DOMSVGAnimatedTransformList::IsAnimating() const {
   return InternalAList().IsAnimating();
 }
 
-nsSVGAnimatedTransformList& SVGAnimatedTransformList::InternalAList() {
+nsSVGAnimatedTransformList& DOMSVGAnimatedTransformList::InternalAList() {
   return *mElement->GetAnimatedTransformList();
 }
 
-const nsSVGAnimatedTransformList& SVGAnimatedTransformList::InternalAList()
+const nsSVGAnimatedTransformList& DOMSVGAnimatedTransformList::InternalAList()
     const {
   return *mElement->GetAnimatedTransformList();
 }
 
 }  // namespace dom
 }  // namespace mozilla
rename from dom/svg/SVGAnimatedTransformList.h
rename to dom/svg/DOMSVGAnimatedTransformList.h
--- a/dom/svg/SVGAnimatedTransformList.h
+++ b/dom/svg/DOMSVGAnimatedTransformList.h
@@ -17,58 +17,60 @@
 namespace mozilla {
 
 class DOMSVGTransformList;
 class nsSVGAnimatedTransformList;
 
 namespace dom {
 
 /**
- * Class SVGAnimatedTransformList
+ * Class DOMSVGAnimatedTransformList
  *
  * This class is used to create the DOM tearoff objects that wrap internal
  * nsSVGAnimatedTransformList objects.
  *
  * See the architecture comment in DOMSVGAnimatedLengthList.h (that's
  * LENGTH list). The comment for that class largly applies to this one too
  * and will go a long way to helping you understand the architecture here.
  *
  * This class is strongly intertwined with DOMSVGTransformList and
  * DOMSVGTransform.
  * Our DOMSVGTransformList base and anim vals are friends and take care of
  * nulling out our pointers to them when they die (making our pointers to them
  * true weak refs).
  */
-class SVGAnimatedTransformList final : public nsWrapperCache {
+class DOMSVGAnimatedTransformList final : public nsWrapperCache {
   friend class mozilla::DOMSVGTransformList;
 
  public:
-  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(SVGAnimatedTransformList)
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(SVGAnimatedTransformList)
+  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(
+      DOMSVGAnimatedTransformList)
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(
+      DOMSVGAnimatedTransformList)
 
   /**
-   * Factory method to create and return a SVGAnimatedTransformList wrapper
+   * Factory method to create and return a DOMSVGAnimatedTransformList wrapper
    * for a given internal nsSVGAnimatedTransformList object. The factory takes
    * care of caching the object that it returns so that the same object can be
    * returned for the given nsSVGAnimatedTransformList each time it is
    * requested. The cached object is only removed from the cache when it is
    * destroyed due to there being no more references to it or to any of its
    * descendant objects. If that happens, any subsequent call requesting the DOM
    * wrapper for the nsSVGAnimatedTransformList will naturally result in a new
-   * SVGAnimatedTransformList being returned.
+   * DOMSVGAnimatedTransformList being returned.
    */
-  static already_AddRefed<SVGAnimatedTransformList> GetDOMWrapper(
+  static already_AddRefed<DOMSVGAnimatedTransformList> GetDOMWrapper(
       nsSVGAnimatedTransformList* aList, SVGElement* aElement);
 
   /**
-   * This method returns the SVGAnimatedTransformList wrapper for an internal
+   * This method returns the DOMSVGAnimatedTransformList wrapper for an internal
    * nsSVGAnimatedTransformList object if it currently has a wrapper. If it does
    * not, then nullptr is returned.
    */
-  static SVGAnimatedTransformList* GetDOMWrapperIfExists(
+  static DOMSVGAnimatedTransformList* GetDOMWrapperIfExists(
       nsSVGAnimatedTransformList* aList);
 
   /**
    * Called by internal code to notify us when we need to sync the length of
    * our baseVal DOM list with its internal list. This is called just prior to
    * the length of the internal baseVal list being changed so that any DOM list
    * items that need to be removed from the DOM list can first get their values
    * from their internal counterpart.
@@ -95,20 +97,20 @@ class SVGAnimatedTransformList final : p
   already_AddRefed<DOMSVGTransformList> BaseVal();
   already_AddRefed<DOMSVGTransformList> AnimVal();
 
  private:
   /**
    * Only our static GetDOMWrapper() factory method may create objects of our
    * type.
    */
-  explicit SVGAnimatedTransformList(SVGElement* aElement)
+  explicit DOMSVGAnimatedTransformList(SVGElement* aElement)
       : mBaseVal(nullptr), mAnimVal(nullptr), mElement(aElement) {}
 
-  ~SVGAnimatedTransformList();
+  ~DOMSVGAnimatedTransformList();
 
   /// Get a reference to this DOM wrapper object's internal counterpart.
   nsSVGAnimatedTransformList& InternalAList();
   const nsSVGAnimatedTransformList& InternalAList() const;
 
   // Weak refs to our DOMSVGTransformList baseVal/animVal objects. These objects
   // are friends and take care of clearing these pointers when they die, making
   // these true weak references.
--- a/dom/svg/DOMSVGTransformList.h
+++ b/dom/svg/DOMSVGTransformList.h
@@ -2,17 +2,17 @@
 /* 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 MOZILLA_DOMSVGTRANSFORMLIST_H__
 #define MOZILLA_DOMSVGTRANSFORMLIST_H__
 
-#include "mozilla/dom/SVGAnimatedTransformList.h"
+#include "DOMSVGAnimatedTransformList.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsDebug.h"
 #include "nsTArray.h"
 #include "SVGTransformList.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/ErrorResult.h"
 
 namespace mozilla {
@@ -24,17 +24,17 @@ class SVGTransform;
 }  // namespace dom
 
 /**
  * Class DOMSVGTransformList
  *
  * This class is used to create the DOM tearoff objects that wrap internal
  * SVGTransformList objects.
  *
- * See the architecture comment in SVGAnimatedTransformList.h.
+ * See the architecture comment in DOMSVGAnimatedTransformList.h.
  */
 class DOMSVGTransformList final : public nsISupports, public nsWrapperCache {
   friend class AutoChangeTransformListNotifier;
   friend class dom::SVGTransform;
 
   ~DOMSVGTransformList() {
     // Our mAList's weak ref to us must be nulled out when we die. If GC has
     // unlinked us using the cycle collector code, then that has already
@@ -43,17 +43,17 @@ class DOMSVGTransformList final : public
       (IsAnimValList() ? mAList->mAnimVal : mAList->mBaseVal) = nullptr;
     }
   }
 
  public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DOMSVGTransformList)
 
-  DOMSVGTransformList(dom::SVGAnimatedTransformList* aAList,
+  DOMSVGTransformList(dom::DOMSVGAnimatedTransformList* aAList,
                       const SVGTransformList& aInternalList)
       : mAList(aAList) {
     // aInternalList must be passed in explicitly because we can't use
     // InternalList() here. (Because it depends on IsAnimValList, which depends
     // on this object having been assigned to aAList's mBaseVal or mAnimVal,
     // which hasn't happened yet.)
 
     InternalListLengthWillChange(aInternalList.Length());  // Sync mItems
@@ -143,14 +143,14 @@ class DOMSVGTransformList final : public
 
   void MaybeInsertNullInAnimValListAt(uint32_t aIndex);
   void MaybeRemoveItemFromAnimValListAt(uint32_t aIndex);
 
   // Weak refs to our SVGTransform items. The items are friends and take care
   // of clearing our pointer to them when they die.
   FallibleTArray<dom::SVGTransform*> mItems;
 
-  RefPtr<dom::SVGAnimatedTransformList> mAList;
+  RefPtr<dom::DOMSVGAnimatedTransformList> mAList;
 };
 
 }  // namespace mozilla
 
 #endif  // MOZILLA_DOMSVGTRANSFORMLIST_H__
--- a/dom/svg/SVGGradientElement.cpp
+++ b/dom/svg/SVGGradientElement.cpp
@@ -2,17 +2,17 @@
 /* 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 "mozilla/dom/SVGGradientElement.h"
 
 #include "mozilla/ArrayUtils.h"
-#include "mozilla/dom/SVGAnimatedTransformList.h"
+#include "DOMSVGAnimatedTransformList.h"
 #include "mozilla/dom/SVGGradientElementBinding.h"
 #include "mozilla/dom/SVGRadialGradientElementBinding.h"
 #include "mozilla/dom/SVGLengthBinding.h"
 #include "mozilla/dom/SVGLinearGradientElementBinding.h"
 #include "mozilla/dom/SVGUnitTypesBinding.h"
 #include "nsCOMPtr.h"
 #include "nsGkAtoms.h"
 #include "SVGElement.h"
@@ -61,21 +61,21 @@ SVGElement::StringAttributesInfo SVGGrad
   return StringAttributesInfo(mStringAttributes, sStringInfo,
                               ArrayLength(sStringInfo));
 }
 
 already_AddRefed<SVGAnimatedEnumeration> SVGGradientElement::GradientUnits() {
   return mEnumAttributes[GRADIENTUNITS].ToDOMAnimatedEnum(this);
 }
 
-already_AddRefed<SVGAnimatedTransformList>
+already_AddRefed<DOMSVGAnimatedTransformList>
 SVGGradientElement::GradientTransform() {
   // We're creating a DOM wrapper, so we must tell GetAnimatedTransformList
-  // to allocate the SVGAnimatedTransformList if it hasn't already done so:
-  return SVGAnimatedTransformList::GetDOMWrapper(
+  // to allocate the DOMSVGAnimatedTransformList if it hasn't already done so:
+  return DOMSVGAnimatedTransformList::GetDOMWrapper(
       GetAnimatedTransformList(DO_ALLOCATE), this);
 }
 
 already_AddRefed<SVGAnimatedEnumeration> SVGGradientElement::SpreadMethod() {
   return mEnumAttributes[SPREADMETHOD].ToDOMAnimatedEnum(this);
 }
 
 already_AddRefed<SVGAnimatedString> SVGGradientElement::Href() {
--- a/dom/svg/SVGGradientElement.h
+++ b/dom/svg/SVGGradientElement.h
@@ -21,17 +21,17 @@ class nsSVGRadialGradientFrame;
 nsresult NS_NewSVGLinearGradientElement(
     nsIContent** aResult, already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
 nsresult NS_NewSVGRadialGradientElement(
     nsIContent** aResult, already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
 
 namespace mozilla {
 namespace dom {
 
-class SVGAnimatedTransformList;
+class DOMSVGAnimatedTransformList;
 
 //--------------------- Gradients------------------------
 
 typedef SVGElement SVGGradientElementBase;
 
 class SVGGradientElement : public SVGGradientElementBase {
   friend class ::nsSVGGradientFrame;
 
@@ -50,17 +50,17 @@ class SVGGradientElement : public SVGGra
   virtual nsSVGAnimatedTransformList* GetAnimatedTransformList(
       uint32_t aFlags = 0) override;
   virtual nsStaticAtom* GetTransformListAttrName() const override {
     return nsGkAtoms::gradientTransform;
   }
 
   // WebIDL
   already_AddRefed<SVGAnimatedEnumeration> GradientUnits();
-  already_AddRefed<SVGAnimatedTransformList> GradientTransform();
+  already_AddRefed<DOMSVGAnimatedTransformList> GradientTransform();
   already_AddRefed<SVGAnimatedEnumeration> SpreadMethod();
   already_AddRefed<SVGAnimatedString> Href();
 
  protected:
   virtual EnumAttributesInfo GetEnumInfo() override;
   virtual StringAttributesInfo GetStringInfo() override;
 
   enum { GRADIENTUNITS, SPREADMETHOD };
--- a/dom/svg/SVGPatternElement.cpp
+++ b/dom/svg/SVGPatternElement.cpp
@@ -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/. */
 
 #include "mozilla/ArrayUtils.h"
 
 #include "nsCOMPtr.h"
 #include "nsGkAtoms.h"
-#include "mozilla/dom/SVGAnimatedTransformList.h"
+#include "DOMSVGAnimatedTransformList.h"
 #include "mozilla/dom/SVGLengthBinding.h"
 #include "mozilla/dom/SVGPatternElement.h"
 #include "mozilla/dom/SVGPatternElementBinding.h"
 #include "mozilla/dom/SVGUnitTypesBinding.h"
 
 NS_IMPL_NS_NEW_SVG_ELEMENT(Pattern)
 
 namespace mozilla {
@@ -78,21 +78,21 @@ already_AddRefed<SVGAnimatedEnumeration>
   return mEnumAttributes[PATTERNUNITS].ToDOMAnimatedEnum(this);
 }
 
 already_AddRefed<SVGAnimatedEnumeration>
 SVGPatternElement::PatternContentUnits() {
   return mEnumAttributes[PATTERNCONTENTUNITS].ToDOMAnimatedEnum(this);
 }
 
-already_AddRefed<SVGAnimatedTransformList>
+already_AddRefed<DOMSVGAnimatedTransformList>
 SVGPatternElement::PatternTransform() {
   // We're creating a DOM wrapper, so we must tell GetAnimatedTransformList
-  // to allocate the SVGAnimatedTransformList if it hasn't already done so:
-  return SVGAnimatedTransformList::GetDOMWrapper(
+  // to allocate the DOMSVGAnimatedTransformList if it hasn't already done so:
+  return DOMSVGAnimatedTransformList::GetDOMWrapper(
       GetAnimatedTransformList(DO_ALLOCATE), this);
 }
 
 already_AddRefed<SVGAnimatedLength> SVGPatternElement::X() {
   return mLengthAttributes[ATTR_X].ToDOMAnimatedLength(this);
 }
 
 already_AddRefed<SVGAnimatedLength> SVGPatternElement::Y() {
--- a/dom/svg/SVGPatternElement.h
+++ b/dom/svg/SVGPatternElement.h
@@ -18,17 +18,17 @@
 
 class nsSVGPatternFrame;
 
 nsresult NS_NewSVGPatternElement(
     nsIContent** aResult, already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
 
 namespace mozilla {
 namespace dom {
-class SVGAnimatedTransformList;
+class DOMSVGAnimatedTransformList;
 
 typedef SVGElement SVGPatternElementBase;
 
 class SVGPatternElement final : public SVGPatternElementBase {
   friend class ::nsSVGPatternFrame;
 
  protected:
   friend nsresult(::NS_NewSVGPatternElement(
@@ -57,17 +57,17 @@ class SVGPatternElement final : public S
     return nsGkAtoms::patternTransform;
   }
 
   // WebIDL
   already_AddRefed<SVGAnimatedRect> ViewBox();
   already_AddRefed<DOMSVGAnimatedPreserveAspectRatio> PreserveAspectRatio();
   already_AddRefed<SVGAnimatedEnumeration> PatternUnits();
   already_AddRefed<SVGAnimatedEnumeration> PatternContentUnits();
-  already_AddRefed<SVGAnimatedTransformList> PatternTransform();
+  already_AddRefed<DOMSVGAnimatedTransformList> PatternTransform();
   already_AddRefed<SVGAnimatedLength> X();
   already_AddRefed<SVGAnimatedLength> Y();
   already_AddRefed<SVGAnimatedLength> Width();
   already_AddRefed<SVGAnimatedLength> Height();
   already_AddRefed<SVGAnimatedString> Href();
 
  protected:
   virtual LengthAttributesInfo GetLengthInfo() override;
--- a/dom/svg/SVGTransformList.h
+++ b/dom/svg/SVGTransformList.h
@@ -59,18 +59,18 @@ class SVGTransformList {
   void Compact() { mItems.Compact(); }
 
   gfxMatrix GetConsolidationMatrix() const;
 
   // Access to methods that can modify objects of this type is deliberately
   // limited. This is to reduce the chances of someone modifying objects of
   // this type without taking the necessary steps to keep DOM wrappers in sync.
   // If you need wider access to these methods, consider adding a method to
-  // SVGAnimatedTransformList and having that class act as an intermediary so it
-  // can take care of keeping DOM wrappers in sync.
+  // DOMSVGAnimatedTransformList and having that class act as an intermediary so
+  // it can take care of keeping DOM wrappers in sync.
 
  protected:
   /**
    * These may fail on OOM if the internal capacity needs to be increased, in
    * which case the list will be left unmodified.
    */
   nsresult CopyFrom(const SVGTransformList& rhs);
   nsresult CopyFrom(const nsTArray<nsSVGTransform>& aTransformArray);
--- a/dom/svg/SVGTransformableElement.cpp
+++ b/dom/svg/SVGTransformableElement.cpp
@@ -1,38 +1,38 @@
 /* -*- 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 "gfx2DGlue.h"
 #include "mozilla/dom/MutationEventBinding.h"
-#include "mozilla/dom/SVGAnimatedTransformList.h"
+#include "DOMSVGAnimatedTransformList.h"
 #include "mozilla/dom/SVGGraphicsElementBinding.h"
 #include "mozilla/dom/SVGTransformableElement.h"
 #include "mozilla/dom/SVGMatrix.h"
 #include "mozilla/dom/SVGSVGElement.h"
 #include "nsContentUtils.h"
 #include "nsIFrame.h"
 #include "nsSVGDisplayableFrame.h"
 #include "mozilla/dom/SVGRect.h"
 #include "nsSVGUtils.h"
 #include "SVGContentUtils.h"
 
 using namespace mozilla::gfx;
 
 namespace mozilla {
 namespace dom {
 
-already_AddRefed<SVGAnimatedTransformList>
+already_AddRefed<DOMSVGAnimatedTransformList>
 SVGTransformableElement::Transform() {
   // We're creating a DOM wrapper, so we must tell GetAnimatedTransformList
-  // to allocate the SVGAnimatedTransformList if it hasn't already done so:
-  return SVGAnimatedTransformList::GetDOMWrapper(
+  // to allocate the DOMSVGAnimatedTransformList if it hasn't already done so:
+  return DOMSVGAnimatedTransformList::GetDOMWrapper(
       GetAnimatedTransformList(DO_ALLOCATE), this);
 }
 
 //----------------------------------------------------------------------
 // nsIContent methods
 
 NS_IMETHODIMP_(bool)
 SVGTransformableElement::IsAttributeMapped(const nsAtom* name) const {
--- a/dom/svg/SVGTransformableElement.h
+++ b/dom/svg/SVGTransformableElement.h
@@ -12,32 +12,32 @@
 #include "nsSVGAnimatedTransformList.h"
 #include "SVGElement.h"
 #include "gfxMatrix.h"
 #include "mozilla/gfx/Matrix.h"
 
 namespace mozilla {
 namespace dom {
 
-class SVGAnimatedTransformList;
+class DOMSVGAnimatedTransformList;
 class SVGGraphicsElement;
 class SVGMatrix;
 class SVGIRect;
 struct SVGBoundingBoxOptions;
 
 class SVGTransformableElement : public SVGElement {
  public:
   explicit SVGTransformableElement(already_AddRefed<dom::NodeInfo>&& aNodeInfo)
       : SVGElement(std::move(aNodeInfo)) {}
   virtual ~SVGTransformableElement() {}
 
   virtual nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override = 0;
 
   // WebIDL
-  already_AddRefed<SVGAnimatedTransformList> Transform();
+  already_AddRefed<DOMSVGAnimatedTransformList> Transform();
   SVGElement* GetNearestViewportElement();
   SVGElement* GetFarthestViewportElement();
   MOZ_CAN_RUN_SCRIPT
   already_AddRefed<SVGIRect> GetBBox(const SVGBoundingBoxOptions& aOptions,
                                      ErrorResult& rv);
   already_AddRefed<SVGMatrix> GetCTM();
   already_AddRefed<SVGMatrix> GetScreenCTM();
   already_AddRefed<SVGMatrix> GetTransformToElement(
--- a/dom/svg/moz.build
+++ b/dom/svg/moz.build
@@ -27,17 +27,16 @@ EXPORTS.mozilla.dom += [
     'SVGAnimatedBoolean.h',
     'SVGAnimatedEnumeration.h',
     'SVGAnimatedInteger.h',
     'SVGAnimatedLength.h',
     'SVGAnimatedNumber.h',
     'SVGAnimatedPathSegList.h',
     'SVGAnimatedRect.h',
     'SVGAnimatedString.h',
-    'SVGAnimatedTransformList.h',
     'SVGAnimateElement.h',
     'SVGAnimateMotionElement.h',
     'SVGAnimateTransformElement.h',
     'SVGAnimationElement.h',
     'SVGCircleElement.h',
     'SVGClipPathElement.h',
     'SVGComponentTransferFunctionElement.h',
     'SVGDefsElement.h',
@@ -107,16 +106,17 @@ EXPORTS.mozilla.dom += [
     'SVGUseElement.h',
     'SVGViewElement.h',
     'SVGViewportElement.h',
 ]
 
 UNIFIED_SOURCES += [
     'DOMSVGAnimatedLengthList.cpp',
     'DOMSVGAnimatedNumberList.cpp',
+    'DOMSVGAnimatedTransformList.cpp',
     'DOMSVGLength.cpp',
     'DOMSVGLengthList.cpp',
     'DOMSVGNumber.cpp',
     'DOMSVGNumberList.cpp',
     'DOMSVGPathSeg.cpp',
     'DOMSVGPathSegList.cpp',
     'DOMSVGPoint.cpp',
     'DOMSVGPointList.cpp',
@@ -147,17 +147,16 @@ UNIFIED_SOURCES += [
     'SVGAnimatedLengthList.cpp',
     'SVGAnimatedNumber.cpp',
     'SVGAnimatedNumberList.cpp',
     'SVGAnimatedPathSegList.cpp',
     'SVGAnimatedPointList.cpp',
     'SVGAnimatedPreserveAspectRatio.cpp',
     'SVGAnimatedRect.cpp',
     'SVGAnimatedString.cpp',
-    'SVGAnimatedTransformList.cpp',
     'SVGAnimateElement.cpp',
     'SVGAnimateMotionElement.cpp',
     'SVGAnimateTransformElement.cpp',
     'SVGAnimationElement.cpp',
     'SVGAttrValueWrapper.cpp',
     'SVGCircleElement.cpp',
     'SVGClipPathElement.cpp',
     'SVGContentUtils.cpp',
--- a/dom/svg/nsSVGAnimatedTransformList.cpp
+++ b/dom/svg/nsSVGAnimatedTransformList.cpp
@@ -2,17 +2,17 @@
 /* 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 "nsSVGAnimatedTransformList.h"
 
 #include "mozilla/dom/MutationEventBinding.h"
-#include "mozilla/dom/SVGAnimatedTransformList.h"
+#include "DOMSVGAnimatedTransformList.h"
 #include "mozilla/dom/SVGAnimationElement.h"
 #include "mozilla/Move.h"
 #include "nsCharSeparatedTokenizer.h"
 #include "nsSVGTransform.h"
 #include "nsSMILValue.h"
 #include "SVGContentUtils.h"
 #include "SVGTransformListSMILType.h"
 
@@ -29,18 +29,18 @@ nsresult nsSVGAnimatedTransformList::Set
     return rv;
   }
 
   return SetBaseValue(newBaseValue, aSVGElement);
 }
 
 nsresult nsSVGAnimatedTransformList::SetBaseValue(
     const SVGTransformList& aValue, SVGElement* aSVGElement) {
-  SVGAnimatedTransformList* domWrapper =
-      SVGAnimatedTransformList::GetDOMWrapperIfExists(this);
+  DOMSVGAnimatedTransformList* domWrapper =
+      DOMSVGAnimatedTransformList::GetDOMWrapperIfExists(this);
   if (domWrapper) {
     // We must send this notification *before* changing mBaseVal! If the length
     // of our baseVal is being reduced, our baseVal's DOM wrapper list may have
     // to remove DOM items from itself, and any removed DOM items need to copy
     // their internal counterpart values *before* we change them.
     //
     domWrapper->InternalBaseValListWillChangeLengthTo(aValue.Length());
   }
@@ -65,38 +65,38 @@ nsresult nsSVGAnimatedTransformList::Set
         aSVGElement->GetPrimaryFrame() && !hadTransform;
   }
   return rv;
 }
 
 void nsSVGAnimatedTransformList::ClearBaseValue() {
   mRequiresFrameReconstruction = !HasTransform();
 
-  SVGAnimatedTransformList* domWrapper =
-      SVGAnimatedTransformList::GetDOMWrapperIfExists(this);
+  DOMSVGAnimatedTransformList* domWrapper =
+      DOMSVGAnimatedTransformList::GetDOMWrapperIfExists(this);
   if (domWrapper) {
     // We must send this notification *before* changing mBaseVal! (See above.)
     domWrapper->InternalBaseValListWillChangeLengthTo(0);
   }
   mBaseVal.Clear();
   mIsAttrSet = false;
   // Caller notifies
 }
 
 nsresult nsSVGAnimatedTransformList::SetAnimValue(
     const SVGTransformList& aValue, SVGElement* aElement) {
   bool prevSet = HasTransform() || aElement->GetAnimateMotionTransform();
-  SVGAnimatedTransformList* domWrapper =
-      SVGAnimatedTransformList::GetDOMWrapperIfExists(this);
+  DOMSVGAnimatedTransformList* domWrapper =
+      DOMSVGAnimatedTransformList::GetDOMWrapperIfExists(this);
   if (domWrapper) {
     // A new animation may totally change the number of items in the animVal
     // list, replacing what was essentially a mirror of the baseVal list, or
     // else replacing and overriding an existing animation. When this happens
     // we must try and keep our animVal's DOM wrapper in sync (see the comment
-    // in SVGAnimatedTransformList::InternalBaseValListWillChangeLengthTo).
+    // in DOMSVGAnimatedTransformList::InternalBaseValListWillChangeLengthTo).
     //
     // It's not possible for us to reliably distinguish between calls to this
     // method that are setting a new sample for an existing animation, and
     // calls that are setting the first sample of an animation that will
     // override an existing animation. Happily it's cheap to just blindly
     // notify our animVal's DOM wrapper of its internal counterpart's new value
     // each time this method is called, so that's what we do.
     //
@@ -121,18 +121,18 @@ nsresult nsSVGAnimatedTransformList::Set
   } else {
     modType = MutationEvent_Binding::ADDITION;
   }
   aElement->DidAnimateTransformList(modType);
   return NS_OK;
 }
 
 void nsSVGAnimatedTransformList::ClearAnimValue(SVGElement* aElement) {
-  SVGAnimatedTransformList* domWrapper =
-      SVGAnimatedTransformList::GetDOMWrapperIfExists(this);
+  DOMSVGAnimatedTransformList* domWrapper =
+      DOMSVGAnimatedTransformList::GetDOMWrapperIfExists(this);
   if (domWrapper) {
     // When all animation ends, animVal simply mirrors baseVal, which may have
     // a different number of items to the last active animated value. We must
     // keep the length of our animVal's DOM wrapper list in sync, and again we
     // must do that before touching mAnimVal. See comments above.
     //
     domWrapper->InternalAnimValListWillChangeLengthTo(mBaseVal.Length());
   }
--- a/dom/svg/nsSVGAnimatedTransformList.h
+++ b/dom/svg/nsSVGAnimatedTransformList.h
@@ -24,38 +24,38 @@ class SVGElement;
 class SVGTransform;
 }  // namespace dom
 
 /**
  * Class nsSVGAnimatedTransformList
  *
  * This class is very different to the SVG DOM interface of the same name found
  * in the SVG specification. This is a lightweight internal class - see
- * SVGAnimatedTransformList for the heavier DOM class that wraps instances of
+ * DOMSVGAnimatedTransformList for the heavier DOM class that wraps instances of
  * this class and implements the SVG specification's SVGAnimatedTransformList
  * DOM interface.
  *
  * Except where noted otherwise, this class' methods take care of keeping the
  * appropriate DOM wrappers in sync (see the comment in
- * SVGAnimatedTransformList::InternalBaseValListWillChangeTo) so that their
+ * DOMSVGAnimatedTransformList::InternalBaseValListWillChangeTo) so that their
  * consumers don't need to concern themselves with that.
  */
 class nsSVGAnimatedTransformList {
   // friends so that they can get write access to mBaseVal
   friend class dom::SVGTransform;
   friend class DOMSVGTransformList;
 
  public:
   nsSVGAnimatedTransformList()
       : mIsAttrSet(false), mRequiresFrameReconstruction(true) {}
 
   /**
    * Because it's so important that mBaseVal and its DOMSVGTransformList wrapper
    * (if any) be kept in sync (see the comment in
-   * SVGAnimatedTransformList::InternalBaseValListWillChangeTo), this method
+   * DOMSVGAnimatedTransformList::InternalBaseValListWillChangeTo), this method
    * returns a const reference. Only our friend classes may get mutable
    * references to mBaseVal.
    */
   const SVGTransformList& GetBaseValue() const { return mBaseVal; }
 
   nsresult SetBaseValue(const SVGTransformList& aValue,
                         dom::SVGElement* aSVGElement);
 
--- a/layout/svg/SVGGeometryFrame.cpp
+++ b/layout/svg/SVGGeometryFrame.cpp
@@ -20,17 +20,17 @@
 #include "nsGkAtoms.h"
 #include "nsLayoutUtils.h"
 #include "SVGObserverUtils.h"
 #include "nsSVGIntegrationUtils.h"
 #include "nsSVGMarkerFrame.h"
 #include "SVGGeometryElement.h"
 #include "nsSVGUtils.h"
 #include "mozilla/ArrayUtils.h"
-#include "SVGAnimatedTransformList.h"
+#include "nsSVGAnimatedTransformList.h"
 #include "SVGContentUtils.h"
 #include "SVGGraphicsElement.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::gfx;
 using namespace mozilla::image;