--- a/dom/animation/Animation.cpp
+++ b/dom/animation/Animation.cpp
@@ -739,17 +739,17 @@ Animation::AnimationTimeToTimeStamp(cons
   return result;
 }
 
 TimeStamp
 Animation::ElapsedTimeToTimeStamp(
   const StickyTimeDuration& aElapsedTime) const
 {
   TimeDuration delay = mEffect
-                       ? mEffect->SpecifiedTiming().mDelay
+                       ? mEffect->SpecifiedTiming().Delay()
                        : TimeDuration();
   return AnimationTimeToTimeStamp(aElapsedTime + delay);
 }
 
 // https://w3c.github.io/web-animations/#silently-set-the-current-time
 void
 Animation::SilentlySetCurrentTime(const TimeDuration& aSeekTime)
 {

--- a/dom/animation/AnimationEffectReadOnly.cpp
+++ b/dom/animation/AnimationEffectReadOnly.cpp
@@ -92,81 +92,81 @@ AnimationEffectReadOnly::GetComputedTimi
     const TimingParams& aTiming,
     double aPlaybackRate)
 {
   const StickyTimeDuration zeroDuration;
 
   // Always return the same object to benefit from return-value optimization.
   ComputedTiming result;
 
-  if (aTiming.mDuration) {
-    MOZ_ASSERT(aTiming.mDuration.ref() >= zeroDuration,
+  if (aTiming.Duration()) {
+    MOZ_ASSERT(aTiming.Duration().ref() >= zeroDuration,
                "Iteration duration should be positive");
-    result.mDuration = aTiming.mDuration.ref();
+    result.mDuration = aTiming.Duration().ref();
   }
 
-  MOZ_ASSERT(aTiming.mIterations >= 0.0 && !IsNaN(aTiming.mIterations),
+  MOZ_ASSERT(aTiming.Iterations() >= 0.0 && !IsNaN(aTiming.Iterations()),
              "mIterations should be nonnegative & finite, as ensured by "
              "ValidateIterations or CSSParser");
-  result.mIterations = aTiming.mIterations;
+  result.mIterations = aTiming.Iterations();
 
-  MOZ_ASSERT(aTiming.mIterationStart >= 0.0,
+  MOZ_ASSERT(aTiming.IterationStart() >= 0.0,
              "mIterationStart should be nonnegative, as ensured by "
              "ValidateIterationStart");
-  result.mIterationStart = aTiming.mIterationStart;
+  result.mIterationStart = aTiming.IterationStart();
 
   result.mActiveDuration = aTiming.ActiveDuration();
   result.mEndTime = aTiming.EndTime();
-  result.mFill = aTiming.mFill == dom::FillMode::Auto ?
+  result.mFill = aTiming.Fill() == dom::FillMode::Auto ?
                  dom::FillMode::None :
-                 aTiming.mFill;
+                 aTiming.Fill();
 
   // The default constructor for ComputedTiming sets all other members to
   // values consistent with an animation that has not been sampled.
   if (aLocalTime.IsNull()) {
     return result;
   }
   const TimeDuration& localTime = aLocalTime.Value();
 
   StickyTimeDuration beforeActiveBoundary =
-    std::max(std::min(StickyTimeDuration(aTiming.mDelay), result.mEndTime),
+    std::max(std::min(StickyTimeDuration(aTiming.Delay()), result.mEndTime),
              zeroDuration);
 
   StickyTimeDuration activeAfterBoundary =
-    std::max(std::min(StickyTimeDuration(aTiming.mDelay +
+    std::max(std::min(StickyTimeDuration(aTiming.Delay() +
                                          result.mActiveDuration),
                       result.mEndTime),
              zeroDuration);
 
   if (localTime > activeAfterBoundary ||
       (aPlaybackRate >= 0 && localTime == activeAfterBoundary)) {
     result.mPhase = ComputedTiming::AnimationPhase::After;
     if (!result.FillsForwards()) {
       // The animation isn't active or filling at this time.
       return result;
     }
     result.mActiveTime =
-      std::max(std::min(StickyTimeDuration(localTime - aTiming.mDelay),
+      std::max(std::min(StickyTimeDuration(localTime - aTiming.Delay()),
                         result.mActiveDuration),
                zeroDuration);
   } else if (localTime < beforeActiveBoundary ||
              (aPlaybackRate < 0 && localTime == beforeActiveBoundary)) {
     result.mPhase = ComputedTiming::AnimationPhase::Before;
     if (!result.FillsBackwards()) {
       // The animation isn't active or filling at this time.
       return result;
     }
     result.mActiveTime
-      = std::max(StickyTimeDuration(localTime - aTiming.mDelay),
+      = std::max(StickyTimeDuration(localTime - aTiming.Delay()),
                  zeroDuration);
   } else {
     MOZ_ASSERT(result.mActiveDuration != zeroDuration,
                "How can we be in the middle of a zero-duration interval?");
     result.mPhase = ComputedTiming::AnimationPhase::Active;
-    result.mActiveTime = localTime - aTiming.mDelay;
+    result.mActiveTime = localTime - aTiming.Delay();
   }
 
   // Convert active time to a multiple of iterations.
   // https://w3c.github.io/web-animations/#overall-progress
   double overallProgress;
   if (result.mDuration == zeroDuration) {
     overallProgress = result.mPhase == ComputedTiming::AnimationPhase::Before
                       ? 0.0
@@ -215,17 +215,17 @@ AnimationEffectReadOnly::GetComputedTimi
     progress = 1.0;
     if (result.mCurrentIteration != UINT64_MAX) {
       result.mCurrentIteration--;
     }
   }
 
   // Factor in the direction.
   bool thisIterationReverse = false;
-  switch (aTiming.mDirection) {
+  switch (aTiming.Direction()) {
     case PlaybackDirection::Normal:
       thisIterationReverse = false;
       break;
     case PlaybackDirection::Reverse:
       thisIterationReverse = true;
       break;
     case PlaybackDirection::Alternate:
       thisIterationReverse = (result.mCurrentIteration & 1) == 1;
@@ -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.mFunction) {
-    progress = aTiming.mFunction->GetValue(progress, result.mBeforeFlag);
+  if (aTiming.Function()) {
+    progress = aTiming.Function()->GetValue(progress, result.mBeforeFlag);
   }
 
   MOZ_ASSERT(IsFinite(progress), "Progress value should be finite");
   result.mProgress.SetValue(progress);
   return result;
 }
 
 ComputedTiming
@@ -271,24 +271,24 @@ AnimationEffectReadOnly::GetComputedTimi
 // Helper functions for generating a ComputedTimingProperties dictionary
 static void
 GetComputedTimingDictionary(const ComputedTiming& aComputedTiming,
                             const Nullable<TimeDuration>& aLocalTime,
                             const TimingParams& aTiming,
                             ComputedTimingProperties& aRetVal)
 {
   // AnimationEffectTimingProperties
-  aRetVal.mDelay = aTiming.mDelay.ToMilliseconds();
-  aRetVal.mEndDelay = aTiming.mEndDelay.ToMilliseconds();
+  aRetVal.mDelay = aTiming.Delay().ToMilliseconds();
+  aRetVal.mEndDelay = aTiming.EndDelay().ToMilliseconds();
   aRetVal.mFill = aComputedTiming.mFill;
   aRetVal.mIterations = aComputedTiming.mIterations;
   aRetVal.mIterationStart = aComputedTiming.mIterationStart;
   aRetVal.mDuration.SetAsUnrestrictedDouble() =
     aComputedTiming.mDuration.ToMilliseconds();
-  aRetVal.mDirection = aTiming.mDirection;
+  aRetVal.mDirection = aTiming.Direction();
 
   // ComputedTimingProperties
   aRetVal.mActiveDuration = aComputedTiming.mActiveDuration.ToMilliseconds();
   aRetVal.mEndTime = aComputedTiming.mEndTime.ToMilliseconds();
   aRetVal.mLocalTime = AnimationUtils::TimeDurationToDouble(aLocalTime);
   aRetVal.mProgress = aComputedTiming.mProgress;
 
   if (!aRetVal.mProgress.IsNull()) {

--- a/dom/animation/AnimationEffectTiming.cpp
+++ b/dom/animation/AnimationEffectTiming.cpp
@@ -28,125 +28,125 @@ PostSpecifiedTimingUpdated(KeyframeEffec
     aEffect->NotifySpecifiedTimingUpdated();
   }
 }
 
 void
 AnimationEffectTiming::SetDelay(double aDelay)
 {
   TimeDuration delay = TimeDuration::FromMilliseconds(aDelay);
-  if (mTiming.mDelay == delay) {
+  if (mTiming.Delay() == delay) {
     return;
   }
-  mTiming.mDelay = delay;
+  mTiming.SetDelay(delay);
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 void
 AnimationEffectTiming::SetEndDelay(double aEndDelay)
 {
   TimeDuration endDelay = TimeDuration::FromMilliseconds(aEndDelay);
-  if (mTiming.mEndDelay == endDelay) {
+  if (mTiming.EndDelay() == endDelay) {
     return;
   }
-  mTiming.mEndDelay = endDelay;
+  mTiming.SetEndDelay(endDelay);
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 void
 AnimationEffectTiming::SetFill(const FillMode& aFill)
 {
-  if (mTiming.mFill == aFill) {
+  if (mTiming.Fill() == aFill) {
     return;
   }
-  mTiming.mFill = aFill;
+  mTiming.SetFill(aFill);
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 void
 AnimationEffectTiming::SetIterationStart(double aIterationStart,
                                          ErrorResult& aRv)
 {
-  if (mTiming.mIterationStart == aIterationStart) {
+  if (mTiming.IterationStart() == aIterationStart) {
     return;
   }
 
   TimingParams::ValidateIterationStart(aIterationStart, aRv);
   if (aRv.Failed()) {
     return;
   }
 
-  mTiming.mIterationStart = aIterationStart;
+  mTiming.SetIterationStart(aIterationStart);
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 void
 AnimationEffectTiming::SetIterations(double aIterations, ErrorResult& aRv)
 {
-  if (mTiming.mIterations == aIterations) {
+  if (mTiming.Iterations() == aIterations) {
     return;
   }
 
   TimingParams::ValidateIterations(aIterations, aRv);
   if (aRv.Failed()) {
     return;
   }
 
-  mTiming.mIterations = aIterations;
+  mTiming.SetIterations(aIterations);
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 void
 AnimationEffectTiming::SetDuration(const UnrestrictedDoubleOrString& aDuration,
                                    ErrorResult& aRv)
 {
   Maybe<StickyTimeDuration> newDuration =
     TimingParams::ParseDuration(aDuration, aRv);
   if (aRv.Failed()) {
     return;
   }
 
-  if (mTiming.mDuration == newDuration) {
+  if (mTiming.Duration() == newDuration) {
     return;
   }
 
-  mTiming.mDuration = newDuration;
+  mTiming.SetDuration(Move(newDuration));
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 void
 AnimationEffectTiming::SetDirection(const PlaybackDirection& aDirection)
 {
-  if (mTiming.mDirection == aDirection) {
+  if (mTiming.Direction() == aDirection) {
     return;
   }
 
-  mTiming.mDirection = aDirection;
+  mTiming.SetDirection(aDirection);
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 void
 AnimationEffectTiming::SetEasing(const nsAString& aEasing, ErrorResult& aRv)
 {
   Maybe<ComputedTimingFunction> newFunction =
     TimingParams::ParseEasing(aEasing, mDocument, aRv);
   if (aRv.Failed()) {
     return;
   }
 
-  if (mTiming.mFunction == newFunction) {
+  if (mTiming.Function() == newFunction) {
     return;
   }
 
-  mTiming.mFunction = newFunction;
+  mTiming.SetFunction(Move(newFunction));
 
   PostSpecifiedTimingUpdated(mEffect);
 }
 
 } // namespace dom
 } // namespace mozilla

--- a/dom/animation/AnimationEffectTimingReadOnly.cpp
+++ b/dom/animation/AnimationEffectTimingReadOnly.cpp
@@ -25,27 +25,27 @@ AnimationEffectTimingReadOnly::WrapObjec
 {
   return AnimationEffectTimingReadOnlyBinding::Wrap(aCx, this, aGivenProto);
 }
 
 void
 AnimationEffectTimingReadOnly::GetDuration(
     OwningUnrestrictedDoubleOrString& aRetVal) const
 {
-  if (mTiming.mDuration) {
-    aRetVal.SetAsUnrestrictedDouble() = mTiming.mDuration->ToMilliseconds();
+  if (mTiming.Duration()) {
+    aRetVal.SetAsUnrestrictedDouble() = mTiming.Duration()->ToMilliseconds();
   } else {
     aRetVal.SetAsString().AssignLiteral("auto");
   }
 }
 
 void
 AnimationEffectTimingReadOnly::GetEasing(nsString& aRetVal) const
 {
-  if (mTiming.mFunction) {
-    mTiming.mFunction->AppendToString(aRetVal);
+  if (mTiming.Function()) {
+    mTiming.Function()->AppendToString(aRetVal);
   } else {
     aRetVal.AssignLiteral("linear");
   }
 }
 
 } // namespace dom
 } // namespace mozilla

--- a/dom/animation/AnimationEffectTimingReadOnly.h
+++ b/dom/animation/AnimationEffectTimingReadOnly.h
@@ -33,23 +33,23 @@ public:
 
 protected:
   virtual ~AnimationEffectTimingReadOnly() = default;
 
 public:
   nsISupports* GetParentObject() const { return mDocument; }
   JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
 
-  double Delay() const { return mTiming.mDelay.ToMilliseconds(); }
-  double EndDelay() const { return mTiming.mEndDelay.ToMilliseconds(); }
-  FillMode Fill() const { return mTiming.mFill; }
-  double IterationStart() const { return mTiming.mIterationStart; }
-  double Iterations() const { return mTiming.mIterations; }
+  double Delay() const { return mTiming.Delay().ToMilliseconds(); }
+  double EndDelay() const { return mTiming.EndDelay().ToMilliseconds(); }
+  FillMode Fill() const { return mTiming.Fill(); }
+  double IterationStart() const { return mTiming.IterationStart(); }
+  double Iterations() const { return mTiming.Iterations(); }
   void GetDuration(OwningUnrestrictedDoubleOrString& aRetVal) const;
-  PlaybackDirection Direction() const { return mTiming.mDirection; }
+  PlaybackDirection Direction() const { return mTiming.Direction(); }
   void GetEasing(nsString& aRetVal) const;
 
   const TimingParams& AsTimingParams() const { return mTiming; }
   void SetTimingParams(const TimingParams& aTiming) { mTiming = aTiming; }
 
   virtual void Unlink() { }
 
 protected:

--- a/dom/animation/TimingParams.h
+++ b/dom/animation/TimingParams.h
@@ -118,26 +118,16 @@ struct TimingParams
         NS_LITERAL_STRING("iterations"));
     }
   }
 
   static Maybe<ComputedTimingFunction> ParseEasing(const nsAString& aEasing,
                                                    nsIDocument* aDocument,
                                                    ErrorResult& aRv);
 
-  // mDuration.isNothing() represents the "auto" value
-  Maybe<StickyTimeDuration> mDuration;
-  TimeDuration mDelay;      // Initializes to zero
-  TimeDuration mEndDelay;
-  double mIterations = 1.0; // Can be NaN, negative, +/-Infinity
-  double mIterationStart = 0.0;
-  dom::PlaybackDirection mDirection = dom::PlaybackDirection::Normal;
-  dom::FillMode mFill = dom::FillMode::Auto;
-  Maybe<ComputedTimingFunction> mFunction;
-
   // Return the duration of the active interval calculated by duration and
   // iteration count.
   StickyTimeDuration ActiveDuration() const
   {
     // If either the iteration duration or iteration count is zero,
     // Web Animations says that the active duration is zero. This is to
     // ensure that the result is defined when the other argument is Infinity.
     static const StickyTimeDuration zeroDuration;
@@ -154,13 +144,72 @@ struct TimingParams
                     StickyTimeDuration());
   }
 
   bool operator==(const TimingParams& aOther) const;
   bool operator!=(const TimingParams& aOther) const
   {
     return !(*this == aOther);
   }
+
+  void SetDuration(Maybe<StickyTimeDuration>&& aDuration)
+  {
+    mDuration = Move(aDuration);
+  }
+  const Maybe<StickyTimeDuration>& Duration() const { return mDuration; }
+
+  void SetDelay(const TimeDuration& aDelay)
+  {
+    mDelay = aDelay;
+  }
+  const TimeDuration& Delay() const { return mDelay; }
+
+  void SetEndDelay(const TimeDuration& aEndDelay)
+  {
+    mEndDelay = aEndDelay;
+  }
+  const TimeDuration& EndDelay() const { return mEndDelay; }
+
+  void SetIterations(double aIterations)
+  {
+    mIterations = aIterations;
+  }
+  double Iterations() const { return mIterations; }
+
+  void SetIterationStart(double aIterationStart)
+  {
+    mIterationStart = aIterationStart;
+  }
+  double IterationStart() const { return mIterationStart; }
+
+  void SetDirection(dom::PlaybackDirection aDirection)
+  {
+    mDirection = aDirection;
+  }
+  dom::PlaybackDirection Direction() const { return mDirection; }
+
+  void SetFill(dom::FillMode aFill)
+  {
+    mFill = aFill;
+  }
+  dom::FillMode Fill() const { return mFill; }
+
+  void SetFunction(Maybe<ComputedTimingFunction>&& aFunction)
+  {
+    mFunction = Move(aFunction);
+  }
+  const Maybe<ComputedTimingFunction>& Function() const { return mFunction; }
+
+private:
+  // mDuration.isNothing() represents the "auto" value
+  Maybe<StickyTimeDuration> mDuration;
+  TimeDuration mDelay;      // Initializes to zero
+  TimeDuration mEndDelay;
+  double mIterations = 1.0; // Can be NaN, negative, +/-Infinity
+  double mIterationStart = 0.0;
+  dom::PlaybackDirection mDirection = dom::PlaybackDirection::Normal;
+  dom::FillMode mFill = dom::FillMode::Auto;
+  Maybe<ComputedTimingFunction> mFunction;
 };
 
 } // namespace mozilla
 
 #endif // mozilla_TimingParams_h

--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -540,27 +540,27 @@ AddAnimationForProperty(nsIFrame* aFrame
   } else {
     animation->startTime() = startTime.Value();
   }
 
   animation->holdTime() = aAnimation->GetCurrentTime().Value();
 
   const ComputedTiming computedTiming =
     aAnimation->GetEffect()->GetComputedTiming();
-  animation->delay() = timing.mDelay;
-  animation->endDelay() = timing.mEndDelay;
+  animation->delay() = timing.Delay();
+  animation->endDelay() = timing.EndDelay();
   animation->duration() = computedTiming.mDuration;
   animation->iterations() = computedTiming.mIterations;
   animation->iterationStart() = computedTiming.mIterationStart;
-  animation->direction() = static_cast<uint8_t>(timing.mDirection);
+  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.mFunction);
+  animation->easingFunction() = ToTimingFunction(timing.Function());
   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

--- a/layout/style/nsAnimationManager.cpp
+++ b/layout/style/nsAnimationManager.cpp
@@ -214,21 +214,21 @@ CSSAnimation::QueueEvents(StickyTimeDura
     ComputedTiming computedTiming = mEffect->GetComputedTiming();
     currentPhase = computedTiming.mPhase;
     currentIteration = computedTiming.mCurrentIteration;
     if (currentPhase == mPreviousPhase &&
         currentIteration == mPreviousIteration) {
       return;
     }
     intervalStartTime =
-      std::max(std::min(StickyTimeDuration(-mEffect->SpecifiedTiming().mDelay),
+      std::max(std::min(StickyTimeDuration(-mEffect->SpecifiedTiming().Delay()),
                         computedTiming.mActiveDuration),
                zeroDuration);
     intervalEndTime =
-      std::max(std::min((EffectEnd() - mEffect->SpecifiedTiming().mDelay),
+      std::max(std::min((EffectEnd() - mEffect->SpecifiedTiming().Delay()),
                         computedTiming.mActiveDuration),
                zeroDuration);
 
     uint64_t iterationBoundary = mPreviousIteration > currentIteration
                                  ? currentIteration + 1
                                  : currentIteration;
     iterationStartTime  =
       computedTiming.mDuration.MultDouble(

--- a/layout/style/nsAnimationManager.h
+++ b/layout/style/nsAnimationManager.h
@@ -184,17 +184,17 @@ protected:
 
   // Returns the duration from the start of the animation's source effect's
   // active interval to the point where the animation actually begins playback.
   // This is zero unless the animation's source effect has a negative delay in
   // which case it is the absolute value of that delay.
   // This is used for setting the elapsedTime member of CSS AnimationEvents.
   TimeDuration InitialAdvance() const {
     return mEffect ?
-           std::max(TimeDuration(), mEffect->SpecifiedTiming().mDelay * -1) :
+           std::max(TimeDuration(), mEffect->SpecifiedTiming().Delay() * -1) :
            TimeDuration();
   }
 
   nsString mAnimationName;
 
   // The (pseudo-)element whose computed animation-name refers to this
   // animation (if any).
   //

--- a/layout/style/nsTransitionManager.cpp
+++ b/layout/style/nsTransitionManager.cpp
@@ -65,17 +65,17 @@ ElementPropertyTransition::CurrentValueP
 
   // Transitions use a fill mode of 'backwards' so GetComputedTiming will
   // never return a null time progress due to being *before* the animation
   // interval. However, it might be possible that we're behind on flushing
   // causing us to get called *after* the animation interval. So, just in
   // case, we override the fill mode to 'both' to ensure the progress
   // is never null.
   TimingParams timingToUse = SpecifiedTiming();
-  timingToUse.mFill = dom::FillMode::Both;
+  timingToUse.SetFill(dom::FillMode::Both);
   ComputedTiming computedTiming = GetComputedTiming(&timingToUse);
 
   MOZ_ASSERT(!computedTiming.mProgress.IsNull(),
              "Got a null progress for a fill mode of 'both'");
   MOZ_ASSERT(mKeyframes.Length() == 2,
              "Should have two animation keyframes for a transition");
   return ComputedTimingFunction::GetPortion(mKeyframes[0].mTimingFunction,
                                             computedTiming.mProgress.Value(),
@@ -221,20 +221,20 @@ CSSTransition::QueueEvents(StickyTimeDur
 
   if (!mEffect) {
     currentPhase = GetAnimationPhaseWithoutEffect<TransitionPhase>(*this);
   } else {
     ComputedTiming computedTiming = mEffect->GetComputedTiming();
 
     currentPhase = static_cast<TransitionPhase>(computedTiming.mPhase);
     intervalStartTime =
-      std::max(std::min(StickyTimeDuration(-mEffect->SpecifiedTiming().mDelay),
+      std::max(std::min(StickyTimeDuration(-mEffect->SpecifiedTiming().Delay()),
                         computedTiming.mActiveDuration), zeroDuration);
     intervalEndTime =
-      std::max(std::min((EffectEnd() - mEffect->SpecifiedTiming().mDelay),
+      std::max(std::min((EffectEnd() - mEffect->SpecifiedTiming().Delay()),
                         computedTiming.mActiveDuration), zeroDuration);
   }
 
   // TimeStamps to use for ordering the events when they are dispatched. We
   // use a TimeStamp so we can compare events produced by different elements,
   // perhaps even with different timelines.
   // The zero timestamp is for transitionrun events where we ignore the delay
   // for the purpose of ordering events.