--- a/dom/animation/AnimationEffectReadOnly.cpp
+++ b/dom/animation/AnimationEffectReadOnly.cpp
@@ -245,18 +245,18 @@ AnimationEffectReadOnly::GetComputedTimi
   if ((result.mPhase == ComputedTiming::AnimationPhase::After &&
        thisIterationReverse) ||
       (result.mPhase == ComputedTiming::AnimationPhase::Before &&
        !thisIterationReverse)) {
     result.mBeforeFlag = ComputedTimingFunction::BeforeFlag::Set;
   }
 
   // Apply the easing.
-  if (aTiming.Function()) {
-    progress = aTiming.Function()->GetValue(progress, result.mBeforeFlag);
+  if (aTiming.TimingFunction()) {
+    progress = aTiming.TimingFunction()->GetValue(progress, result.mBeforeFlag);
   }
 
   MOZ_ASSERT(IsFinite(progress), "Progress value should be finite");
   result.mProgress.SetValue(progress);
   return result;
 }
 
 ComputedTiming

--- a/dom/animation/AnimationEffectTiming.cpp
+++ b/dom/animation/AnimationEffectTiming.cpp
@@ -134,19 +134,19 @@ void
 AnimationEffectTiming::SetEasing(const nsAString& aEasing, ErrorResult& aRv)
 {
   Maybe<ComputedTimingFunction> newFunction =
     TimingParams::ParseEasing(aEasing, mDocument, aRv);
   if (aRv.Failed()) {
     return;
   }
 
-  if (mTiming.Function() == newFunction) {
+  if (mTiming.TimingFunction() == newFunction) {
     return;
   }
 
-  mTiming.SetFunction(Move(newFunction));
+  mTiming.SetTimingFunction(Move(newFunction));
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 } // namespace dom
 } // namespace mozilla

--- a/dom/animation/AnimationEffectTimingReadOnly.cpp
+++ b/dom/animation/AnimationEffectTimingReadOnly.cpp
@@ -35,17 +35,17 @@ AnimationEffectTimingReadOnly::GetDurati
   } else {
     aRetVal.SetAsString().AssignLiteral("auto");
   }
 }
 
 void
 AnimationEffectTimingReadOnly::GetEasing(nsString& aRetVal) const
 {
-  if (mTiming.Function()) {
-    mTiming.Function()->AppendToString(aRetVal);
+  if (mTiming.TimingFunction()) {
+    mTiming.TimingFunction()->AppendToString(aRetVal);
   } else {
     aRetVal.AssignLiteral("linear");
   }
 }
 
 } // namespace dom
 } // namespace mozilla

--- a/dom/animation/TimingParams.h
+++ b/dom/animation/TimingParams.h
@@ -203,21 +203,24 @@ struct TimingParams
   dom::PlaybackDirection Direction() const { return mDirection; }
 
   void SetFill(dom::FillMode aFill)
   {
     mFill = aFill;
   }
   dom::FillMode Fill() const { return mFill; }
 
-  void SetFunction(Maybe<ComputedTimingFunction>&& aFunction)
+  void SetTimingFunction(Maybe<ComputedTimingFunction>&& aFunction)
   {
     mFunction = Move(aFunction);
   }
-  const Maybe<ComputedTimingFunction>& Function() const { return mFunction; }
+  const Maybe<ComputedTimingFunction>& TimingFunction() const
+  {
+    return mFunction;
+  }
 
 private:
   void Update()
   {
     mActiveDuration = CalcActiveDuration(mDuration, mIterations);
 
     mEndTime = std::max(mDelay + mActiveDuration + mEndDelay,
                         StickyTimeDuration());

--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -550,17 +550,17 @@ AddAnimationForProperty(nsIFrame* aFrame
   animation->duration() = computedTiming.mDuration;
   animation->iterations() = computedTiming.mIterations;
   animation->iterationStart() = computedTiming.mIterationStart;
   animation->direction() = static_cast<uint8_t>(timing.Direction());
   animation->fillMode() = static_cast<uint8_t>(computedTiming.mFill);
   animation->property() = aProperty.mProperty;
   animation->playbackRate() = aAnimation->PlaybackRate();
   animation->data() = aData;
-  animation->easingFunction() = ToTimingFunction(timing.Function());
+  animation->easingFunction() = ToTimingFunction(timing.TimingFunction());
   animation->iterationComposite() =
     static_cast<uint8_t>(aAnimation->GetEffect()->
                          AsKeyframeEffect()->IterationComposite());
   animation->isNotPlaying() = !aAnimation->IsPlaying();
 
   TransformReferenceBox refBox(aFrame);
 
   // If the animation is additive or accumulates, we need to pass its base value