Merge mozilla-inbound to mozilla-central a=merge
authorRazvan Maries <rmaries@mozilla.com>
Sun, 28 Apr 2019 00:39:52 +0300
changeset 530476 b0d41799ceb31e39ea857f18f4a65e8944818c6a
parent 530471 70a7b7db7b84452a83026949fccda6d10ca57869 (current diff)
parent 530475 d134fc3b9e290ccd3404890491dee63d0c5fcdbf (diff)
child 530484 14e82cfcd7270d40294542ba24f03ee459830e8e
child 530510 5257cabf18a9f322ff48973f2e02cc830eba5aa1
push id11265
push userffxbld-merge
push dateMon, 13 May 2019 10:53:39 +0000
treeherdermozilla-beta@77e0fe8dbdd3 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone68.0a1
first release with
nightly linux32
b0d41799ceb3 / 68.0a1 / 20190427214042 / files
nightly linux64
b0d41799ceb3 / 68.0a1 / 20190427214042 / files
nightly mac
b0d41799ceb3 / 68.0a1 / 20190427214042 / files
nightly win32
b0d41799ceb3 / 68.0a1 / 20190427214042 / files
nightly win64
b0d41799ceb3 / 68.0a1 / 20190427214042 / 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
layout/svg/nsSVGSwitchFrame.cpp
layout/svg/nsSVGUtils.h
--- a/dom/localstorage/ActorsParent.cpp
+++ b/dom/localstorage/ActorsParent.cpp
@@ -7689,17 +7689,17 @@ nsresult QuotaClient::InitOrigin(Persist
 
       rv = usageJournalFile->Remove(false);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         REPORT_TELEMETRY_INIT_ERR(kExternalError, LS_Remove3);
         return rv;
       }
     }
 
