Merge mozilla-central to autoland. a=merge on a CLOSED TREE
authorRazvan Maries <rmaries@mozilla.com>
Sun, 28 Apr 2019 00:49:14 +0300
changeset 530484 14e82cfcd7270d40294542ba24f03ee459830e8e
parent 530483 037390836504bc52a3470027aa3015b476e6147c (current diff)
parent 530476 b0d41799ceb31e39ea857f18f4a65e8944818c6a (diff)
child 530485 120e27d9bb9e38735e003e0e0fbbba522d41f940
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
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge mozilla-central to autoland. a=merge on a CLOSED TREE
--- 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.