-    MOZ_ASSERT(usage >= 0);
+    MOZ_DIAGNOSTIC_ASSERT(usage >= 0);
 
     if (!aForGetUsage) {
       InitUsageForOrigin(aOrigin, usage);
     }
 
     aUsageInfo->AppendToDatabaseUsage(uint64_t(usage));
   } else if (usageFileExists) {
     rv = usageFile->Remove(false);
--- a/dom/smil/SMILTimeValueSpec.h
+++ b/dom/smil/SMILTimeValueSpec.h
@@ -66,18 +66,18 @@ class SMILTimeValueSpec {
   void Traverse(nsCycleCollectionTraversalCallback* aCallback);
   void Unlink();
 
  protected:
   void UpdateReferencedElement(Element* aFrom, Element* aTo);
   void UnregisterFromReferencedElement(Element* aElement);
   SMILTimedElement* GetTimedElement(Element* aElement);
   bool IsWhitelistedEvent();
-  void RegisterEventListener(Element* aElement);
-  void UnregisterEventListener(Element* aElement);
+  void RegisterEventListener(Element* aTarget);
+  void UnregisterEventListener(Element* aTarget);
   void HandleEvent(Event* aEvent);
   bool CheckRepeatEventDetail(Event* aEvent);
   SMILTimeValue ConvertBetweenTimeContainers(
       const SMILTimeValue& aSrcTime, const SMILTimeContainer* aSrcContainer);
   bool ApplyOffset(SMILTimeValue& aTime) const;
 
   SMILTimedElement* mOwner;
   bool mIsBegin;  // Indicates if *we* are a begin spec,
--- a/dom/smil/SMILTimedElement.h
+++ b/dom/smil/SMILTimedElement.h
@@ -170,22 +170,22 @@ class SMILTimedElement {
    */
   void RemoveInstanceTime(SMILInstanceTime* aInstanceTime, bool aIsBegin);
 
   /**
    * Removes all the instance times associated with the given
    * SMILTimeValueSpec object. Used when an ID assignment changes and hence
    * all the previously associated instance times become invalid.
    *
-   * @param aSpec    The SMILTimeValueSpec object whose created
+   * @param aCreator The SMILTimeValueSpec object whose created
    *                 SMILInstanceTime's should be removed.
    * @param aIsBegin true if the times to be removed represent begin
    *                 times or false if they are end times.
    */
-  void RemoveInstanceTimesForCreator(const SMILTimeValueSpec* aSpec,
+  void RemoveInstanceTimesForCreator(const SMILTimeValueSpec* aCreator,
                                      bool aIsBegin);
 
   /**
    * Sets the object that will be called by this timed element each time it is
    * sampled.
    *
    * In Schmitz's model it is possible to associate several time clients with
    * a timed element but for now we only allow one.
--- a/dom/svg/DOMSVGLength.h
+++ b/dom/svg/DOMSVGLength.h
@@ -160,17 +160,17 @@ class DOMSVGLength final : public nsISup
    */
   void RemovingFromList();
 
   SVGLength ToSVGLength();
 
   // WebIDL
   uint16_t UnitType();
   float GetValue(ErrorResult& aRv);
-  void SetValue(float aValue, ErrorResult& aRv);
+  void SetValue(float aUserUnitValue, ErrorResult& aRv);
   float ValueInSpecifiedUnits();
   void SetValueInSpecifiedUnits(float aValue, ErrorResult& aRv);
   void GetValueAsString(nsAString& aValue);
   void SetValueAsString(const nsAString& aValue, ErrorResult& aRv);
   void NewValueSpecifiedUnits(uint16_t aUnit, float aValue, ErrorResult& aRv);
   void ConvertToSpecifiedUnits(uint16_t aUnit, ErrorResult& aRv);
 
   nsISupports* GetParentObject() const {
--- a/dom/svg/DOMSVGNumberList.h
+++ b/dom/svg/DOMSVGNumberList.h
@@ -100,25 +100,25 @@ class DOMSVGNumberList final : public ns
 
   uint32_t NumberOfItems() const {
     if (IsAnimValList()) {
       Element()->FlushAnimations();
     }
     return LengthNoFlush();
   }
   void Clear(ErrorResult& error);
-  already_AddRefed<DOMSVGNumber> Initialize(DOMSVGNumber& newItem,
+  already_AddRefed<DOMSVGNumber> Initialize(DOMSVGNumber& aItem,
                                             ErrorResult& error);
   already_AddRefed<DOMSVGNumber> GetItem(uint32_t index, ErrorResult& error);
   already_AddRefed<DOMSVGNumber> IndexedGetter(uint32_t index, bool& found,
                                                ErrorResult& error);
-  already_AddRefed<DOMSVGNumber> InsertItemBefore(DOMSVGNumber& newItem,
+  already_AddRefed<DOMSVGNumber> InsertItemBefore(DOMSVGNumber& aItem,
                                                   uint32_t index,
                                                   ErrorResult& error);
-  already_AddRefed<DOMSVGNumber> ReplaceItem(DOMSVGNumber& newItem,
+  already_AddRefed<DOMSVGNumber> ReplaceItem(DOMSVGNumber& aItem,
                                              uint32_t index,
                                              ErrorResult& error);
   already_AddRefed<DOMSVGNumber> RemoveItem(uint32_t index, ErrorResult& error);
   already_AddRefed<DOMSVGNumber> AppendItem(DOMSVGNumber& newItem,
                                             ErrorResult& error) {
     return InsertItemBefore(newItem, LengthNoFlush(), error);
   }
   uint32_t Length() const { return NumberOfItems(); }
--- a/dom/svg/DOMSVGPathSeg.h
+++ b/dom/svg/DOMSVGPathSeg.h
@@ -129,17 +129,17 @@ class DOMSVGPathSeg : public nsWrapperCa
   void RemovingFromList();
 
   /**
    * This method converts the segment to a string of floats as found in
    * SVGPathData (i.e. the first float contains the type of the segment,
    * encoded into a float, followed by its arguments in the same order as they
    * are given in the <path> element's 'd' attribute).
    */
-  void ToSVGPathSegEncodedData(float* aData);
+  void ToSVGPathSegEncodedData(float* aRaw);
 
   /**
    * The type of this path segment.
    */
   virtual uint32_t Type() const = 0;
 
   // WebIDL
   DOMSVGPathSegList* GetParentObject() { return mList; }
@@ -434,19 +434,19 @@ class DOMSVGPathSegArcAbs : public DOMSV
   void SetY(float aY, ErrorResult& rv);
   float R1();
   void SetR1(float aR1, ErrorResult& rv);
   float R2();
   void SetR2(float aR2, ErrorResult& rv);
   float Angle();
   void SetAngle(float aAngle, ErrorResult& rv);
   bool LargeArcFlag();
-  void SetLargeArcFlag(bool aFlag, ErrorResult& rv);
+  void SetLargeArcFlag(bool aLargeArcFlag, ErrorResult& rv);
   bool SweepFlag();
-  void SetSweepFlag(bool aFlag, ErrorResult& rv);
+  void SetSweepFlag(bool aSweepFlag, ErrorResult& rv);
 
  protected:
   float mArgs[7];
 };
 
 class DOMSVGPathSegArcRel : public DOMSVGPathSeg {
  public:
   DOMSVGPathSegArcRel(float r1, float r2, float angle, bool largeArcFlag,
@@ -470,19 +470,19 @@ class DOMSVGPathSegArcRel : public DOMSV
   void SetY(float aY, ErrorResult& rv);
   float R1();
   void SetR1(float aR1, ErrorResult& rv);
   float R2();
   void SetR2(float aR2, ErrorResult& rv);
   float Angle();
   void SetAngle(float aAngle, ErrorResult& rv);
   bool LargeArcFlag();
-  void SetLargeArcFlag(bool aFlag, ErrorResult& rv);
+  void SetLargeArcFlag(bool aLargeArcFlag, ErrorResult& rv);
   bool SweepFlag();
-  void SetSweepFlag(bool aFlag, ErrorResult& rv);
+  void SetSweepFlag(bool aSweepFlag, ErrorResult& rv);
 
  protected:
   float mArgs[7];
 };
 
 class DOMSVGPathSegLinetoHorizontalAbs : public DOMSVGPathSeg {
  public:
   explicit DOMSVGPathSegLinetoHorizontalAbs(float x) : DOMSVGPathSeg() {
--- a/dom/svg/DOMSVGTransform.h
+++ b/dom/svg/DOMSVGTransform.h
@@ -49,17 +49,17 @@ class DOMSVGTransform final : public nsW
    * which do not initially belong to an attribute.
    */
   explicit DOMSVGTransform();
   explicit DOMSVGTransform(const gfxMatrix& aMatrix);
 
   /**
    * Ctor for creating an unowned copy. Used with Clone().
    */
-  explicit DOMSVGTransform(const SVGTransform& aMatrix);
+  explicit DOMSVGTransform(const SVGTransform& aTransform);
 
   /**
    * Create an unowned copy of an owned transform. The caller is responsible for
    * the first AddRef().
    */
   DOMSVGTransform* Clone() {
     NS_ASSERTION(mList, "unexpected caller");
     return new DOMSVGTransform(InternalItem());
--- a/dom/svg/SVGAElement.h
+++ b/dom/svg/SVGAElement.h
@@ -71,19 +71,18 @@ class SVGAElement final : public SVGAEle
   already_AddRefed<DOMSVGAnimatedString> Href();
   already_AddRefed<DOMSVGAnimatedString> Target();
   void GetDownload(nsAString& aDownload);
   void SetDownload(const nsAString& aDownload, ErrorResult& rv);
   void GetPing(nsAString& aPing);
   void SetPing(const nsAString& aPing, mozilla::ErrorResult& rv);
   void GetRel(nsAString& aRel);
   void SetRel(const nsAString& aRel, mozilla::ErrorResult& rv);
-  void SetReferrerPolicy(const nsAString& aReferrerPolicy,
-                         mozilla::ErrorResult& rv);
-  void GetReferrerPolicy(nsAString& aReferrerPolicy);
+  void SetReferrerPolicy(const nsAString& aPolicy, mozilla::ErrorResult& rv);
+  void GetReferrerPolicy(nsAString& aPolicy);
   nsDOMTokenList* RelList();
   void GetHreflang(nsAString& aHreflang);
   void SetHreflang(const nsAString& aHreflang, mozilla::ErrorResult& rv);
   void GetType(nsAString& aType);
   void SetType(const nsAString& aType, mozilla::ErrorResult& rv);
   void GetText(nsAString& aText, mozilla::ErrorResult& rv);
   void SetText(const nsAString& aText, mozilla::ErrorResult& rv);
 
--- a/dom/svg/SVGAnimatedClass.h
+++ b/dom/svg/SVGAnimatedClass.h
@@ -29,17 +29,17 @@ class SVGAnimatedClass {
 
   void Init() { mAnimVal = nullptr; }
 
   void SetBaseValue(const nsAString& aValue, SVGElement* aSVGElement,
                     bool aDoSetAttr);
   void GetBaseValue(nsAString& aValue, const SVGElement* aSVGElement) const;
 
   void SetAnimValue(const nsAString& aValue, SVGElement* aSVGElement);
-  void GetAnimValue(nsAString& aValue, const SVGElement* aSVGElement) const;
+  void GetAnimValue(nsAString& aResult, const SVGElement* aSVGElement) const;
   bool IsAnimated() const { return !!mAnimVal; }
 
   already_AddRefed<mozilla::dom::DOMSVGAnimatedString> ToDOMAnimatedString(
       SVGElement* aSVGElement);
 
   mozilla::UniquePtr<SMILAttr> ToSMILAttr(SVGElement* aSVGElement);
 
  private:
--- a/dom/svg/SVGAnimatedIntegerPair.h
+++ b/dom/svg/SVGAnimatedIntegerPair.h
@@ -36,17 +36,18 @@ class SVGAnimatedIntegerPair {
     mAttrEnum = aAttrEnum;
     mIsAnimated = false;
     mIsBaseSet = false;
   }
 
   nsresult SetBaseValueString(const nsAString& aValue, SVGElement* aSVGElement);
   void GetBaseValueString(nsAString& aValue) const;
 
-  void SetBaseValue(int32_t aValue, PairIndex aIndex, SVGElement* aSVGElement);
+  void SetBaseValue(int32_t aValue, PairIndex aPairIndex,
+                    SVGElement* aSVGElement);
   void SetBaseValues(int32_t aValue1, int32_t aValue2, SVGElement* aSVGElement);
   int32_t GetBaseValue(PairIndex aIndex) const {
     return mBaseVal[aIndex == eFirst ? 0 : 1];
   }
   void SetAnimValue(const int32_t aValue[2], SVGElement* aSVGElement);
   int32_t GetAnimValue(PairIndex aIndex) const {
     return mAnimVal[aIndex == eFirst ? 0 : 1];
   }
--- a/dom/svg/SVGAnimatedLength.cpp
+++ b/dom/svg/SVGAnimatedLength.cpp
@@ -281,32 +281,32 @@ nsresult SVGAnimatedLength::ConvertToSpe
   // Will/DidChangeAngle a second time (and dispatch duplicate notifications).
   SetBaseValueInSpecifiedUnits(valueInSpecifiedUnits, aSVGElement, false);
 
   aSVGElement->DidChangeLength(mAttrEnum, emptyOrOldValue);
 
   return NS_OK;
 }
 
-nsresult SVGAnimatedLength::NewValueSpecifiedUnits(uint16_t unitType,
-                                                   float valueInSpecifiedUnits,
+nsresult SVGAnimatedLength::NewValueSpecifiedUnits(uint16_t aUnitType,
+                                                   float aValueInSpecifiedUnits,
                                                    SVGElement* aSVGElement) {
-  NS_ENSURE_FINITE(valueInSpecifiedUnits, NS_ERROR_ILLEGAL_VALUE);
+  NS_ENSURE_FINITE(aValueInSpecifiedUnits, NS_ERROR_ILLEGAL_VALUE);
 
-  if (!IsValidUnitType(unitType)) return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
+  if (!IsValidUnitType(aUnitType)) return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
 
-  if (mIsBaseSet && mBaseVal == valueInSpecifiedUnits &&
-      mSpecifiedUnitType == uint8_t(unitType)) {
+  if (mIsBaseSet && mBaseVal == aValueInSpecifiedUnits &&
+      mSpecifiedUnitType == uint8_t(aUnitType)) {
     return NS_OK;
   }
 
   nsAttrValue emptyOrOldValue = aSVGElement->WillChangeLength(mAttrEnum);
-  mBaseVal = valueInSpecifiedUnits;
+  mBaseVal = aValueInSpecifiedUnits;
   mIsBaseSet = true;
-  mSpecifiedUnitType = uint8_t(unitType);
+  mSpecifiedUnitType = uint8_t(aUnitType);
   if (!mIsAnimated) {
     mAnimVal = mBaseVal;
   } else {
     aSVGElement->AnimationNeedsResample();
   }
   aSVGElement->DidChangeLength(mAttrEnum, emptyOrOldValue);
   return NS_OK;
 }
--- a/dom/svg/SVGAnimatedLength.h
+++ b/dom/svg/SVGAnimatedLength.h
@@ -182,17 +182,18 @@ class SVGAnimatedLength {
   // font-size is 0.
   // SetBaseValueInSpecifiedUnits and SetAnimValueInSpecifiedUnits do not
   // perform unit conversion and are therefore infallible.
   nsresult SetBaseValue(float aValue, SVGElement* aSVGElement, bool aDoSetAttr);
   void SetBaseValueInSpecifiedUnits(float aValue, SVGElement* aSVGElement,
                                     bool aDoSetAttr);
   nsresult SetAnimValue(float aValue, SVGElement* aSVGElement);
   void SetAnimValueInSpecifiedUnits(float aValue, SVGElement* aSVGElement);
-  nsresult NewValueSpecifiedUnits(uint16_t aUnitType, float aValue,
+  nsresult NewValueSpecifiedUnits(uint16_t aUnitType,
+                                  float aValueInSpecifiedUnits,
                                   SVGElement* aSVGElement);
   nsresult ConvertToSpecifiedUnits(uint16_t aUnitType, SVGElement* aSVGElement);
   already_AddRefed<DOMSVGLength> ToDOMBaseVal(SVGElement* aSVGElement);
   already_AddRefed<DOMSVGLength> ToDOMAnimVal(SVGElement* aSVGElement);
 
  public:
   struct SMILLength : public SMILAttr {
    public:
--- a/dom/svg/SVGAnimatedLengthList.h
+++ b/dom/svg/SVGAnimatedLengthList.h
@@ -56,18 +56,18 @@ class SVGAnimatedLengthList {
   nsresult SetBaseValueString(const nsAString& aValue);
 
   void ClearBaseValue(uint32_t aAttrEnum);
 
   const SVGLengthList& GetAnimValue() const {
     return mAnimVal ? *mAnimVal : mBaseVal;
   }
 
-  nsresult SetAnimValue(const SVGLengthList& aValue, dom::SVGElement* aElement,
-                        uint32_t aAttrEnum);
+  nsresult SetAnimValue(const SVGLengthList& aNewAnimValue,
+                        dom::SVGElement* aElement, uint32_t aAttrEnum);
 
   void ClearAnimValue(dom::SVGElement* aElement, uint32_t aAttrEnum);
 
   bool IsAnimating() const { return !!mAnimVal; }
 
   UniquePtr<SMILAttr> ToSMILAttr(dom::SVGElement* aSVGElement,
                                  uint8_t aAttrEnum, uint8_t aAxis,
                                  bool aCanZeroPadList);
--- a/dom/svg/SVGAnimatedNumberList.h
+++ b/dom/svg/SVGAnimatedNumberList.h
@@ -56,18 +56,18 @@ class SVGAnimatedNumberList {
   nsresult SetBaseValueString(const nsAString& aValue);
 
   void ClearBaseValue(uint32_t aAttrEnum);
 
   const SVGNumberList& GetAnimValue() const {
     return mAnimVal ? *mAnimVal : mBaseVal;
   }
 
-  nsresult SetAnimValue(const SVGNumberList& aValue, dom::SVGElement* aElement,
-                        uint32_t aAttrEnum);
+  nsresult SetAnimValue(const SVGNumberList& aNewAnimValue,
+                        dom::SVGElement* aElement, uint32_t aAttrEnum);
 
   void ClearAnimValue(dom::SVGElement* aElement, uint32_t aAttrEnum);
 
   // Returns true if the animated value of this list has been explicitly
   // set (either by animation, or by taking on the base value which has been
   // explicitly set by markup or a DOM call), false otherwise.
   // If this returns false, the animated value is still valid, that is,
   // usable, and represents the default base value of the attribute.
--- a/dom/svg/SVGAnimatedNumberPair.h
+++ b/dom/svg/SVGAnimatedNumberPair.h
@@ -37,17 +37,18 @@ class SVGAnimatedNumberPair {
     mAttrEnum = aAttrEnum;
     mIsAnimated = false;
     mIsBaseSet = false;
   }
 
   nsresult SetBaseValueString(const nsAString& aValue, SVGElement* aSVGElement);
   void GetBaseValueString(nsAString& aValue) const;
 
-  void SetBaseValue(float aValue, PairIndex aIndex, SVGElement* aSVGElement);
+  void SetBaseValue(float aValue, PairIndex aPairIndex,
+                    SVGElement* aSVGElement);
   void SetBaseValues(float aValue1, float aValue2, SVGElement* aSVGElement);
   float GetBaseValue(PairIndex aIndex) const {
     return mBaseVal[aIndex == eFirst ? 0 : 1];
   }
   void SetAnimValue(const float aValue[2], SVGElement* aSVGElement);
   float GetAnimValue(PairIndex aIndex) const {
     return mAnimVal[aIndex == eFirst ? 0 : 1];
   }
--- a/dom/svg/SVGAnimatedOrient.cpp
+++ b/dom/svg/SVGAnimatedOrient.cpp
@@ -179,31 +179,32 @@ nsresult SVGAnimatedOrient::ConvertToSpe
   }
 
   float valueInUserUnits = mBaseVal * GetDegreesPerUnit(mBaseValUnit);
   SetBaseValue(valueInUserUnits, unitType, aSVGElement, true);
 
   return NS_OK;
 }
 
-nsresult SVGAnimatedOrient::NewValueSpecifiedUnits(uint16_t unitType,
-                                                   float valueInSpecifiedUnits,
+nsresult SVGAnimatedOrient::NewValueSpecifiedUnits(uint16_t aUnitType,
+                                                   float aValueInSpecifiedUnits,
                                                    SVGElement* aSVGElement) {
-  NS_ENSURE_FINITE(valueInSpecifiedUnits, NS_ERROR_ILLEGAL_VALUE);
+  NS_ENSURE_FINITE(aValueInSpecifiedUnits, NS_ERROR_ILLEGAL_VALUE);
 
-  if (!IsValidAngleUnitType(unitType)) return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
+  if (!IsValidAngleUnitType(aUnitType)) return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
 
-  if (mBaseVal == valueInSpecifiedUnits && mBaseValUnit == uint8_t(unitType) &&
+  if (mBaseVal == aValueInSpecifiedUnits &&
+      mBaseValUnit == uint8_t(aUnitType) &&
       mBaseType == SVG_MARKER_ORIENT_ANGLE)
     return NS_OK;
 
   AutoChangeOrientNotifier notifier(this, aSVGElement);
 
-  mBaseVal = valueInSpecifiedUnits;
-  mBaseValUnit = uint8_t(unitType);
+  mBaseVal = aValueInSpecifiedUnits;
+  mBaseValUnit = uint8_t(aUnitType);
   mBaseType = SVG_MARKER_ORIENT_ANGLE;
   if (!mIsAnimated) {
     mAnimVal = mBaseVal;
     mAnimValUnit = mBaseValUnit;
     mAnimType = mBaseType;
   }
   return NS_OK;
 }
--- a/dom/svg/SVGAnimatedOrient.h
+++ b/dom/svg/SVGAnimatedOrient.h
@@ -59,17 +59,17 @@ class SVGAnimatedOrient {
     return mAnimVal * GetDegreesPerUnit(mAnimValUnit);
   }
   SVGEnumValue GetAnimType() const { return mAnimType; }
 
   void SetBaseValue(float aValue, uint8_t aUnit, SVGElement* aSVGElement,
                     bool aDoSetAttr);
   nsresult SetBaseType(SVGEnumValue aValue, SVGElement* aSVGElement);
   void SetAnimValue(float aValue, uint8_t aUnit, SVGElement* aSVGElement);
-  void SetAnimType(SVGEnumValue aType, SVGElement* aSVGElement);
+  void SetAnimType(SVGEnumValue aValue, SVGElement* aSVGElement);
 
   uint8_t GetBaseValueUnit() const { return mBaseValUnit; }
   uint8_t GetAnimValueUnit() const { return mAnimValUnit; }
   float GetBaseValInSpecifiedUnits() const { return mBaseVal; }
   float GetAnimValInSpecifiedUnits() const { return mAnimVal; }
 
   static nsresult ToDOMSVGAngle(nsISupports** aResult);
   already_AddRefed<dom::DOMSVGAnimatedAngle> ToDOMAnimatedAngle(
@@ -87,17 +87,18 @@ class SVGAnimatedOrient {
   float mBaseVal;
   uint8_t mAnimType;
   uint8_t mBaseType;
   uint8_t mAnimValUnit;
   uint8_t mBaseValUnit;
   bool mIsAnimated;
 
   void SetBaseValueInSpecifiedUnits(float aValue, SVGElement* aSVGElement);
-  nsresult NewValueSpecifiedUnits(uint16_t aUnitType, float aValue,
+  nsresult NewValueSpecifiedUnits(uint16_t aUnitType,
+                                  float aValueInSpecifiedUnits,
                                   SVGElement* aSVGElement);
   nsresult ConvertToSpecifiedUnits(uint16_t aUnitType, SVGElement* aSVGElement);
   already_AddRefed<dom::DOMSVGAngle> ToDOMBaseVal(SVGElement* aSVGElement);
   already_AddRefed<dom::DOMSVGAngle> ToDOMAnimVal(SVGElement* aSVGElement);
 
  public:
   // DOM wrapper class for the (DOM)SVGAnimatedEnumeration interface where the
   // wrapped class is SVGAnimatedOrient.
--- a/dom/svg/SVGAnimatedPathSegList.h
+++ b/dom/svg/SVGAnimatedPathSegList.h
@@ -60,17 +60,18 @@ class SVGAnimatedPathSegList final {
 
   /**
    * const! See comment for GetBaseValue!
    */
   const SVGPathData& GetAnimValue() const {
     return mAnimVal ? *mAnimVal : mBaseVal;
   }
 
-  nsresult SetAnimValue(const SVGPathData& aValue, dom::SVGElement* aElement);
+  nsresult SetAnimValue(const SVGPathData& aNewAnimValue,
+                        dom::SVGElement* aElement);
 
   void ClearAnimValue(dom::SVGElement* aElement);
 
   /**
    * Empty paths are not rendered.
    */
   bool IsRendered() const;
 
--- a/dom/svg/SVGAnimatedPointList.h
+++ b/dom/svg/SVGAnimatedPointList.h
@@ -59,17 +59,18 @@ class SVGAnimatedPointList {
 
   /**
    * const! See comment for GetBaseValue!
    */
   const SVGPointList& GetAnimValue() const {
     return mAnimVal ? *mAnimVal : mBaseVal;
   }
 
-  nsresult SetAnimValue(const SVGPointList& aValue, dom::SVGElement* aElement);
+  nsresult SetAnimValue(const SVGPointList& aNewAnimValue,
+                        dom::SVGElement* aElement);
 
   void ClearAnimValue(dom::SVGElement* aElement);
 
   /**
    * Needed for correct DOM wrapper construction since GetAnimValue may
    * actually return the baseVal!
    */
   void* GetBaseValKey() const { return (void*)&mBaseVal; }
--- a/dom/svg/SVGAnimatedString.h
+++ b/dom/svg/SVGAnimatedString.h
@@ -33,17 +33,17 @@ class SVGAnimatedString {
 
   void SetBaseValue(const nsAString& aValue, SVGElement* aSVGElement,
                     bool aDoSetAttr);
   void GetBaseValue(nsAString& aValue, const SVGElement* aSVGElement) const {
     aSVGElement->GetStringBaseValue(mAttrEnum, aValue);
   }
 
   void SetAnimValue(const nsAString& aValue, SVGElement* aSVGElement);
-  void GetAnimValue(nsAString& aValue, const SVGElement* aSVGElement) const;
+  void GetAnimValue(nsAString& aResult, const SVGElement* aSVGElement) const;
 
   // Returns true if the animated value of this string has been explicitly
   // set (either by animation, or by taking on the base value which has been
   // explicitly set by markup or a DOM call), false otherwise.
   // If this returns false, the animated value is still valid, that is,
   // usable, and represents the default base value of the attribute.
   bool IsExplicitlySet() const { return !!mAnimVal || mIsBaseSet; }
 
--- a/dom/svg/SVGAnimatedTransformList.h
+++ b/dom/svg/SVGAnimatedTransformList.h
@@ -64,17 +64,17 @@ class SVGAnimatedTransformList {
                               dom::SVGElement* aSVGElement);
 
   void ClearBaseValue();
 
   const SVGTransformList& GetAnimValue() const {
     return mAnimVal ? *mAnimVal : mBaseVal;
   }
 
-  nsresult SetAnimValue(const SVGTransformList& aNewAnimValue,
+  nsresult SetAnimValue(const SVGTransformList& aValue,
                         dom::SVGElement* aElement);
 
   void ClearAnimValue(dom::SVGElement* aElement);
 
   /**
    * Returns true if the corresponding transform attribute is set (or animated)
    * to a valid value. Unlike HasTransform it will return true for an empty
    * transform.
@@ -129,17 +129,17 @@ class SVGAnimatedTransformList {
         : mVal(aVal), mElement(aSVGElement) {}
 
     // SMILAttr methods
     virtual nsresult ValueFromString(
         const nsAString& aStr, const dom::SVGAnimationElement* aSrcElement,
         SMILValue& aValue, bool& aPreventCachingOfSandwich) const override;
     virtual SMILValue GetBaseValue() const override;
     virtual void ClearAnimValue() override;
-    virtual nsresult SetAnimValue(const SMILValue& aValue) override;
+    virtual nsresult SetAnimValue(const SMILValue& aNewAnimValue) override;
 
    protected:
     static void ParseValue(const nsAString& aSpec, const nsAtom* aTransformType,
                            SMILValue& aResult);
     static int32_t ParseParameterList(const nsAString& aSpec, float* aVars,
                                       int32_t aNVars);
 
     // These will stay alive because a SMILAttr only lives as long
--- a/dom/svg/SVGElement.h
+++ b/dom/svg/SVGElement.h
@@ -573,18 +573,17 @@ class SVGElement : public SVGElementBase
   virtual NumberListAttributesInfo GetNumberListInfo();
   virtual LengthListAttributesInfo GetLengthListInfo();
   virtual StringAttributesInfo GetStringInfo();
   virtual StringListAttributesInfo GetStringListInfo();
 
   static SVGEnumMapping sSVGUnitTypesMap[];
 
  private:
-  void UnsetAttrInternal(int32_t aNameSpaceID, nsAtom* aAttribute,
-                         bool aNotify);
+  void UnsetAttrInternal(int32_t aNameSpaceID, nsAtom* aName, bool aNotify);
 
   SVGAnimatedClass mClassAttribute;
   nsAutoPtr<nsAttrValue> mClassAnimAttr;
   RefPtr<mozilla::DeclarationBlock> mContentDeclarationBlock;
 };
 
 /**
  * A macro to implement the NS_NewSVGXXXElement() functions.
--- a/dom/svg/SVGLength.h
+++ b/dom/svg/SVGLength.h
@@ -48,17 +48,17 @@ class SVGLength {
   }
 
   void GetValueAsString(nsAString &aValue) const;
 
   /**
    * This method returns true, unless there was a parse failure, in which
    * case it returns false (and the length is left unchanged).
    */
-  bool SetValueFromString(const nsAString &aValue);
+  bool SetValueFromString(const nsAString &aString);
 
   /**
    * This will usually return a valid, finite number. There is one exception
    * though - see the comment in SetValueAndUnit().
    */
   float GetValueInCurrentUnits() const { return mValue; }
 
   uint8_t GetUnit() const { return mUnit; }
--- a/dom/svg/SVGMotionSMILAnimationFunction.h
+++ b/dom/svg/SVGMotionSMILAnimationFunction.h
@@ -71,17 +71,17 @@ class SVGMotionSMILAnimationFunction fin
   void CheckKeyPoints();
   nsresult SetKeyPoints(const nsAString& aKeyPoints, nsAttrValue& aResult);
   void UnsetKeyPoints();
   nsresult SetRotate(const nsAString& aRotate, nsAttrValue& aResult);
   void UnsetRotate();
 
   // Helpers for GetValues
   void MarkStaleIfAttributeAffectsPath(nsAtom* aAttribute);
-  void RebuildPathAndVertices(const nsIContent* aContextElem);
+  void RebuildPathAndVertices(const nsIContent* aTargetElement);
   void RebuildPathAndVerticesFromMpathElem(dom::SVGMPathElement* aMpathElem);
   void RebuildPathAndVerticesFromPathAttr();
   void RebuildPathAndVerticesFromBasicAttrs(const nsIContent* aContextElem);
   bool GenerateValuesForPathAndPoints(Path* aPath, bool aIsKeyPoints,
                                       FallibleTArray<double>& aPointDistances,
                                       SMILValueArray& aResult);
 
   // Members
--- a/dom/svg/SVGMotionSMILPathUtils.h
+++ b/dom/svg/SVGMotionSMILPathUtils.h
@@ -61,17 +61,18 @@ class SVGMotionSMILPathUtils {
 
     // Accessor to let clients check if we've received any commands yet.
     inline bool HaveReceivedCommands() { return mHaveReceivedCommands; }
     // Accessor to get the finalized path
     already_AddRefed<Path> GetResultingPath();
 
    protected:
     // Helper methods
-    bool ParseCoordinatePair(const nsAString& aStr, float& aXVal, float& aYVal);
+    bool ParseCoordinatePair(const nsAString& aCoordPairStr, float& aXVal,
+                             float& aYVal);
 
     // Member data
     const dom::SVGElement* mSVGElement;  // context for converting to user units
     RefPtr<PathBuilder> mPathBuilder;
     bool mHaveReceivedCommands;
   };
 
   // Class to assist in passing each subcomponent of a |values| attribute to
--- a/dom/svg/SVGPathData.h
+++ b/dom/svg/SVGPathData.h
@@ -130,48 +130,49 @@ class SVGPathData {
   bool SetCapacity(uint32_t aSize) {
     return mData.SetCapacity(aSize, fallible);
   }
 
   void Compact() { mData.Compact(); }
 
   float GetPathLength() const;
 
-  uint32_t GetPathSegAtLength(float aLength) const;
+  uint32_t GetPathSegAtLength(float aDistance) const;
 
   void GetMarkerPositioningData(nsTArray<SVGMark>* aMarks) const;
 
   /**
    * Returns true, except on OOM, in which case returns false.
    */
   bool GetSegmentLengths(nsTArray<double>* aLengths) const;
 
   /**
    * Returns true, except on OOM, in which case returns false.
    */
   bool GetDistancesFromOriginToEndsOfVisibleSegments(
-      FallibleTArray<double>* aArray) const;
+      FallibleTArray<double>* aOutput) const;
 
   /**
    * This returns a path without the extra little line segments that
    * ApproximateZeroLengthSubpathSquareCaps can insert if we have square-caps.
    * See the comment for that function for more info on that.
    */
   already_AddRefed<Path> BuildPathForMeasuring() const;
 
-  already_AddRefed<Path> BuildPath(PathBuilder* aBuilder, uint8_t aCapStyle,
+  already_AddRefed<Path> BuildPath(PathBuilder* aBuilder,
+                                   uint8_t aStrokeLineCap,
                                    Float aStrokeWidth) const;
   /**
    * This function tries to build the path by an array of StylePathCommand,
    * which is generated by cbindgen from Rust (see ServoStyleConsts.h).
    * Basically, this is a variant of the above BuildPath() functions.
    */
   static already_AddRefed<Path> BuildPath(
       const nsTArray<StylePathCommand>& aPath, PathBuilder* aBuilder,
-      uint8_t aCapStyle, Float aStrokeWidth, float aZoomFactor = 1.0);
+      uint8_t aStrokeLineCap, Float aStrokeWidth, float aZoomFactor = 1.0);
 
   const_iterator begin() const { return mData.Elements(); }
   const_iterator end() const { return mData.Elements() + mData.Length(); }
 
   // memory reporting methods
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
--- a/dom/svg/SVGViewportElement.h
+++ b/dom/svg/SVGViewportElement.h
@@ -59,17 +59,17 @@ class SVGViewportElement : public SVGGra
   virtual gfxMatrix PrependLocalTransformsTo(
       const gfxMatrix& aMatrix,
       SVGTransformTypes aWhich = eAllTransforms) const override;
 
   virtual bool HasValidDimensions() const override;
 
   // SVGViewportElement methods:
 
-  float GetLength(uint8_t mCtxType);
+  float GetLength(uint8_t aCtxType);
 
   // public helpers:
 
   /**
    * Returns true if this element has a base/anim value for its "viewBox"
    * attribute that defines a viewBox rectangle with finite values, or
    * if there is a view element overriding this element's viewBox and it
    * has a valid viewBox.
--- a/layout/svg/SVGGeometryFrame.cpp
+++ b/layout/svg/SVGGeometryFrame.cpp
@@ -628,19 +628,19 @@ gfxMatrix SVGGeometryFrame::GetCanvasTM(
 
   nsSVGContainerFrame* parent = static_cast<nsSVGContainerFrame*>(GetParent());
   SVGGraphicsElement* content = static_cast<SVGGraphicsElement*>(GetContent());
 
   return content->PrependLocalTransformsTo(parent->GetCanvasTM());
 }
 
 void SVGGeometryFrame::Render(gfxContext* aContext, uint32_t aRenderComponents,
-                              const gfxMatrix& aNewTransform,
+                              const gfxMatrix& aTransform,
                               imgDrawingParams& aImgParams) {
-  MOZ_ASSERT(!aNewTransform.IsSingular());
+  MOZ_ASSERT(!aTransform.IsSingular());
 
   DrawTarget* drawTarget = aContext->GetDrawTarget();
 
   FillRule fillRule = nsSVGUtils::ToFillRule(
       (GetStateBits() & NS_STATE_SVG_CLIPPATH_CHILD) ? StyleSVG()->mClipRule
                                                      : StyleSVG()->mFillRule);
 
   SVGGeometryElement* element = static_cast<SVGGeometryElement*>(GetContent());
@@ -650,17 +650,17 @@ void SVGGeometryFrame::Render(gfxContext
        StyleSVG()->mShapeRendering == NS_STYLE_SHAPE_RENDERING_CRISPEDGES)
           ? AntialiasMode::NONE
           : AntialiasMode::SUBPIXEL;
 
   // We wait as late as possible before setting the transform so that we don't
   // set it unnecessarily if we return early (it's an expensive operation for
   // some backends).
   gfxContextMatrixAutoSaveRestore autoRestoreTransform(aContext);
-  aContext->SetMatrixDouble(aNewTransform);
+  aContext->SetMatrixDouble(aTransform);
 
   if (GetStateBits() & NS_STATE_SVG_CLIPPATH_CHILD) {
     // We don't complicate this code with GetAsSimplePath since the cost of
     // masking will dwarf Path creation overhead anyway.
     RefPtr<Path> path = element->GetOrBuildPath(drawTarget, fillRule);
     if (path) {
       ColorPattern white(ToDeviceColor(Color(1.0f, 1.0f, 1.0f, 1.0f)));
       drawTarget->Fill(path, white,
--- a/layout/svg/SVGGeometryFrame.h
+++ b/layout/svg/SVGGeometryFrame.h
@@ -118,14 +118,14 @@ class SVGGeometryFrame : public nsFrame,
   enum { eRenderFill = 1, eRenderStroke = 2 };
   void Render(gfxContext* aContext, uint32_t aRenderComponents,
               const gfxMatrix& aTransform, imgDrawingParams& aImgParams);
 
   /**
    * @param aMatrix The transform that must be multiplied onto aContext to
    *   establish this frame's SVG user space.
    */
-  void PaintMarkers(gfxContext& aContext, const gfxMatrix& aMatrix,
+  void PaintMarkers(gfxContext& aContext, const gfxMatrix& aTransform,
                     imgDrawingParams& aImgParams);
 };
 }  // namespace mozilla
 
 #endif  // __SVGGEOMETRYFRAME_H__
--- a/layout/svg/SVGObserverUtils.cpp
+++ b/layout/svg/SVGObserverUtils.cpp
@@ -568,17 +568,17 @@ nsSVGFilterFrame* SVGFilterObserver::Get
  * filters like "blur(10px)" don't reference filter elements, so they don't
  * need an SVGFilterObserver.  The style system invalidates changes to CSS
  * filters.
  */
 class SVGFilterObserverList : public nsISupports {
  public:
   SVGFilterObserverList(const nsTArray<nsStyleFilter>& aFilters,
                         nsIContent* aFilteredElement,
-                        nsIFrame* aFiltedFrame = nullptr);
+                        nsIFrame* aFilteredFrame = nullptr);
 
   bool ReferencesValidResources();
   void Invalidate() { OnRenderingChange(); }
 
   const nsTArray<RefPtr<SVGFilterObserver>>& GetObservers() const {
     return mObservers;
   }
 
--- a/layout/svg/SVGObserverUtils.h
+++ b/layout/svg/SVGObserverUtils.h
@@ -246,17 +246,17 @@ class SVGObserverUtils {
                                                  uint32_t aFlags = 0);
   static void InvalidateDirectRenderingObservers(nsIFrame* aFrame,
                                                  uint32_t aFlags = 0);
 
   /**
    * Get the paint server for aPaintedFrame.
    */
   static nsSVGPaintServerFrame* GetAndObservePaintServer(
-      nsIFrame* aPaintedFrame, nsStyleSVGPaint nsStyleSVG::*aPaint);
+      nsIFrame* aTargetFrame, nsStyleSVGPaint nsStyleSVG::*aPaint);
 
   /**
    * Get the start/mid/end-markers for the given frame, and add the frame as
    * an observer to those markers.  Returns true if at least one marker type is
    * found, false otherwise.
    */
   static bool GetAndObserveMarkers(nsIFrame* aMarkedFrame,
                                    nsSVGMarkerFrame* (*aFrames)[3]);
--- a/layout/svg/nsFilterInstance.h
+++ b/layout/svg/nsFilterInstance.h
@@ -141,30 +141,30 @@ class nsFilterInstance {
    * @param aPaintTransform The transform to apply to convert to
    *   aTargetFrame's SVG user space. Only used when painting.
    * @param aPostFilterDirtyRegion [optional] The post-filter area
    *   that has to be repainted, in app units. Only required if you will
    *   call ComputeSourceNeededRect() or Render().
    * @param aPreFilterDirtyRegion [optional] The pre-filter area of
    *   the filtered element that changed, in app units. Only required if you
    *   will call ComputePostFilterDirtyRegion().
-   * @param aOverridePreFilterVisualOverflowRect [optional] Use a different
+   * @param aPreFilterVisualOverflowRectOverride [optional] Use a different
    *   visual overflow rect for the target element.
    * @param aOverrideBBox [optional] Use a different SVG bbox for the target
    *   element. Must be non-null if aTargetFrame is null.
    */
   nsFilterInstance(nsIFrame* aTargetFrame, nsIContent* aTargetContent,
                    const UserSpaceMetrics& aMetrics,
                    const nsTArray<nsStyleFilter>& aFilterChain,
                    bool aFilterInputIsTainted,
                    nsSVGFilterPaintCallback* aPaintCallback,
                    const gfxMatrix& aPaintTransform,
                    const nsRegion* aPostFilterDirtyRegion = nullptr,
                    const nsRegion* aPreFilterDirtyRegion = nullptr,
-                   const nsRect* aOverridePreFilterVisualOverflowRect = nullptr,
+                   const nsRect* aPreFilterVisualOverflowRectOverride = nullptr,
                    const gfxRect* aOverrideBBox = nullptr);
 
   /**
    * Returns true if the filter instance was created successfully.
    */
   bool IsInitialized() const { return mInitialized; }
 
   /**
@@ -222,17 +222,17 @@ class nsFilterInstance {
     // Set by BuildSourceImage / BuildSourcePaint.
     IntRect mSurfaceRect;
   };
 
   /**
    * Creates a SourceSurface for either the FillPaint or StrokePaint graph
    * nodes
    */
-  void BuildSourcePaint(SourceInfo* aPrimitive, imgDrawingParams& aImgParams);
+  void BuildSourcePaint(SourceInfo* aSource, imgDrawingParams& aImgParams);
 
   /**
    * Creates a SourceSurface for either the FillPaint and StrokePaint graph
    * nodes, fills its contents and assigns it to mFillPaint.mSourceSurface and
    * mStrokePaint.mSourceSurface respectively.
    */
   void BuildSourcePaints(imgDrawingParams& aImgParams);
 
--- a/layout/svg/nsSVGGradientFrame.h
+++ b/layout/svg/nsSVGGradientFrame.h
@@ -38,17 +38,17 @@ class nsSVGGradientFrame : public nsSVGP
 
  public:
   NS_DECL_ABSTRACT_FRAME(nsSVGGradientFrame)
 
   // nsSVGPaintServerFrame methods:
   virtual already_AddRefed<gfxPattern> GetPaintServerPattern(
       nsIFrame* aSource, const DrawTarget* aDrawTarget,
       const gfxMatrix& aContextMatrix,
-      nsStyleSVGPaint nsStyleSVG::*aFillOrStroke, float aOpacity,
+      nsStyleSVGPaint nsStyleSVG::*aFillOrStroke, float aGraphicOpacity,
       imgDrawingParams& aImgParams, const gfxRect* aOverrideBounds) override;
 
   // nsIFrame interface:
   virtual nsresult AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
                                     int32_t aModType) override;
 
 #ifdef DEBUG_FRAME_DUMP
   virtual nsresult GetFrameName(nsAString& aResult) const override {
--- a/layout/svg/nsSVGIntegrationUtils.h
+++ b/layout/svg/nsSVGIntegrationUtils.h
@@ -136,17 +136,17 @@ class nsSVGIntegrationUtils final {
       nsIFrame* aFrame, const nsPoint& aToReferenceFrame,
       const nsIntRegion& aInvalidRegion);
 
   /**
    * Figure out which area of the source is needed given an area to
    * repaint
    */
   static nsRect GetRequiredSourceForInvalidArea(nsIFrame* aFrame,
-                                                const nsRect& aDamageRect);
+                                                const nsRect& aDirtyRect);
 
   /**
    * Returns true if the given point is not clipped out by effects.
    * @param aPt in appunits relative to aFrame
    */
   static bool HitTestFrameForEffects(nsIFrame* aFrame, const nsPoint& aPt);
 
   struct MOZ_STACK_CLASS PaintFramesParams {
--- a/layout/svg/nsSVGOuterSVGFrame.cpp
+++ b/layout/svg/nsSVGOuterSVGFrame.cpp
@@ -289,80 +289,82 @@ nsSize nsSVGOuterSVGFrame::GetIntrinsicR
                   nsPresContext::CSSPixelsToAppUnits(viewBoxHeight));
   }
 
   return nsSVGDisplayContainerFrame::GetIntrinsicRatio();
 }
 
 /* virtual */
 LogicalSize nsSVGOuterSVGFrame::ComputeSize(
-    gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
-    nscoord aAvailableISize, const LogicalSize& aMargin,
-    const LogicalSize& aBorder, const LogicalSize& aPadding,
-    ComputeSizeFlags aFlags) {
+    gfxContext* aRenderingContext, WritingMode aWritingMode,
+    const LogicalSize& aCBSize, nscoord aAvailableISize,
+    const LogicalSize& aMargin, const LogicalSize& aBorder,
+    const LogicalSize& aPadding, ComputeSizeFlags aFlags) {
   if (IsRootOfImage() || IsRootOfReplacedElementSubDoc()) {
     // The embedding element has sized itself using the CSS replaced element
     // sizing rules, using our intrinsic dimensions as necessary. The SVG spec
     // says that the width and height of embedded SVG is overridden by the
     // width and height of the embedding element, so we just need to size to
     // the viewport that the embedding element has established for us.
     return aCBSize;
   }
 
   LogicalSize cbSize = aCBSize;
   IntrinsicSize intrinsicSize = GetIntrinsicSize();
 
   if (!mContent->GetParent()) {
     // We're the root of the outermost browsing context, so we need to scale
     // cbSize by the full-zoom so that SVGs with percentage width/height zoom:
 
-    NS_ASSERTION(aCBSize.ISize(aWM) != NS_AUTOHEIGHT &&
-                     aCBSize.BSize(aWM) != NS_AUTOHEIGHT,
+    NS_ASSERTION(aCBSize.ISize(aWritingMode) != NS_AUTOHEIGHT &&
+                     aCBSize.BSize(aWritingMode) != NS_AUTOHEIGHT,
                  "root should not have auto-width/height containing block");
 
     if (!IsContainingWindowElementOfType(nullptr, nsGkAtoms::iframe)) {
-      cbSize.ISize(aWM) *= PresContext()->GetFullZoom();
-      cbSize.BSize(aWM) *= PresContext()->GetFullZoom();
+      cbSize.ISize(aWritingMode) *= PresContext()->GetFullZoom();
+      cbSize.BSize(aWritingMode) *= PresContext()->GetFullZoom();
     }
 
     // We also need to honour the width and height attributes' default values
     // of 100% when we're the root of a browsing context.  (GetIntrinsicSize()
     // doesn't report these since there's no such thing as a percentage
     // intrinsic size.  Also note that explicit percentage values are mapped
     // into style, so the following isn't for them.)
 
     SVGSVGElement* content = static_cast<SVGSVGElement*>(GetContent());
 
     const SVGAnimatedLength& width =
         content->mLengthAttributes[SVGSVGElement::ATTR_WIDTH];
     if (width.IsPercentage()) {
       MOZ_ASSERT(!intrinsicSize.width,
                  "GetIntrinsicSize should have reported no intrinsic width");
       float val = width.GetAnimValInSpecifiedUnits() / 100.0f;
-      intrinsicSize.width.emplace(std::max(val, 0.0f) * cbSize.Width(aWM));
+      intrinsicSize.width.emplace(std::max(val, 0.0f) *
+                                  cbSize.Width(aWritingMode));
     }
 
     const SVGAnimatedLength& height =
         content->mLengthAttributes[SVGSVGElement::ATTR_HEIGHT];
-    NS_ASSERTION(aCBSize.BSize(aWM) != NS_AUTOHEIGHT,
+    NS_ASSERTION(aCBSize.BSize(aWritingMode) != NS_AUTOHEIGHT,
                  "root should not have auto-height containing block");
     if (height.IsPercentage()) {
       MOZ_ASSERT(!intrinsicSize.height,
                  "GetIntrinsicSize should have reported no intrinsic height");
       float val = height.GetAnimValInSpecifiedUnits() / 100.0f;
-      intrinsicSize.height.emplace(std::max(val, 0.0f) * cbSize.Height(aWM));
+      intrinsicSize.height.emplace(std::max(val, 0.0f) *
+                                   cbSize.Height(aWritingMode));
     }
     MOZ_ASSERT(intrinsicSize.height && intrinsicSize.width,
                "We should have just handled the only situation where"
                "we lack an intrinsic height or width.");
   }
 
   return ComputeSizeWithIntrinsicDimensions(
-      aRenderingContext, aWM, intrinsicSize, GetIntrinsicRatio(), cbSize,
-      aMargin, aBorder, aPadding, aFlags);
+      aRenderingContext, aWritingMode, intrinsicSize, GetIntrinsicRatio(),
+      cbSize, aMargin, aBorder, aPadding, aFlags);
 }
 
 void nsSVGOuterSVGFrame::Reflow(nsPresContext* aPresContext,
                                 ReflowOutput& aDesiredSize,
                                 const ReflowInput& aReflowInput,
                                 nsReflowStatus& aStatus) {
   MarkInReflow();
   DO_GLOBAL_REFLOW_COUNT("nsSVGOuterSVGFrame");
@@ -551,17 +553,18 @@ class nsDisplayOuterSVG final : public n
   }
 #ifdef NS_BUILD_REFCNT_LOGGING
   virtual ~nsDisplayOuterSVG() { MOZ_COUNT_DTOR(nsDisplayOuterSVG); }
 #endif
 
   virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
                        HitTestState* aState,
                        nsTArray<nsIFrame*>* aOutFrames) override;
-  virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
+  virtual void Paint(nsDisplayListBuilder* aBuilder,
+                     gfxContext* aContext) override;
 
   virtual void ComputeInvalidationRegion(
       nsDisplayListBuilder* aBuilder, const nsDisplayItemGeometry* aGeometry,
       nsRegion* aInvalidRegion) const override;
 
   nsDisplayItemGeometry* AllocateGeometry(
       nsDisplayListBuilder* aBuilder) override {
     return new nsDisplayItemGenericImageGeometry(this, aBuilder);
--- a/layout/svg/nsSVGPatternFrame.h
+++ b/layout/svg/nsSVGPatternFrame.h
@@ -36,17 +36,17 @@ class nsSVGPatternFrame final : public n
 
   explicit nsSVGPatternFrame(ComputedStyle* aStyle,
                              nsPresContext* aPresContext);
 
   // nsSVGPaintServerFrame methods:
   virtual already_AddRefed<gfxPattern> GetPaintServerPattern(
       nsIFrame* aSource, const DrawTarget* aDrawTarget,
       const gfxMatrix& aContextMatrix,
-      nsStyleSVGPaint nsStyleSVG::*aFillOrStroke, float aOpacity,
+      nsStyleSVGPaint nsStyleSVG::*aFillOrStroke, float aGraphicOpacity,
       imgDrawingParams& aImgParams, const gfxRect* aOverrideBounds) override;
 
  public:
   typedef mozilla::SVGAnimatedPreserveAspectRatio
       SVGAnimatedPreserveAspectRatio;
 
   // nsSVGContainerFrame methods:
   virtual gfxMatrix GetCanvasTM() override;
@@ -106,17 +106,17 @@ class nsSVGPatternFrame final : public n
    * will "inherit" the children of the referenced pattern (which may itself be
    * inheriting its children if it references another <pattern>).  This
    * function returns this nsSVGPatternFrame or the first pattern along the
    * reference chain (if there is one) to have children.
    */
   nsSVGPatternFrame* GetPatternWithChildren();
 
   gfxRect GetPatternRect(uint16_t aPatternUnits, const gfxRect& bbox,
-                         const Matrix& callerCTM, nsIFrame* aTarget);
+                         const Matrix& aTargetCTM, nsIFrame* aTarget);
   gfxMatrix ConstructCTM(const SVGAnimatedViewBox& aViewBox,
                          uint16_t aPatternContentUnits, uint16_t aPatternUnits,
                          const gfxRect& callerBBox, const Matrix& callerCTM,
                          nsIFrame* aTarget);
 
  private:
   // this is a *temporary* reference to the frame of the element currently
   // referencing our pattern.  This must be temporary because different
--- a/layout/svg/nsSVGSwitchFrame.cpp
+++ b/layout/svg/nsSVGSwitchFrame.cpp
@@ -40,17 +40,17 @@ class nsSVGSwitchFrame final : public ns
   }
 #endif
 
   virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
                                 const nsDisplayListSet& aLists) override;
 
   // nsSVGDisplayableFrame interface:
   virtual void PaintSVG(gfxContext& aContext, const gfxMatrix& aTransform,
-                        imgDrawingParams& aPackage,
+                        imgDrawingParams& aImgParams,
                         const nsIntRect* aDirtyRect = nullptr) override;
   nsIFrame* GetFrameForPoint(const gfxPoint& aPoint) override;
   virtual void ReflowSVG() override;
   virtual SVGBBox GetBBoxContribution(const Matrix& aToBBoxUserspace,
                                       uint32_t aFlags) override;
 
  private:
   nsIFrame* GetActiveChildFrame();
--- a/layout/svg/nsSVGUtils.h
+++ b/layout/svg/nsSVGUtils.h
@@ -171,17 +171,17 @@ class nsSVGUtils {
   NS_DECLARE_FRAME_PROPERTY_DELETABLE(ObjectBoundingBoxProperty, gfxRect)
 
   /**
    * Returns the frame's post-filter visual overflow rect when passed the
    * frame's pre-filter visual overflow rect. If the frame is not currently
    * being filtered, this function simply returns aUnfilteredRect.
    */
   static nsRect GetPostFilterVisualOverflowRect(nsIFrame* aFrame,
-                                                const nsRect& aUnfilteredRect);
+                                                const nsRect& aPreFilterRect);
 
   /**
    * Schedules an update of the frame's bounds (which will in turn invalidate
    * the new area that the frame should paint to).
    *
    * This does nothing when passed an NS_FRAME_IS_NONDISPLAY frame.
    * In future we may want to allow ReflowSVG to be called on such frames,
    * but that would be better implemented as a ForceReflowSVG function to
@@ -230,17 +230,18 @@ class nsSVGUtils {
                            const SVGAnimatedLength* aLength);
 
   /* Computes the input length in terms of user space coordinates.
      Input: content - object to be used for determining user space
      Input: length - length to be converted
   */
   static float UserSpace(SVGElement* aSVGElement,
                          const SVGAnimatedLength* aLength);
-  static float UserSpace(nsIFrame* aFrame, const SVGAnimatedLength* aLength);
+  static float UserSpace(nsIFrame* aNonSVGContext,
+                         const SVGAnimatedLength* aLength);
   static float UserSpace(const mozilla::dom::UserSpaceMetrics& aMetrics,
                          const SVGAnimatedLength* aLength);
 
   /* Find the outermost SVG frame of the passed frame */
   static nsSVGOuterSVGFrame* GetOuterSVGFrame(nsIFrame* aFrame);
 
   /**
    * Get the covered region for a frame. Return null if it's not an SVG frame.