rename from dom/animation/AnimationPlayer.cpp
rename to dom/animation/Animation.cpp
--- a/dom/animation/AnimationPlayer.cpp
+++ b/dom/animation/Animation.cpp
@@ -1,44 +1,44 @@
 /* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "AnimationPlayer.h"
+#include "Animation.h"
 #include "AnimationUtils.h"
-#include "mozilla/dom/AnimationPlayerBinding.h"
+#include "mozilla/dom/AnimationBinding.h"
 #include "mozilla/AutoRestore.h"
-#include "AnimationCommon.h" // For AnimationPlayerCollection,
+#include "AnimationCommon.h" // For AnimationCollection,
                              // CommonAnimationManager
 #include "nsIDocument.h" // For nsIDocument
 #include "nsIPresShell.h" // For nsIPresShell
 #include "nsLayoutUtils.h" // For PostRestyleEvent (remove after bug 1073336)
-#include "PendingPlayerTracker.h" // For PendingPlayerTracker
+#include "PendingAnimationTracker.h" // For PendingAnimationTracker
 
 namespace mozilla {
 namespace dom {
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(AnimationPlayer, mTimeline,
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Animation, mTimeline,
                                       mEffect, mReady, mFinished)
-NS_IMPL_CYCLE_COLLECTING_ADDREF(AnimationPlayer)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(AnimationPlayer)
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AnimationPlayer)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(Animation)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(Animation)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Animation)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 JSObject*
-AnimationPlayer::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+Animation::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return dom::AnimationPlayerBinding::Wrap(aCx, this, aGivenProto);
+  return dom::AnimationBinding::Wrap(aCx, this, aGivenProto);
 }
 
 void
-AnimationPlayer::SetStartTime(const Nullable<TimeDuration>& aNewStartTime)
+Animation::SetStartTime(const Nullable<TimeDuration>& aNewStartTime)
 {
 #if 1
   // Bug 1096776: once we support inactive/missing timelines we'll want to take
   // the disabled branch.
   MOZ_ASSERT(mTimeline && !mTimeline->GetCurrentTime().IsNull(),
              "We don't support inactive/missing timelines yet");
 #else
   Nullable<TimeDuration> timelineTime = mTimeline->GetCurrentTime();
@@ -69,17 +69,17 @@ AnimationPlayer::SetStartTime(const Null
     mReady->MaybeResolve(this);
   }
 
   UpdateTiming();
   PostUpdate();
 }
 
 Nullable<TimeDuration>
-AnimationPlayer::GetCurrentTime() const
+Animation::GetCurrentTime() const
 {
   Nullable<TimeDuration> result;
   if (!mHoldTime.IsNull()) {
     result = mHoldTime;
     return result;
   }
 
   if (!mStartTime.IsNull()) {
@@ -89,17 +89,17 @@ AnimationPlayer::GetCurrentTime() const
                         .MultDouble(mPlaybackRate));
     }
   }
   return result;
 }
 
 // Implements http://w3c.github.io/web-animations/#silently-set-the-current-time
 void
-AnimationPlayer::SilentlySetCurrentTime(const TimeDuration& aSeekTime)
+Animation::SilentlySetCurrentTime(const TimeDuration& aSeekTime)
 {
   if (!mHoldTime.IsNull() ||
       !mTimeline ||
       mTimeline->GetCurrentTime().IsNull() ||
       mPlaybackRate == 0.0
       /*or, once supported, if we have a pending pause task*/) {
     mHoldTime.SetValue(aSeekTime);
     if (!mTimeline || mTimeline->GetCurrentTime().IsNull()) {
@@ -110,58 +110,58 @@ AnimationPlayer::SilentlySetCurrentTime(
                           (aSeekTime.MultDouble(1 / mPlaybackRate)));
   }
 
   mPreviousCurrentTime.SetNull();
 }
 
 // Implements http://w3c.github.io/web-animations/#set-the-current-time
 void
-AnimationPlayer::SetCurrentTime(const TimeDuration& aSeekTime)
+Animation::SetCurrentTime(const TimeDuration& aSeekTime)
 {
   SilentlySetCurrentTime(aSeekTime);
 
   if (mPendingState == PendingState::PausePending) {
     CancelPendingTasks();
     if (mReady) {
       mReady->MaybeResolve(this);
     }
   }
 
   UpdateFinishedState(true);
   UpdateEffect();
   PostUpdate();
 }
 
 void
-AnimationPlayer::SetPlaybackRate(double aPlaybackRate)
+Animation::SetPlaybackRate(double aPlaybackRate)
 {
   Nullable<TimeDuration> previousTime = GetCurrentTime();
   mPlaybackRate = aPlaybackRate;
   if (!previousTime.IsNull()) {
     ErrorResult rv;
     SetCurrentTime(previousTime.Value());
     MOZ_ASSERT(!rv.Failed(), "Should not assert for non-null time");
   }
 }
 
 void
-AnimationPlayer::SilentlySetPlaybackRate(double aPlaybackRate)
+Animation::SilentlySetPlaybackRate(double aPlaybackRate)
 {
   Nullable<TimeDuration> previousTime = GetCurrentTime();
   mPlaybackRate = aPlaybackRate;
   if (!previousTime.IsNull()) {
     ErrorResult rv;
     SilentlySetCurrentTime(previousTime.Value());
     MOZ_ASSERT(!rv.Failed(), "Should not assert for non-null time");
   }
 }
 
 AnimationPlayState
-AnimationPlayer::PlayState() const
+Animation::PlayState() const
 {
   if (mPendingState != PendingState::NotPending) {
     return AnimationPlayState::Pending;
   }
 
   Nullable<TimeDuration> currentTime = GetCurrentTime();
   if (currentTime.IsNull()) {
     return AnimationPlayState::Idle;
@@ -185,155 +185,156 @@ CreatePromise(DocumentTimeline* aTimelin
   nsIGlobalObject* global = aTimeline->GetParentObject();
   if (global) {
     return Promise::Create(global, aRv);
   }
   return nullptr;
 }
 
 Promise*
-AnimationPlayer::GetReady(ErrorResult& aRv)
+Animation::GetReady(ErrorResult& aRv)
 {
   if (!mReady) {
     mReady = CreatePromise(mTimeline, aRv); // Lazily create on demand
   }
   if (!mReady) {
     aRv.Throw(NS_ERROR_FAILURE);
   } else if (PlayState() != AnimationPlayState::Pending) {
     mReady->MaybeResolve(this);
   }
   return mReady;
 }
 
 Promise*
-AnimationPlayer::GetFinished(ErrorResult& aRv)
+Animation::GetFinished(ErrorResult& aRv)
 {
   if (!mFinished) {
     mFinished = CreatePromise(mTimeline, aRv); // Lazily create on demand
   }
   if (!mFinished) {
     aRv.Throw(NS_ERROR_FAILURE);
   } else if (IsFinished()) {
     mFinished->MaybeResolve(this);
   }
   return mFinished;
 }
 
 void
-AnimationPlayer::Play(LimitBehavior aLimitBehavior)
+Animation::Play(LimitBehavior aLimitBehavior)
 {
   DoPlay(aLimitBehavior);
   PostUpdate();
 }
 
 void
-AnimationPlayer::Pause()
+Animation::Pause()
 {
   // TODO: The DoPause() call should not be synchronous (bug 1109390). See
   // http://w3c.github.io/web-animations/#pausing-an-animation-section
   DoPause();
   PostUpdate();
 }
 
 Nullable<double>
-AnimationPlayer::GetStartTimeAsDouble() const
+Animation::GetStartTimeAsDouble() const
 {
   return AnimationUtils::TimeDurationToDouble(mStartTime);
 }
 
 void
-AnimationPlayer::SetStartTimeAsDouble(const Nullable<double>& aStartTime)
+Animation::SetStartTimeAsDouble(const Nullable<double>& aStartTime)
 {
   return SetStartTime(AnimationUtils::DoubleToTimeDuration(aStartTime));
 }
-  
+
 Nullable<double>
-AnimationPlayer::GetCurrentTimeAsDouble() const
+Animation::GetCurrentTimeAsDouble() const
 {
   return AnimationUtils::TimeDurationToDouble(GetCurrentTime());
 }
 
 void
-AnimationPlayer::SetCurrentTimeAsDouble(const Nullable<double>& aCurrentTime,
+Animation::SetCurrentTimeAsDouble(const Nullable<double>& aCurrentTime,
                                         ErrorResult& aRv)
 {
   if (aCurrentTime.IsNull()) {
     if (!GetCurrentTime().IsNull()) {
       aRv.Throw(NS_ERROR_DOM_TYPE_ERR);
     }
     return;
   }
 
   return SetCurrentTime(TimeDuration::FromMilliseconds(aCurrentTime.Value()));
 }
 
 void
-AnimationPlayer::SetEffect(KeyframeEffectReadonly* aEffect)
+Animation::SetEffect(KeyframeEffectReadonly* aEffect)
 {
   if (mEffect) {
     mEffect->SetParentTime(Nullable<TimeDuration>());
   }
   mEffect = aEffect;
   if (mEffect) {
     mEffect->SetParentTime(GetCurrentTime());
   }
   UpdateRelevance();
 }
 
 void
-AnimationPlayer::Tick()
+Animation::Tick()
 {
   // Since we are not guaranteed to get only one call per refresh driver tick,
   // it's possible that mPendingReadyTime is set to a time in the future.
   // In that case, we should wait until the next refresh driver tick before
   // resuming.
   if (mPendingState != PendingState::NotPending &&
       !mPendingReadyTime.IsNull() &&
       mPendingReadyTime.Value() <= mTimeline->GetCurrentTime().Value()) {
     FinishPendingAt(mPendingReadyTime.Value());
     mPendingReadyTime.SetNull();
   }
 
-  if (IsPossiblyOrphanedPendingPlayer()) {
+  if (IsPossiblyOrphanedPendingAnimation()) {
     MOZ_ASSERT(mTimeline && !mTimeline->GetCurrentTime().IsNull(),
-               "Orphaned pending players should have an active timeline");
+               "Orphaned pending animtaions should have an active timeline");
     FinishPendingAt(mTimeline->GetCurrentTime().Value());
   }
 
   UpdateTiming();
 }
 
 void
-AnimationPlayer::TriggerOnNextTick(const Nullable<TimeDuration>& aReadyTime)
+Animation::TriggerOnNextTick(const Nullable<TimeDuration>& aReadyTime)
 {
   // Normally we expect the play state to be pending but it's possible that,
-  // due to the handling of possibly orphaned players in Tick(), this player got
-  // started whilst still being in another document's pending player map.
+  // due to the handling of possibly orphaned animations in Tick(), this
+  // animation got started whilst still being in another document's pending
+  // animation map.
   if (PlayState() != AnimationPlayState::Pending) {
     return;
   }
 
   // If aReadyTime.IsNull() we'll detect this in Tick() where we check for
-  // orphaned players and trigger this animation anyway
+  // orphaned animations and trigger this animation anyway
   mPendingReadyTime = aReadyTime;
 }
 
 void
-AnimationPlayer::TriggerNow()
+Animation::TriggerNow()
 {
   MOZ_ASSERT(PlayState() == AnimationPlayState::Pending,
-             "Expected to start a pending player");
+             "Expected to start a pending animation");
   MOZ_ASSERT(mTimeline && !mTimeline->GetCurrentTime().IsNull(),
              "Expected an active timeline");
 
   FinishPendingAt(mTimeline->GetCurrentTime().Value());
 }
 
 Nullable<TimeDuration>
-AnimationPlayer::GetCurrentOrPendingStartTime() const
+Animation::GetCurrentOrPendingStartTime() const
 {
   Nullable<TimeDuration> result;
 
   if (!mStartTime.IsNull()) {
     result = mStartTime;
     return result;
   }
 
@@ -344,17 +345,17 @@ AnimationPlayer::GetCurrentOrPendingStar
   // Calculate the equivalent start time from the pending ready time.
   // This is the same as the calculation performed in ResumeAt and will
   // need to incorporate the playbackRate when implemented (bug 1127380).
   result.SetValue(mPendingReadyTime.Value() - mHoldTime.Value());
   return result;
 }
 
 void
-AnimationPlayer::Cancel()
+Animation::Cancel()
 {
   if (mPendingState != PendingState::NotPending) {
     CancelPendingTasks();
     if (mReady) {
       mReady->MaybeReject(NS_ERROR_DOM_ABORT_ERR);
     }
   }
 
@@ -366,31 +367,31 @@ AnimationPlayer::Cancel()
 
   mHoldTime.SetNull();
   mStartTime.SetNull();
 
   UpdateEffect();
 }
 
 void
-AnimationPlayer::UpdateRelevance()
+Animation::UpdateRelevance()
 {
   bool wasRelevant = mIsRelevant;
   mIsRelevant = HasCurrentEffect() || IsInEffect();
 
   // Notify animation observers.
   if (wasRelevant && !mIsRelevant) {
     nsNodeUtils::AnimationRemoved(this);
   } else if (!wasRelevant && mIsRelevant) {
     nsNodeUtils::AnimationAdded(this);
   }
 }
 
 bool
-AnimationPlayer::CanThrottle() const
+Animation::CanThrottle() const
 {
   if (!mEffect ||
       mEffect->IsFinishedTransition() ||
       mEffect->Properties().IsEmpty()) {
     return true;
   }
 
   if (!mIsRunningOnCompositor) {
@@ -405,19 +406,19 @@ AnimationPlayer::CanThrottle() const
   // The animation has finished but, if this is the first sample since
   // finishing, we need an unthrottled sample so we can apply the correct
   // end-of-animation behavior on the main thread (either removing the
   // animation style or applying the fill mode).
   return mFinishedAtLastComposeStyle;
 }
 
 void
-AnimationPlayer::ComposeStyle(nsRefPtr<css::AnimValuesStyleRule>& aStyleRule,
-                              nsCSSPropertySet& aSetProperties,
-                              bool& aNeedsRefreshes)
+Animation::ComposeStyle(nsRefPtr<css::AnimValuesStyleRule>& aStyleRule,
+                        nsCSSPropertySet& aSetProperties,
+                        bool& aNeedsRefreshes)
 {
   if (!mEffect || mEffect->IsFinishedTransition()) {
     return;
   }
 
   AnimationPlayState playState = PlayState();
   if (playState == AnimationPlayState::Running ||
       playState == AnimationPlayState::Pending) {
@@ -488,17 +489,17 @@ AnimationPlayer::ComposeStyle(nsRefPtr<c
       UpdateTiming();
     }
 
     mFinishedAtLastComposeStyle = (playState == AnimationPlayState::Finished);
   }
 }
 
 void
-AnimationPlayer::DoPlay(LimitBehavior aLimitBehavior)
+Animation::DoPlay(LimitBehavior aLimitBehavior)
 {
   bool abortedPause = mPendingState == PendingState::PausePending;
 
   bool reuseReadyPromise = false;
   if (mPendingState != PendingState::NotPending) {
     CancelPendingTasks();
     reuseReadyPromise = true;
   }
@@ -543,25 +544,25 @@ AnimationPlayer::DoPlay(LimitBehavior aL
   mPendingState = PendingState::PlayPending;
 
   nsIDocument* doc = GetRenderedDocument();
   if (!doc) {
     TriggerOnNextTick(Nullable<TimeDuration>());
     return;
   }
 
-  PendingPlayerTracker* tracker = doc->GetOrCreatePendingPlayerTracker();
+  PendingAnimationTracker* tracker = doc->GetOrCreatePendingAnimationTracker();
   tracker->AddPlayPending(*this);
 
   // We may have updated the current time when we set the hold time above.
   UpdateTiming();
 }
 
 void
-AnimationPlayer::DoPause()
+Animation::DoPause()
 {
   if (IsPausedOrPausing()) {
     return;
   }
 
   bool reuseReadyPromise = false;
   if (mPendingState == PendingState::PlayPending) {
     CancelPendingTasks();
@@ -581,32 +582,32 @@ AnimationPlayer::DoPause()
   mPendingState = PendingState::PausePending;
 
   nsIDocument* doc = GetRenderedDocument();
   if (!doc) {
     TriggerOnNextTick(Nullable<TimeDuration>());
     return;
   }
 
-  PendingPlayerTracker* tracker = doc->GetOrCreatePendingPlayerTracker();
+  PendingAnimationTracker* tracker = doc->GetOrCreatePendingAnimationTracker();
   tracker->AddPausePending(*this);
 
   UpdateFinishedState();
 }
 
 void
-AnimationPlayer::ResumeAt(const TimeDuration& aReadyTime)
+Animation::ResumeAt(const TimeDuration& aReadyTime)
 {
-  // This method is only expected to be called for a player that is
+  // This method is only expected to be called for an animation that is
   // waiting to play. We can easily adapt it to handle other states
   // but it's currently not necessary.
   MOZ_ASSERT(mPendingState == PendingState::PlayPending,
-             "Expected to resume a play-pending player");
+             "Expected to resume a play-pending animation");
   MOZ_ASSERT(mHoldTime.IsNull() != mStartTime.IsNull(),
-             "A player in the play-pending state should have either a"
+             "An animation in the play-pending state should have either a"
              " resolved hold time or resolved start time (but not both)");
 
   // If we aborted a pending pause operation we will already have a start time
   // we should use. In all other cases, we resolve it from the ready time.
   if (mStartTime.IsNull()) {
     if (mPlaybackRate != 0) {
       mStartTime.SetValue(aReadyTime -
                           (mHoldTime.Value().MultDouble(1 / mPlaybackRate)));
@@ -620,46 +621,46 @@ AnimationPlayer::ResumeAt(const TimeDura
   UpdateTiming();
 
   if (mReady) {
     mReady->MaybeResolve(this);
   }
 }
 
 void
-AnimationPlayer::PauseAt(const TimeDuration& aReadyTime)
+Animation::PauseAt(const TimeDuration& aReadyTime)
 {
   MOZ_ASSERT(mPendingState == PendingState::PausePending,
-             "Expected to pause a pause-pending player");
+             "Expected to pause a pause-pending animation");
 
   if (!mStartTime.IsNull()) {
     mHoldTime.SetValue((aReadyTime - mStartTime.Value())
                         .MultDouble(mPlaybackRate));
   }
   mStartTime.SetNull();
   mPendingState = PendingState::NotPending;
 
   UpdateTiming();
 
   if (mReady) {
     mReady->MaybeResolve(this);
   }
 }
 
 void
-AnimationPlayer::UpdateTiming()
+Animation::UpdateTiming()
 {
   // We call UpdateFinishedState before UpdateEffect because the former
   // can change the current time, which is used by the latter.
   UpdateFinishedState();
   UpdateEffect();
 }
 
 void
-AnimationPlayer::UpdateFinishedState(bool aSeekFlag)
+Animation::UpdateFinishedState(bool aSeekFlag)
 {
   Nullable<TimeDuration> currentTime = GetCurrentTime();
   TimeDuration effectEnd = TimeDuration(EffectEnd());
 
   if (!mStartTime.IsNull() &&
       mPendingState == PendingState::NotPending) {
     if (mPlaybackRate > 0.0 &&
         !currentTime.IsNull() &&
@@ -692,102 +693,105 @@ AnimationPlayer::UpdateFinishedState(boo
   bool currentFinishedState = IsFinished();
   if (currentFinishedState && !mIsPreviousStateFinished) {
     if (mFinished) {
       mFinished->MaybeResolve(this);
     }
   } else if (!currentFinishedState && mIsPreviousStateFinished) {
     // Clear finished promise. We'll create a new one lazily.
     mFinished = nullptr;
+    if (mEffect->AsTransition()) {
+      mEffect->SetIsFinishedTransition(false);
+    }
   }
   mIsPreviousStateFinished = currentFinishedState;
   // We must recalculate the current time to take account of any mHoldTime
   // changes the code above made.
   mPreviousCurrentTime = GetCurrentTime();
 }
 
 void
-AnimationPlayer::UpdateEffect()
+Animation::UpdateEffect()
 {
   if (mEffect) {
     mEffect->SetParentTime(GetCurrentTime());
     UpdateRelevance();
   }
 }
 
 void
-AnimationPlayer::FlushStyle() const
+Animation::FlushStyle() const
 {
   nsIDocument* doc = GetRenderedDocument();
   if (doc) {
     doc->FlushPendingNotifications(Flush_Style);
   }
 }
 
 void
-AnimationPlayer::PostUpdate()
+Animation::PostUpdate()
 {
-  AnimationPlayerCollection* collection = GetCollection();
+  AnimationCollection* collection = GetCollection();
   if (collection) {
-    collection->NotifyPlayerUpdated();
+    collection->NotifyAnimationUpdated();
   }
 }
 
 void
-AnimationPlayer::CancelPendingTasks()
+Animation::CancelPendingTasks()
 {
   if (mPendingState == PendingState::NotPending) {
     return;
   }
 
   nsIDocument* doc = GetRenderedDocument();
   if (doc) {
-    PendingPlayerTracker* tracker = doc->GetPendingPlayerTracker();
+    PendingAnimationTracker* tracker = doc->GetPendingAnimationTracker();
     if (tracker) {
       if (mPendingState == PendingState::PlayPending) {
         tracker->RemovePlayPending(*this);
       } else {
         tracker->RemovePausePending(*this);
       }
     }
   }
 
   mPendingState = PendingState::NotPending;
   mPendingReadyTime.SetNull();
 }
 
 bool
-AnimationPlayer::IsFinished() const
+Animation::IsFinished() const
 {
   // Unfortunately there's some weirdness in the spec at the moment where if
   // you're finished and paused, the playState is paused. This prevents us
   // from just checking |PlayState() == AnimationPlayState::Finished| here,
   // and we need this much more messy check to see if we're finished.
   Nullable<TimeDuration> currentTime = GetCurrentTime();
   return !currentTime.IsNull() &&
       ((mPlaybackRate > 0.0 && currentTime.Value() >= EffectEnd()) ||
        (mPlaybackRate < 0.0 && currentTime.Value().ToMilliseconds() <= 0.0));
 }
 
 bool
-AnimationPlayer::IsPossiblyOrphanedPendingPlayer() const
+Animation::IsPossiblyOrphanedPendingAnimation() const
 {
   // Check if we are pending but might never start because we are not being
   // tracked.
   //
   // This covers the following cases:
   //
   // * We started playing but our effect's target element was orphaned
   //   or bound to a different document.
   //   (note that for the case of our effect changing we should handle
   //   that in SetEffect)
   // * We started playing but our timeline became inactive.
-  //   In this case the pending player tracker will drop us from its hashmap
+  //   In this case the pending animation tracker will drop us from its hashmap
   //   when we have been painted.
-  // * When we started playing we couldn't find a PendingPlayerTracker to
+  // * When we started playing we couldn't find a PendingAnimationTracker to
   //   register with (perhaps the effect had no document) so we simply
   //   set mPendingState in DoPlay and relied on this method to catch us on the
   //   next tick.
 
   // If we're not pending we're ok.
   if (mPendingState == PendingState::NotPending) {
     return false;
   }
@@ -800,86 +804,87 @@ AnimationPlayer::IsPossiblyOrphanedPendi
 
   // If we don't have an active timeline then we shouldn't start until
   // we do.
   if (!mTimeline || mTimeline->GetCurrentTime().IsNull()) {
     return false;
   }
 
   // If we have no rendered document, or we're not in our rendered document's
-  // PendingPlayerTracker then there's a good chance no one is tracking us.
+  // PendingAnimationTracker then there's a good chance no one is tracking us.
   //
   // If we're wrong and another document is tracking us then, at worst, we'll
   // simply start/pause the animation one tick too soon. That's better than
   // never starting/pausing the animation and is unlikely.
   nsIDocument* doc = GetRenderedDocument();
   if (!doc) {
     return false;
   }
 
-  PendingPlayerTracker* tracker = doc->GetPendingPlayerTracker();
+  PendingAnimationTracker* tracker = doc->GetPendingAnimationTracker();
   return !tracker ||
          (!tracker->IsWaitingToPlay(*this) &&
           !tracker->IsWaitingToPause(*this));
 }
 
 StickyTimeDuration
-AnimationPlayer::EffectEnd() const
+Animation::EffectEnd() const
 {
   if (!mEffect) {
     return StickyTimeDuration(0);
   }
 
   return mEffect->Timing().mDelay
          + mEffect->GetComputedTiming().mActiveDuration;
 }
 
 nsIDocument*
-AnimationPlayer::GetRenderedDocument() const
+Animation::GetRenderedDocument() const
 {
   if (!mEffect) {
     return nullptr;
   }
 
   Element* targetElement;
   nsCSSPseudoElements::Type pseudoType;
   mEffect->GetTarget(targetElement, pseudoType);
   if (!targetElement) {
     return nullptr;
   }
 
   return targetElement->GetComposedDoc();
 }
 
 nsPresContext*
-AnimationPlayer::GetPresContext() const
+Animation::GetPresContext() const
 {
   nsIDocument* doc = GetRenderedDocument();
   if (!doc) {
     return nullptr;
   }
   nsIPresShell* shell = doc->GetShell();
   if (!shell) {
     return nullptr;
   }
   return shell->GetPresContext();
 }
 
-AnimationPlayerCollection*
-AnimationPlayer::GetCollection() const
+AnimationCollection*
+Animation::GetCollection() const
 {
   css::CommonAnimationManager* manager = GetAnimationManager();
   if (!manager) {
     return nullptr;
   }
-  MOZ_ASSERT(mEffect, "A player with an animation manager must have an effect");
+  MOZ_ASSERT(mEffect,
+             "An animation with an animation manager must have an effect");
 
   Element* targetElement;
   nsCSSPseudoElements::Type targetPseudoType;
   mEffect->GetTarget(targetElement, targetPseudoType);
   MOZ_ASSERT(targetElement,
-             "A player with an animation manager must have a target");
+             "An animation with an animation manager must have a target");
 
   return manager->GetAnimations(targetElement, targetPseudoType, false);
 }
 
 } // namespace dom
 } // namespace mozilla

rename from dom/animation/AnimationPlayer.h
rename to dom/animation/Animation.h
--- a/dom/animation/AnimationPlayer.h
+++ b/dom/animation/Animation.h
@@ -1,21 +1,21 @@
 /* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef mozilla_dom_AnimationPlayer_h
-#define mozilla_dom_AnimationPlayer_h
+#ifndef mozilla_dom_Animation_h
+#define mozilla_dom_Animation_h
 
 #include "nsWrapperCache.h"
 #include "nsCycleCollectionParticipant.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/TimeStamp.h" // for TimeStamp, TimeDuration
-#include "mozilla/dom/AnimationPlayerBinding.h" // for AnimationPlayState
+#include "mozilla/dom/AnimationBinding.h" // for AnimationPlayState
 #include "mozilla/dom/DocumentTimeline.h" // for DocumentTimeline
 #include "mozilla/dom/KeyframeEffect.h" // for KeyframeEffectReadonly
 #include "mozilla/dom/Promise.h" // for Promise
 #include "nsCSSProperty.h" // for nsCSSProperty
 
 // X11 has a #define for CurrentTime.
 #ifdef CurrentTime
 #undef CurrentTime
@@ -28,63 +28,64 @@
 #endif
 
 struct JSContext;
 class nsCSSPropertySet;
 class nsIDocument;
 class nsPresContext;
 
 namespace mozilla {
-struct AnimationPlayerCollection;
+struct AnimationCollection;
 namespace css {
 class AnimValuesStyleRule;
 class CommonAnimationManager;
 } // namespace css
 
-class CSSAnimationPlayer;
-class CSSTransitionPlayer;
+class CSSAnimation;
+class CSSTransition;
 
 namespace dom {
 
-class AnimationPlayer : public nsISupports,
-                        public nsWrapperCache
+class Animation
+  : public nsISupports
+  , public nsWrapperCache
 {
 protected:
-  virtual ~AnimationPlayer() {}
+  virtual ~Animation() {}
 
 public:
-  explicit AnimationPlayer(DocumentTimeline* aTimeline)
+  explicit Animation(DocumentTimeline* aTimeline)
     : mTimeline(aTimeline)
     , mPlaybackRate(1.0)
     , mPendingState(PendingState::NotPending)
     , mIsRunningOnCompositor(false)
     , mIsPreviousStateFinished(false)
     , mFinishedAtLastComposeStyle(false)
     , mIsRelevant(false)
   {
   }
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(AnimationPlayer)
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Animation)
 
   DocumentTimeline* GetParentObject() const { return mTimeline; }
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
 
-  virtual CSSAnimationPlayer* AsCSSAnimationPlayer() { return nullptr; }
-  virtual CSSTransitionPlayer* AsCSSTransitionPlayer() { return nullptr; }
+  virtual CSSAnimation* AsCSSAnimation() { return nullptr; }
+  virtual CSSTransition* AsCSSTransition() { return nullptr; }
 
   // Flag to pass to DoPlay to indicate that it should not carry out finishing
   // behavior (reset the current time to the beginning of the active duration).
   enum LimitBehavior {
     AutoRewind = 0,
     Continue = 1
   };
 
-  // AnimationPlayer methods
+  // Animation methods
   KeyframeEffectReadonly* GetEffect() const { return mEffect; }
   DocumentTimeline* Timeline() const { return mTimeline; }
   Nullable<TimeDuration> GetStartTime() const { return mStartTime; }
   void SetStartTime(const Nullable<TimeDuration>& aNewStartTime);
   Nullable<TimeDuration> GetCurrentTime() const;
   void SilentlySetCurrentTime(const TimeDuration& aNewCurrentTime);
   void SetCurrentTime(const TimeDuration& aNewCurrentTime);
   double PlaybackRate() const { return mPlaybackRate; }
@@ -92,96 +93,96 @@ public:
   void SilentlySetPlaybackRate(double aPlaybackRate);
   AnimationPlayState PlayState() const;
   virtual Promise* GetReady(ErrorResult& aRv);
   virtual Promise* GetFinished(ErrorResult& aRv);
   virtual void Play(LimitBehavior aLimitBehavior);
   virtual void Pause();
   bool IsRunningOnCompositor() const { return mIsRunningOnCompositor; }
 
-  // Wrapper functions for AnimationPlayer DOM methods when called
+  // Wrapper functions for Animation DOM methods when called
   // from script. We often use the same methods internally and from
   // script but when called from script we (or one of our subclasses) perform
   // extra steps such as flushing style or converting the return type.
   Nullable<double> GetStartTimeAsDouble() const;
   void SetStartTimeAsDouble(const Nullable<double>& aStartTime);
   Nullable<double> GetCurrentTimeAsDouble() const;
   void SetCurrentTimeAsDouble(const Nullable<double>& aCurrentTime,
                               ErrorResult& aRv);
   virtual AnimationPlayState PlayStateFromJS() const { return PlayState(); }
   virtual void PlayFromJS() { Play(LimitBehavior::AutoRewind); }
   // PauseFromJS is currently only here for symmetry with PlayFromJS but
   // in future we will likely have to flush style in
-  // CSSAnimationPlayer::PauseFromJS so we leave it for now.
+  // CSSAnimation::PauseFromJS so we leave it for now.
   void PauseFromJS() { Pause(); }
 
   void SetEffect(KeyframeEffectReadonly* aEffect);
   void Tick();
 
   /**
-   * Set the time to use for starting or pausing a pending player.
+   * Set the time to use for starting or pausing a pending animation.
    *
-   * Typically, when a player is played, it does not start immediately but is
-   * added to a table of pending players on the document of its effect.
+   * Typically, when an animation is played, it does not start immediately but
+   * is added to a table of pending animations on the document of its effect.
    * In the meantime it sets its hold time to the time from which playback
    * should begin.
    *
-   * When the document finishes painting, any pending players in its table
+   * When the document finishes painting, any pending animations in its table
    * are marked as being ready to start by calling StartOnNextTick.
    * The moment when the paint completed is also recorded, converted to a
    * timeline time, and passed to StartOnTick. This is so that when these
-   * players do start, they can be timed from the point when painting
+   * animations do start, they can be timed from the point when painting
    * completed.
    *
-   * After calling TriggerOnNextTick, players remain in the pending state until
-   * the next refresh driver tick. At that time they transition out of the
-   * pending state using the time passed to TriggerOnNextTick as the effective
-   * time at which they resumed.
+   * After calling TriggerOnNextTick, animations remain in the pending state
+   * until the next refresh driver tick. At that time they transition out of
+   * the pending state using the time passed to TriggerOnNextTick as the
+   * effective time at which they resumed.
    *
    * This approach means that any setup time required for performing the
    * initial paint of an animation such as layerization is not deducted from
    * the running time of the animation. Without this we can easily drop the
    * first few frames of an animation, or, on slower devices, the whole
    * animation.
    *
    * Furthermore:
    *
-   * - Starting the player immediately when painting finishes is problematic
-   *   because the start time of the player will be ahead of its timeline
+   * - Starting the animation immediately when painting finishes is problematic
+   *   because the start time of the animation will be ahead of its timeline
    *   (since the timeline time is based on the refresh driver time).
-   *   That's a problem because the player is playing but its timing suggests
-   *   it starts in the future. We could update the timeline to match the start
-   *   time of the player but then we'd also have to update the timing and style
-   *   of all animations connected to that timeline or else be stuck in an
-   *   inconsistent state until the next refresh driver tick.
+   *   That's a problem because the animation is playing but its timing
+   *   suggests it starts in the future. We could update the timeline to match
+   *   the start time of the animation but then we'd also have to update the
+   *   timing and style of all animations connected to that timeline or else be
+   *   stuck in an inconsistent state until the next refresh driver tick.
    *
    * - If we simply use the refresh driver time on its next tick, the lag
    *   between triggering an animation and its effective start is unacceptably
    *   long.
    *
    * For pausing, we apply the same asynchronous approach. This is so that we
    * synchronize with animations that are running on the compositor. Otherwise
    * if the main thread lags behind the compositor there will be a noticeable
    * jump backwards when the main thread takes over. Even though main thread
    * animations could be paused immediately, we do it asynchronously for
    * consistency and so that animations paused together end up in step.
    *
-   * Note that the caller of this method is responsible for removing the player
-   * from any PendingPlayerTracker it may have been added to.
+   * Note that the caller of this method is responsible for removing the
+   * animation from any PendingAnimationTracker it may have been added to.
    */
   void TriggerOnNextTick(const Nullable<TimeDuration>& aReadyTime);
 
-  // Testing only: Start or pause a pending player using the current timeline
+  // Testing only: Start or pause a pending animation using the current timeline
   // time. This is used to support existing tests that expect animations to
   // begin immediately. Ideally we would rewrite the those tests and get rid of
   // this method, but there are a lot of them.
   //
   // As with TriggerOnNextTick, the caller of this method is responsible for
-  // removing the player from any PendingPlayerTracker it may have been added
-  // to.
+  // removing the animation from any PendingAnimationTracker it may have been
+  // added to.
   void TriggerNow();
 
   /**
    * When StartOnNextTick is called, we store the ready time but we don't apply
    * it until the next tick. In the meantime, GetStartTime() will return null.
    *
    * However, if we build layer animations again before the next tick, we
    * should initialize them with the start time that GetStartTime() will return
@@ -248,21 +249,21 @@ public:
   void SetIsRunningOnCompositor() { mIsRunningOnCompositor = true; }
   void ClearIsRunningOnCompositor() { mIsRunningOnCompositor = false; }
 
   // Returns true if this animation does not currently need to update
   // style on the main thread (e.g. because it is empty, or is
   // running on the compositor).
   bool CanThrottle() const;
 
-  // Updates |aStyleRule| with the animation values of this player's effect,
+  // Updates |aStyleRule| with the animation values of this animation's effect,
   // if any.
   // Any properties already contained in |aSetProperties| are not changed. Any
   // properties that are changed are added to |aSetProperties|.
-  // |aNeedsRefreshes| will be set to true if this player expects to update
+  // |aNeedsRefreshes| will be set to true if this animation expects to update
   // the style rule on the next refresh driver tick as well (because it
   // is running and has an effect to sample).
   void ComposeStyle(nsRefPtr<css::AnimValuesStyleRule>& aStyleRule,
                     nsCSSPropertySet& aSetProperties,
                     bool& aNeedsRefreshes);
 
 protected:
   void DoPlay(LimitBehavior aLimitBehavior);
@@ -281,59 +282,59 @@ protected:
   }
 
   void UpdateTiming();
   void UpdateFinishedState(bool aSeekFlag = false);
   void UpdateEffect();
   void FlushStyle() const;
   void PostUpdate();
   /**
-   * Remove this player from the pending player tracker and reset
+   * Remove this animation from the pending animation tracker and reset
    * mPendingState as necessary. The caller is responsible for resolving or
    * aborting the mReady promise as necessary.
    */
   void CancelPendingTasks();
 
   bool IsFinished() const;
 
-  bool IsPossiblyOrphanedPendingPlayer() const;
+  bool IsPossiblyOrphanedPendingAnimation() const;
   StickyTimeDuration EffectEnd() const;
 
   nsIDocument* GetRenderedDocument() const;
   nsPresContext* GetPresContext() const;
   virtual css::CommonAnimationManager* GetAnimationManager() const = 0;
-  AnimationPlayerCollection* GetCollection() const;
+  AnimationCollection* GetCollection() const;
 
   nsRefPtr<DocumentTimeline> mTimeline;
   nsRefPtr<KeyframeEffectReadonly> mEffect;
   // The beginning of the delay period.
   Nullable<TimeDuration> mStartTime; // Timeline timescale
-  Nullable<TimeDuration> mHoldTime;  // Player timescale
+  Nullable<TimeDuration> mHoldTime;  // Animation timescale
   Nullable<TimeDuration> mPendingReadyTime; // Timeline timescale
-  Nullable<TimeDuration> mPreviousCurrentTime; // Player timescale
+  Nullable<TimeDuration> mPreviousCurrentTime; // Animation timescale
   double mPlaybackRate;
 
   // A Promise that is replaced on each call to Play() (and in future Pause())
   // and fulfilled when Play() is successfully completed.
   // This object is lazily created by GetReady.
   // See http://w3c.github.io/web-animations/#current-ready-promise
   nsRefPtr<Promise> mReady;
 
   // A Promise that is resolved when we reach the end of the effect, or
   // 0 when playing backwards. The Promise is replaced if the animation is
   // finished but then a state change makes it not finished.
   // This object is lazily created by GetFinished.
   // See http://w3c.github.io/web-animations/#current-finished-promise
   nsRefPtr<Promise> mFinished;
 
-  // Indicates if the player is in the pending state (and what state it is
+  // Indicates if the animation is in the pending state (and what state it is
   // waiting to enter when it finished pending). We use this rather than
-  // checking if this player is tracked by a PendingPlayerTracker because the
-  // player will continue to be pending even after it has been removed from the
-  // PendingPlayerTracker while it is waiting for the next tick
+  // checking if this animation is tracked by a PendingAnimationTracker because
+  // the animation will continue to be pending even after it has been removed
+  // from the PendingAnimationTracker while it is waiting for the next tick
   // (see TriggerOnNextTick for details).
   enum class PendingState { NotPending, PlayPending, PausePending };
   PendingState mPendingState;
 
   bool mIsRunningOnCompositor;
   // Indicates whether we were in the finished state during our
   // most recent unthrottled sample (our last ComposeStyle call).
   bool mIsPreviousStateFinished; // Spec calls this "previous finished state"
@@ -341,9 +342,9 @@ protected:
   // Indicates that the animation should be exposed in an element's
   // getAnimations() list.
   bool mIsRelevant;
 };
 
 } // namespace dom
 } // namespace mozilla
 
-#endif // mozilla_dom_AnimationPlayer_h
+#endif // mozilla_dom_Animation_h

--- a/dom/animation/KeyframeEffect.cpp
+++ b/dom/animation/KeyframeEffect.cpp
@@ -229,32 +229,32 @@ KeyframeEffectReadonly::ActiveDuration(c
            : StickyTimeDuration::Forever();
   }
   return StickyTimeDuration(
     aTiming.mIterationDuration.MultDouble(aTiming.mIterationCount));
 }
 
 // http://w3c.github.io/web-animations/#in-play
 bool
-KeyframeEffectReadonly::IsInPlay(const AnimationPlayer& aPlayer) const
+KeyframeEffectReadonly::IsInPlay(const Animation& aAnimation) const
 {
   if (IsFinishedTransition() ||
-      aPlayer.PlayState() == AnimationPlayState::Finished) {
+      aAnimation.PlayState() == AnimationPlayState::Finished) {
     return false;
   }
 
   return GetComputedTiming().mPhase == ComputedTiming::AnimationPhase_Active;
 }
 
 // http://w3c.github.io/web-animations/#current
 bool
-KeyframeEffectReadonly::IsCurrent(const AnimationPlayer& aPlayer) const
+KeyframeEffectReadonly::IsCurrent(const Animation& aAnimation) const
 {
   if (IsFinishedTransition() ||
-      aPlayer.PlayState() == AnimationPlayState::Finished) {
+      aAnimation.PlayState() == AnimationPlayState::Finished) {
     return false;
   }
 
   ComputedTiming computedTiming = GetComputedTiming();
   return computedTiming.mPhase == ComputedTiming::AnimationPhase_Before ||
          computedTiming.mPhase == ComputedTiming::AnimationPhase_Active;
 }
 
@@ -320,17 +320,17 @@ KeyframeEffectReadonly::ComposeStyle(
   {
     const AnimationProperty& prop = mProperties[propIdx];
 
     MOZ_ASSERT(prop.mSegments[0].mFromKey == 0.0, "incorrect first from key");
     MOZ_ASSERT(prop.mSegments[prop.mSegments.Length() - 1].mToKey == 1.0,
                "incorrect last to key");
 
     if (aSetProperties.HasProperty(prop.mProperty)) {
-      // Animations are composed by AnimationPlayerCollection by iterating
+      // Animations are composed by AnimationCollection by iterating
       // from the last animation to first. For animations targetting the
       // same property, the later one wins. So if this property is already set,
       // we should not override it.
       continue;
     }
 
     if (!prop.mWinsInCascade) {
       // This isn't the winning declaration, so don't add it to style.

--- a/dom/animation/KeyframeEffect.h
+++ b/dom/animation/KeyframeEffect.h
@@ -295,24 +295,24 @@ public:
   // After transitions finish they need to be retained in order to
   // address the issue described in
   // https://lists.w3.org/Archives/Public/www-style/2015Jan/0444.html .
   // However, finished transitions are ignored for many purposes.
   bool IsFinishedTransition() const {
     return mIsFinishedTransition;
   }
 
-  void SetIsFinishedTransition() {
+  void SetIsFinishedTransition(bool aIsFinished) {
     MOZ_ASSERT(AsTransition(),
                "Calling SetIsFinishedTransition but it's not a transition");
-    mIsFinishedTransition = true;
+    mIsFinishedTransition = aIsFinished;
   }
 
-  bool IsInPlay(const AnimationPlayer& aPlayer) const;
-  bool IsCurrent(const AnimationPlayer& aPlayer) const;
+  bool IsInPlay(const Animation& aAnimation) const;
+  bool IsCurrent(const Animation& aAnimation) const;
   bool IsInEffect() const;
 
   const AnimationProperty*
   GetAnimationOfProperty(nsCSSProperty aProperty) const;
   bool HasAnimationOfProperty(nsCSSProperty aProperty) const {
     return GetAnimationOfProperty(aProperty) != nullptr;
   }
   bool HasAnimationOfProperties(const nsCSSProperty* aProperties,

rename from dom/animation/PendingPlayerTracker.cpp
rename to dom/animation/PendingAnimationTracker.cpp
--- a/dom/animation/PendingPlayerTracker.cpp
+++ b/dom/animation/PendingAnimationTracker.cpp
@@ -1,108 +1,108 @@
 /* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "PendingPlayerTracker.h"
+#include "PendingAnimationTracker.h"
 
 #include "mozilla/dom/DocumentTimeline.h"
 #include "nsIFrame.h"
 #include "nsIPresShell.h"
 
 using namespace mozilla;
 
 namespace mozilla {
 
-NS_IMPL_CYCLE_COLLECTION(PendingPlayerTracker,
+NS_IMPL_CYCLE_COLLECTION(PendingAnimationTracker,
                          mPlayPendingSet,
                          mPausePendingSet,
                          mDocument)
 
-NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(PendingPlayerTracker, AddRef)
-NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(PendingPlayerTracker, Release)
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(PendingAnimationTracker, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(PendingAnimationTracker, Release)
 
 void
-PendingPlayerTracker::AddPending(dom::AnimationPlayer& aPlayer,
-                                 AnimationPlayerSet& aSet)
+PendingAnimationTracker::AddPending(dom::Animation& aAnimation,
+                                    AnimationSet& aSet)
 {
-  aSet.PutEntry(&aPlayer);
+  aSet.PutEntry(&aAnimation);
 
   // Schedule a paint. Otherwise animations that don't trigger a paint by
   // themselves (e.g. CSS animations with an empty keyframes rule) won't
   // start until something else paints.
   EnsurePaintIsScheduled();
 }
 
 void
-PendingPlayerTracker::RemovePending(dom::AnimationPlayer& aPlayer,
-                                    AnimationPlayerSet& aSet)
+PendingAnimationTracker::RemovePending(dom::Animation& aAnimation,
+                                       AnimationSet& aSet)
 {
-  aSet.RemoveEntry(&aPlayer);
+  aSet.RemoveEntry(&aAnimation);
 }
 
 bool
-PendingPlayerTracker::IsWaiting(const dom::AnimationPlayer& aPlayer,
-                                const AnimationPlayerSet& aSet) const
+PendingAnimationTracker::IsWaiting(const dom::Animation& aAnimation,
+                                   const AnimationSet& aSet) const
 {
-  return aSet.Contains(const_cast<dom::AnimationPlayer*>(&aPlayer));
+  return aSet.Contains(const_cast<dom::Animation*>(&aAnimation));
 }
 
 PLDHashOperator
-TriggerPlayerAtTime(nsRefPtrHashKey<dom::AnimationPlayer>* aKey,
+TriggerAnimationAtTime(nsRefPtrHashKey<dom::Animation>* aKey,
                     void* aReadyTime)
 {
-  dom::AnimationPlayer* player = aKey->GetKey();
-  dom::DocumentTimeline* timeline = player->Timeline();
+  dom::Animation* animation = aKey->GetKey();
+  dom::DocumentTimeline* timeline = animation->Timeline();
 
   // When the timeline's refresh driver is under test control, its values
   // have no correspondance to wallclock times so we shouldn't try to convert
   // aReadyTime (which is a wallclock time) to a timeline value. Instead, the
-  // animation player will be started/paused when the refresh driver is next
-  // advanced since this will trigger a call to TriggerPendingPlayersNow.
+  // animation will be started/paused when the refresh driver is next
+  // advanced since this will trigger a call to TriggerPendingAnimationsNow.
   if (timeline->IsUnderTestControl()) {
     return PL_DHASH_NEXT;
   }
 
   Nullable<TimeDuration> readyTime =
     timeline->ToTimelineTime(*static_cast<const TimeStamp*>(aReadyTime));
-  player->TriggerOnNextTick(readyTime);
+  animation->TriggerOnNextTick(readyTime);
 
   return PL_DHASH_REMOVE;
 }
 
 void
-PendingPlayerTracker::TriggerPendingPlayersOnNextTick(const TimeStamp&
+PendingAnimationTracker::TriggerPendingAnimationsOnNextTick(const TimeStamp&
                                                         aReadyTime)
 {
-  mPlayPendingSet.EnumerateEntries(TriggerPlayerAtTime,
+  mPlayPendingSet.EnumerateEntries(TriggerAnimationAtTime,
                                    const_cast<TimeStamp*>(&aReadyTime));
-  mPausePendingSet.EnumerateEntries(TriggerPlayerAtTime,
+  mPausePendingSet.EnumerateEntries(TriggerAnimationAtTime,
                                     const_cast<TimeStamp*>(&aReadyTime));
 }
 
 PLDHashOperator
-TriggerPlayerNow(nsRefPtrHashKey<dom::AnimationPlayer>* aKey, void*)
+TriggerAnimationNow(nsRefPtrHashKey<dom::Animation>* aKey, void*)
 {
   aKey->GetKey()->TriggerNow();
   return PL_DHASH_NEXT;
 }
 
 void
-PendingPlayerTracker::TriggerPendingPlayersNow()
+PendingAnimationTracker::TriggerPendingAnimationsNow()
 {
-  mPlayPendingSet.EnumerateEntries(TriggerPlayerNow, nullptr);
+  mPlayPendingSet.EnumerateEntries(TriggerAnimationNow, nullptr);
   mPlayPendingSet.Clear();
-  mPausePendingSet.EnumerateEntries(TriggerPlayerNow, nullptr);
+  mPausePendingSet.EnumerateEntries(TriggerAnimationNow, nullptr);
   mPausePendingSet.Clear();
 }
 
 void
-PendingPlayerTracker::EnsurePaintIsScheduled()
+PendingAnimationTracker::EnsurePaintIsScheduled()
 {
   if (!mDocument) {
     return;
   }
 
   nsIPresShell* presShell = mDocument->GetShell();
   if (!presShell) {
     return;

rename from dom/animation/PendingPlayerTracker.h
rename to dom/animation/PendingAnimationTracker.h
--- a/dom/animation/PendingPlayerTracker.h
+++ b/dom/animation/PendingAnimationTracker.h
@@ -1,86 +1,83 @@
 /* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef mozilla_dom_PendingPlayerTracker_h
-#define mozilla_dom_PendingPlayerTracker_h
+#ifndef mozilla_dom_PendingAnimationTracker_h
+#define mozilla_dom_PendingAnimationTracker_h
 
-#include "mozilla/dom/AnimationPlayer.h"
+#include "mozilla/dom/Animation.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsIDocument.h"
 #include "nsTHashtable.h"
 
 class nsIFrame;
 
 namespace mozilla {
 
-class PendingPlayerTracker final
+class PendingAnimationTracker final
 {
 public:
-  explicit PendingPlayerTracker(nsIDocument* aDocument)
+  explicit PendingAnimationTracker(nsIDocument* aDocument)
     : mDocument(aDocument)
   { }
 
-  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(PendingPlayerTracker)
-  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(PendingPlayerTracker)
+  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(PendingAnimationTracker)
+  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(PendingAnimationTracker)
 
-  void AddPlayPending(dom::AnimationPlayer& aPlayer)
+  void AddPlayPending(dom::Animation& aAnimation)
   {
-    MOZ_ASSERT(!IsWaitingToPause(aPlayer),
-               "Player is already waiting to pause");
-    AddPending(aPlayer, mPlayPendingSet);
+    MOZ_ASSERT(!IsWaitingToPause(aAnimation),
+               "Animation is already waiting to pause");
+    AddPending(aAnimation, mPlayPendingSet);
   }
-  void RemovePlayPending(dom::AnimationPlayer& aPlayer)
+  void RemovePlayPending(dom::Animation& aAnimation)
   {
-    RemovePending(aPlayer, mPlayPendingSet);
+    RemovePending(aAnimation, mPlayPendingSet);
   }
-  bool IsWaitingToPlay(const dom::AnimationPlayer& aPlayer) const
+  bool IsWaitingToPlay(const dom::Animation& aAnimation) const
   {
-    return IsWaiting(aPlayer, mPlayPendingSet);
+    return IsWaiting(aAnimation, mPlayPendingSet);
   }
 
-  void AddPausePending(dom::AnimationPlayer& aPlayer)
+  void AddPausePending(dom::Animation& aAnimation)
   {
-    MOZ_ASSERT(!IsWaitingToPlay(aPlayer),
-               "Player is already waiting to play");
-    AddPending(aPlayer, mPausePendingSet);
+    MOZ_ASSERT(!IsWaitingToPlay(aAnimation),
+               "Animation is already waiting to play");
+    AddPending(aAnimation, mPausePendingSet);
   }
-  void RemovePausePending(dom::AnimationPlayer& aPlayer)
+  void RemovePausePending(dom::Animation& aAnimation)
   {
-    RemovePending(aPlayer, mPausePendingSet);
+    RemovePending(aAnimation, mPausePendingSet);
   }
-  bool IsWaitingToPause(const dom::AnimationPlayer& aPlayer) const
+  bool IsWaitingToPause(const dom::Animation& aAnimation) const
   {
-    return IsWaiting(aPlayer, mPausePendingSet);
+    return IsWaiting(aAnimation, mPausePendingSet);
   }
 
-  void TriggerPendingPlayersOnNextTick(const TimeStamp& aReadyTime);
-  void TriggerPendingPlayersNow();
-  bool HasPendingPlayers() const {
+  void TriggerPendingAnimationsOnNextTick(const TimeStamp& aReadyTime);
+  void TriggerPendingAnimationsNow();
+  bool HasPendingAnimations() const {
     return mPlayPendingSet.Count() > 0 || mPausePendingSet.Count() > 0;
   }
 
 private:
-  ~PendingPlayerTracker() { }
+  ~PendingAnimationTracker() { }
 
   void EnsurePaintIsScheduled();
 
-  typedef nsTHashtable<nsRefPtrHashKey<dom::AnimationPlayer>>
-    AnimationPlayerSet;
+  typedef nsTHashtable<nsRefPtrHashKey<dom::Animation>> AnimationSet;
 
-  void AddPending(dom::AnimationPlayer& aPlayer,
-                  AnimationPlayerSet& aSet);
-  void RemovePending(dom::AnimationPlayer& aPlayer,
-                     AnimationPlayerSet& aSet);
-  bool IsWaiting(const dom::AnimationPlayer& aPlayer,
-                 const AnimationPlayerSet& aSet) const;
+  void AddPending(dom::Animation& aAnimation, AnimationSet& aSet);
+  void RemovePending(dom::Animation& aAnimation, AnimationSet& aSet);
+  bool IsWaiting(const dom::Animation& aAnimation,
+                 const AnimationSet& aSet) const;
 
-  AnimationPlayerSet mPlayPendingSet;
-  AnimationPlayerSet mPausePendingSet;
+  AnimationSet mPlayPendingSet;
+  AnimationSet mPausePendingSet;
   nsCOMPtr<nsIDocument> mDocument;
 };
 
 } // namespace mozilla
 
-#endif // mozilla_dom_PendingPlayerTracker_h
+#endif // mozilla_dom_PendingAnimationTracker_h

--- a/dom/animation/moz.build
+++ b/dom/animation/moz.build
@@ -3,32 +3,32 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 MOCHITEST_MANIFESTS += ['test/mochitest.ini']
 MOCHITEST_CHROME_MANIFESTS += ['test/chrome.ini']
 
 EXPORTS.mozilla.dom += [
+    'Animation.h',
     'AnimationEffectReadonly.h',
-    'AnimationPlayer.h',
     'AnimationTimeline.h',
     'DocumentTimeline.h',
     'KeyframeEffect.h',
 ]
 
 EXPORTS.mozilla += [
     'AnimationUtils.h',
-    'PendingPlayerTracker.h',
+    'PendingAnimationTracker.h',
 ]
 
 UNIFIED_SOURCES += [
+    'Animation.cpp',
     'AnimationEffectReadonly.cpp',
-    'AnimationPlayer.cpp',
     'AnimationTimeline.cpp',
     'DocumentTimeline.cpp',
     'KeyframeEffect.cpp',
-    'PendingPlayerTracker.cpp',
+    'PendingAnimationTracker.cpp',
 ]
 
 FAIL_ON_WARNINGS = True
 
 FINAL_LIBRARY = 'xul'

rename from dom/animation/test/css-animations/test_animation-player-currenttime.html
rename to dom/animation/test/css-animations/test_animation-currenttime.html
--- a/dom/animation/test/css-animations/test_animation-player-currenttime.html
+++ b/dom/animation/test/css-animations/test_animation-currenttime.html
@@ -188,21 +188,20 @@ function EventWatcher(watchedNode, event
 
   return this;
 }
 
 // The terms used for the naming of the following helper functions refer to
 // terms used in the Web Animations specification for specific phases of an
 // animation. The terms can be found here:
 //
-//   http://w3c.github.io/web-animations/#animation-node-phases-and-states
+//   https://w3c.github.io/web-animations/#animation-effect-phases-and-states
 //
-// Note the distinction between "player start time" and "animation start time".
-// The former is the start of the start delay. The latter is the start of the
-// active interval. (If there is no delay, they are the same.)
+// Note the distinction between the "animation start time" which occurs before
+// the start delay and the start of the active interval which occurs after it.
 
 // Called when currentTime is set to zero (the beginning of the start delay).
 function checkStateOnSettingCurrentTimeToZero(animation)
 {
   // We don't test animation.currentTime since our caller just set it.
 
   assert_equals(animation.playState, 'running',
     'Animation.playState should be "running" at the start of ' +

rename from dom/animation/test/css-animations/test_animation-player-finished.html
rename to dom/animation/test/css-animations/test_animation-finished.html

rename from dom/animation/test/css-animations/test_animation-player-playstate.html
rename to dom/animation/test/css-animations/test_animation-playstate.html

rename from dom/animation/test/css-animations/test_animation-player-ready.html
rename to dom/animation/test/css-animations/test_animation-ready.html

rename from dom/animation/test/css-animations/test_animation-player-starttime.html
rename to dom/animation/test/css-animations/test_animation-starttime.html
--- a/dom/animation/test/css-animations/test_animation-player-starttime.html
+++ b/dom/animation/test/css-animations/test_animation-starttime.html
@@ -188,21 +188,20 @@ function EventWatcher(watchedNode, event
 
   return this;
 }
 
 // The terms used for the naming of the following helper functions refer to
 // terms used in the Web Animations specification for specific phases of an
 // animation. The terms can be found here:
 //
-//   http://w3c.github.io/web-animations/#animation-node-phases-and-states
+//   https://w3c.github.io/web-animations/#animation-effect-phases-and-states
 //
-// Note the distinction between "player start time" and "animation start time".
-// The former is the start of the start delay. The latter is the start of the
-// active interval. (If there is no delay, they are the same.)
+// Note the distinction between the "animation start time" which occurs before
+// the start delay and the start of the active interval which occurs after it.
 
 // Called when the ready Promise's callbacks should happen
 function checkStateOnReadyPromiseResolved(animation)
 {
   assert_less_than_equal(animation.startTime, animation.timeline.currentTime,
     'Animation.startTime should be less than the timeline\'s ' +
     'currentTime on the first paint tick after animation creation');
 

rename from dom/animation/test/css-animations/test_element-get-animation-players.html
rename to dom/animation/test/css-animations/test_element-get-animations.html

rename from dom/animation/test/css-transitions/test_animation-player-currenttime.html
rename to dom/animation/test/css-transitions/test_animation-currenttime.html

rename from dom/animation/test/css-transitions/test_animation-player-ready.html
rename to dom/animation/test/css-transitions/test_animation-ready.html

rename from dom/animation/test/css-transitions/test_animation-player-starttime.html
rename to dom/animation/test/css-transitions/test_animation-starttime.html
--- a/dom/animation/test/css-transitions/test_animation-player-starttime.html
+++ b/dom/animation/test/css-transitions/test_animation-starttime.html
@@ -178,21 +178,20 @@ function EventWatcher(watchedNode, event
 
   return this;
 }
 
 // The terms used for the naming of the following helper functions refer to
 // terms used in the Web Animations specification for specific phases of an
 // animation. The terms can be found here:
 //
-//   http://w3c.github.io/web-animations/#animation-effect-phases-and-states
+//   https://w3c.github.io/web-animations/#animation-effect-phases-and-states
 //
-// Note the distinction between "player start time" and "animation start time".
-// The former is the start of the start delay. The latter is the start of the
-// active interval. (If there is no delay, they are the same.)
+// Note the distinction between the "animation start time" which occurs before
+// the start delay and the start of the active interval which occurs after it.
 
 // Called when the ready Promise's callbacks should happen
 function checkStateOnReadyPromiseResolved(animation)
 {
   assert_less_than_equal(animation.startTime, animation.timeline.currentTime,
     'Animation.startTime should be less than the timeline\'s ' +
     'currentTime on the first paint tick after animation creation');
 

rename from dom/animation/test/css-transitions/test_element-get-animation-players.html
rename to dom/animation/test/css-transitions/test_element-get-animations.html

--- a/dom/animation/test/mochitest.ini
+++ b/dom/animation/test/mochitest.ini
@@ -1,27 +1,27 @@
 [DEFAULT]
 support-files =
   testcommon.js
 
 [css-animations/test_animations-dynamic-changes.html]
 [css-animations/test_animation-pausing.html]
-[css-animations/test_animation-player-currenttime.html]
-[css-animations/test_animation-player-finished.html]
-[css-animations/test_animation-player-playstate.html]
-[css-animations/test_animation-player-ready.html]
-[css-animations/test_animation-player-starttime.html]
+[css-animations/test_animation-currenttime.html]
+[css-animations/test_animation-finished.html]
+[css-animations/test_animation-playstate.html]
+[css-animations/test_animation-ready.html]
+[css-animations/test_animation-starttime.html]
 [css-animations/test_effect-name.html]
 [css-animations/test_effect-target.html]
-[css-animations/test_element-get-animation-players.html]
+[css-animations/test_element-get-animations.html]
 skip-if = buildapp == 'mulet'
 [css-transitions/test_animation-pausing.html]
-[css-transitions/test_animation-player-currenttime.html]
-[css-transitions/test_animation-player-ready.html]
-[css-transitions/test_animation-player-starttime.html]
+[css-transitions/test_animation-currenttime.html]
+[css-transitions/test_animation-ready.html]
+[css-transitions/test_animation-starttime.html]
 [css-transitions/test_effect-name.html]
 [css-transitions/test_effect-target.html]
-[css-transitions/test_element-get-animation-players.html]
+[css-transitions/test_element-get-animations.html]
 skip-if = buildapp == 'mulet'
 [document-timeline/test_document-timeline.html]
 [document-timeline/test_request_animation_frame.html]
 skip-if = buildapp == 'mulet'
 [mozilla/test_deferred_start.html]

--- a/dom/asmjscache/AsmJSCache.cpp
+++ b/dom/asmjscache/AsmJSCache.cpp
@@ -999,17 +999,22 @@ MainProcessRunnable::Run()
       mState = eSendingCacheFile;
       NS_DispatchToMainThread(this);
       return NS_OK;
     }
 
     case eFailedToReadMetadata: {
       MOZ_ASSERT(NS_IsMainThread());
 
-      CacheMiss();
+      if (mOpenMode == eOpenForRead) {
+        CacheMiss();
+        return NS_OK;
+      }
+
+      Fail();
       return NS_OK;
     }
 
     case eSendingMetadataForRead: {
       MOZ_ASSERT(NS_IsMainThread());
       MOZ_ASSERT(mOpenMode == eOpenForRead);
 
       mState = eWaitingToOpenCacheFileForRead;

--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -9,17 +9,17 @@
  * of DOM Core's nsIDOMElement, implements nsIContent, provides
  * utility methods for subclasses, and so forth.
  */
 
 #include "mozilla/dom/ElementInlines.h"
 
 #include "AnimationCommon.h"
 #include "mozilla/DebugOnly.h"
-#include "mozilla/dom/AnimationPlayer.h"
+#include "mozilla/dom/Animation.h"
 #include "mozilla/dom/Attr.h"
 #include "nsDOMAttributeMap.h"
 #include "nsIAtom.h"
 #include "nsIContentInlines.h"
 #include "mozilla/dom/NodeInfo.h"
 #include "nsIDocumentInlines.h"
 #include "nsIDOMNodeList.h"
 #include "nsIDOMDocument.h"
@@ -3181,39 +3181,39 @@ Element::MozRequestFullScreen(JSContext*
 
 void
 Element::MozRequestPointerLock()
 {
   OwnerDoc()->RequestPointerLock(this);
 }
 
 void
-Element::GetAnimations(nsTArray<nsRefPtr<AnimationPlayer> >& aAnimations)
+Element::GetAnimations(nsTArray<nsRefPtr<Animation>>& aAnimations)
 {
   nsIDocument* doc = GetComposedDoc();
   if (doc) {
     doc->FlushPendingNotifications(Flush_Style);
   }
 
   nsIAtom* properties[] = { nsGkAtoms::transitionsProperty,
                             nsGkAtoms::animationsProperty };
   for (size_t propIdx = 0; propIdx < MOZ_ARRAY_LENGTH(properties);
        propIdx++) {
-    AnimationPlayerCollection* collection =
-      static_cast<AnimationPlayerCollection*>(
+    AnimationCollection* collection =
+      static_cast<AnimationCollection*>(
         GetProperty(properties[propIdx]));
     if (!collection) {
       continue;
     }
-    for (size_t playerIdx = 0;
-         playerIdx < collection->mPlayers.Length();
-         playerIdx++) {
-      AnimationPlayer* player = collection->mPlayers[playerIdx];
-      if (player->IsRelevant()) {
-        aAnimations.AppendElement(player);
+    for (size_t animIdx = 0;
+         animIdx < collection->mAnimations.Length();
+         animIdx++) {
+      Animation* anim = collection->mAnimations[animIdx];
+      if (anim->IsRelevant()) {
+        aAnimations.AppendElement(anim);
       }
     }
   }
 }
 
 NS_IMETHODIMP
 Element::GetInnerHTML(nsAString& aInnerHTML)
 {

--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -116,17 +116,17 @@ namespace mozilla {
 class EventChainPostVisitor;
 class EventChainPreVisitor;
 class EventChainVisitor;
 class EventListenerManager;
 class EventStateManager;
 
 namespace dom {
 
-class AnimationPlayer;
+class Animation;
 class Link;
 class UndoManager;
 class DOMRect;
 class DOMRectList;
 class DestinationInsertionPointList;
 
 // IID for the dom::Element interface
 #define NS_ELEMENT_IID \
@@ -803,17 +803,17 @@ public:
   {
     return false;
   }
 
   virtual void SetUndoScope(bool aUndoScope, ErrorResult& aError)
   {
   }
 
-  void GetAnimations(nsTArray<nsRefPtr<AnimationPlayer> >& aAnimations);
+  void GetAnimations(nsTArray<nsRefPtr<Animation>>& aAnimations);
 
   NS_IMETHOD GetInnerHTML(nsAString& aInnerHTML);
   virtual void SetInnerHTML(const nsAString& aInnerHTML, ErrorResult& aError);
   void GetOuterHTML(nsAString& aOuterHTML);
   void SetOuterHTML(const nsAString& aOuterHTML, ErrorResult& aError);
   void InsertAdjacentHTML(const nsAString& aPosition, const nsAString& aText,
                           ErrorResult& aError);
 

--- a/dom/base/nsDOMMutationObserver.cpp
+++ b/dom/base/nsDOMMutationObserver.cpp
@@ -9,17 +9,17 @@
 #include "mozilla/dom/OwningNonNull.h"
 #include "nsError.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsContentUtils.h"
 #include "nsThreadUtils.h"
 #include "nsIDOMMutationEvent.h"
 #include "nsTextFragment.h"
 #include "nsServiceManagerUtils.h"
-#include "mozilla/dom/AnimationPlayer.h"
+#include "mozilla/dom/Animation.h"
 #include "mozilla/dom/KeyframeEffect.h"
 
 nsAutoTArray<nsRefPtr<nsDOMMutationObserver>, 4>*
   nsDOMMutationObserver::sScheduledMutationObservers = nullptr;
 
 nsDOMMutationObserver* nsDOMMutationObserver::sCurrentObserver = nullptr;
 
 uint32_t nsDOMMutationObserver::sMutationLevel = 0;
@@ -320,20 +320,20 @@ nsMutationReceiver::ContentRemoved(nsIDo
 
 void nsMutationReceiver::NodeWillBeDestroyed(const nsINode *aNode)
 {
   NS_ASSERTION(!mParent, "Shouldn't have mParent here!");
   Disconnect(true);
 }
 
 void
-nsAnimationReceiver::RecordAnimationMutation(AnimationPlayer* aPlayer,
+nsAnimationReceiver::RecordAnimationMutation(Animation* aAnimation,
                                              AnimationMutation aMutationType)
 {
-  KeyframeEffectReadonly* effect = aPlayer->GetEffect();
+  KeyframeEffectReadonly* effect = aAnimation->GetEffect();
   if (!effect) {
     return;
   }
 
   Element* animationTarget = effect->GetTarget();
   if (!animationTarget) {
     return;
   }
@@ -345,66 +345,66 @@ nsAnimationReceiver::RecordAnimationMuta
 
   if (nsAutoAnimationMutationBatch::IsBatching()) {
     if (nsAutoAnimationMutationBatch::GetBatchTarget() != animationTarget) {
       return;
     }
 
     switch (aMutationType) {
       case eAnimationMutation_Added:
-        nsAutoAnimationMutationBatch::AnimationAdded(aPlayer);
+        nsAutoAnimationMutationBatch::AnimationAdded(aAnimation);
         break;
       case eAnimationMutation_Changed:
-        nsAutoAnimationMutationBatch::AnimationChanged(aPlayer);
+        nsAutoAnimationMutationBatch::AnimationChanged(aAnimation);
         break;
       case eAnimationMutation_Removed:
-        nsAutoAnimationMutationBatch::AnimationRemoved(aPlayer);
+        nsAutoAnimationMutationBatch::AnimationRemoved(aAnimation);
         break;
     }
 
     nsAutoAnimationMutationBatch::AddObserver(Observer());
     return;
   }
 
   nsDOMMutationRecord* m =
     Observer()->CurrentRecord(nsGkAtoms::animations);
 
   NS_ASSERTION(!m->mTarget, "Wrong target!");
 
   m->mTarget = animationTarget;
 
   switch (aMutationType) {
     case eAnimationMutation_Added:
-      m->mAddedAnimations.AppendElement(aPlayer);
+      m->mAddedAnimations.AppendElement(aAnimation);
       break;
     case eAnimationMutation_Changed:
-      m->mChangedAnimations.AppendElement(aPlayer);
+      m->mChangedAnimations.AppendElement(aAnimation);
       break;
     case eAnimationMutation_Removed:
-      m->mRemovedAnimations.AppendElement(aPlayer);
+      m->mRemovedAnimations.AppendElement(aAnimation);
       break;
   }
 }
 
 void
-nsAnimationReceiver::AnimationAdded(AnimationPlayer* aPlayer)
+nsAnimationReceiver::AnimationAdded(Animation* aAnimation)
 {
-  RecordAnimationMutation(aPlayer, eAnimationMutation_Added);
+  RecordAnimationMutation(aAnimation, eAnimationMutation_Added);
 }
 
 void
-nsAnimationReceiver::AnimationChanged(AnimationPlayer* aPlayer)
+nsAnimationReceiver::AnimationChanged(Animation* aAnimation)
 {
-  RecordAnimationMutation(aPlayer, eAnimationMutation_Changed);
+  RecordAnimationMutation(aAnimation, eAnimationMutation_Changed);
 }
 
 void
-nsAnimationReceiver::AnimationRemoved(AnimationPlayer* aPlayer)
+nsAnimationReceiver::AnimationRemoved(Animation* aAnimation)
 {
-  RecordAnimationMutation(aPlayer, eAnimationMutation_Removed);
+  RecordAnimationMutation(aAnimation, eAnimationMutation_Removed);
 }
 
 NS_IMPL_ISUPPORTS_INHERITED(nsAnimationReceiver, nsMutationReceiver,
                             nsIAnimationObserver)
 
 // Observer
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDOMMutationObserver)
@@ -1015,21 +1015,21 @@ nsAutoAnimationMutationBatch::Done()
 
   for (nsDOMMutationObserver* ob : mObservers) {
     nsRefPtr<nsDOMMutationRecord> m =
       new nsDOMMutationRecord(nsGkAtoms::animations, ob->GetParentObject());
     m->mTarget = mBatchTarget;
 
     for (const Entry& e : mEntries) {
       if (e.mState == eState_Added) {
-        m->mAddedAnimations.AppendElement(e.mPlayer);
+        m->mAddedAnimations.AppendElement(e.mAnimation);
       } else if (e.mState == eState_Removed) {
-        m->mRemovedAnimations.AppendElement(e.mPlayer);
+        m->mRemovedAnimations.AppendElement(e.mAnimation);
       } else if (e.mState == eState_RemainedPresent && e.mChanged) {
-        m->mChangedAnimations.AppendElement(e.mPlayer);
+        m->mChangedAnimations.AppendElement(e.mAnimation);
       }
     }
 
     if (!m->mAddedAnimations.IsEmpty() ||
         !m->mChangedAnimations.IsEmpty() ||
         !m->mRemovedAnimations.IsEmpty()) {
       ob->AppendMutationRecord(m.forget());
       ob->ScheduleForRun();

--- a/dom/base/nsDOMMutationObserver.h
+++ b/dom/base/nsDOMMutationObserver.h
@@ -19,29 +19,29 @@
 #include "nsContentList.h"
 #include "mozilla/dom/Element.h"
 #include "nsClassHashtable.h"
 #include "nsNodeUtils.h"
 #include "nsIDOMMutationEvent.h"
 #include "nsWrapperCache.h"
 #include "mozilla/dom/MutationObserverBinding.h"
 #include "nsIDocument.h"
-#include "mozilla/dom/AnimationPlayer.h"
+#include "mozilla/dom/Animation.h"
 #include "nsIAnimationObserver.h"
 
 class nsDOMMutationObserver;
 using mozilla::dom::MutationObservingInfo;
 
 class nsDOMMutationRecord final : public nsISupports,
                                   public nsWrapperCache
 {
   virtual ~nsDOMMutationRecord() {}
 
 public:
-  typedef nsTArray<nsRefPtr<mozilla::dom::AnimationPlayer>> AnimationPlayerArray;
+  typedef nsTArray<nsRefPtr<mozilla::dom::Animation>> AnimationArray;
 
   nsDOMMutationRecord(nsIAtom* aType, nsISupports* aOwner)
   : mType(aType), mAttrNamespace(NullString()), mPrevValue(NullString()), mOwner(aOwner)
   {
   }
 
   nsISupports* GetParentObject() const
   {
@@ -90,43 +90,43 @@ public:
     aRetVal.SetOwnedString(mAttrNamespace);
   }
 
   void GetOldValue(mozilla::dom::DOMString& aRetVal) const
   {
     aRetVal.SetOwnedString(mPrevValue);
   }
 
-  void GetAddedAnimations(AnimationPlayerArray& aRetVal) const
+  void GetAddedAnimations(AnimationArray& aRetVal) const
   {
     aRetVal = mAddedAnimations;
   }
 
-  void GetRemovedAnimations(AnimationPlayerArray& aRetVal) const
+  void GetRemovedAnimations(AnimationArray& aRetVal) const
   {
     aRetVal = mRemovedAnimations;
   }
 
-  void GetChangedAnimations(AnimationPlayerArray& aRetVal) const
+  void GetChangedAnimations(AnimationArray& aRetVal) const
   {
     aRetVal = mChangedAnimations;
   }
 
   nsCOMPtr<nsINode>             mTarget;
   nsCOMPtr<nsIAtom>             mType;
   nsCOMPtr<nsIAtom>             mAttrName;
   nsString                      mAttrNamespace;
   nsString                      mPrevValue;
   nsRefPtr<nsSimpleContentList> mAddedNodes;
   nsRefPtr<nsSimpleContentList> mRemovedNodes;
   nsCOMPtr<nsINode>             mPreviousSibling;
   nsCOMPtr<nsINode>             mNextSibling;
-  AnimationPlayerArray          mAddedAnimations;
-  AnimationPlayerArray          mRemovedAnimations;
-  AnimationPlayerArray          mChangedAnimations;
+  AnimationArray                mAddedAnimations;
+  AnimationArray                mRemovedAnimations;
+  AnimationArray                mChangedAnimations;
 
   nsRefPtr<nsDOMMutationRecord> mNext;
   nsCOMPtr<nsISupports>         mOwner;
 };
  
 // Base class just prevents direct access to
 // members to make sure we go through getters/setters.
 class nsMutationReceiverBase : public nsStubAnimationObserver
@@ -429,17 +429,17 @@ protected:
 
 private:
   enum AnimationMutation {
     eAnimationMutation_Added,
     eAnimationMutation_Changed,
     eAnimationMutation_Removed
   };
 
-  void RecordAnimationMutation(mozilla::dom::AnimationPlayer* aPlayer,
+  void RecordAnimationMutation(mozilla::dom::Animation* aAnimation,
                                AnimationMutation aMutationType);
 };
 
 #define NS_DOM_MUTATION_OBSERVER_IID \
 { 0x0c3b91f8, 0xcc3b, 0x4b08, \
   { 0x9e, 0xab, 0x07, 0x47, 0xa9, 0xe4, 0x65, 0xb4 } }
 
 class nsDOMMutationObserver final : public nsISupports,
@@ -751,104 +751,104 @@ public:
     sCurrentBatch->mObservers.AppendElement(aObserver);
   }
 
   static nsINode* GetBatchTarget()
   {
     return sCurrentBatch->mBatchTarget;
   }
 
-  static void AnimationAdded(mozilla::dom::AnimationPlayer* aPlayer)
+  static void AnimationAdded(mozilla::dom::Animation* aAnimation)
   {
     if (!IsBatching()) {
       return;
     }
 
-    Entry* entry = sCurrentBatch->FindEntry(aPlayer);
+    Entry* entry = sCurrentBatch->FindEntry(aAnimation);
     if (entry) {
       switch (entry->mState) {
         case eState_RemainedAbsent:
           entry->mState = eState_Added;
           break;
         case eState_Removed:
           entry->mState = eState_RemainedPresent;
           break;
         default:
           NS_NOTREACHED("shouldn't have observed an animation being added "
                         "twice");
       }
     } else {
       entry = sCurrentBatch->mEntries.AppendElement();
-      entry->mPlayer = aPlayer;
+      entry->mAnimation = aAnimation;
       entry->mState = eState_Added;
       entry->mChanged = false;
     }
   }
 
-  static void AnimationChanged(mozilla::dom::AnimationPlayer* aPlayer)
+  static void AnimationChanged(mozilla::dom::Animation* aAnimation)
   {
-    Entry* entry = sCurrentBatch->FindEntry(aPlayer);
+    Entry* entry = sCurrentBatch->FindEntry(aAnimation);
     if (entry) {
       NS_ASSERTION(entry->mState == eState_RemainedPresent ||
                    entry->mState == eState_Added,
                    "shouldn't have observed an animation being changed after "
                    "being removed");
       entry->mChanged = true;
     } else {
       entry = sCurrentBatch->mEntries.AppendElement();
-      entry->mPlayer = aPlayer;
+      entry->mAnimation = aAnimation;
       entry->mState = eState_RemainedPresent;
       entry->mChanged = true;
     }
   }
 
-  static void AnimationRemoved(mozilla::dom::AnimationPlayer* aPlayer)
+  static void AnimationRemoved(mozilla::dom::Animation* aAnimation)
   {
-    Entry* entry = sCurrentBatch->FindEntry(aPlayer);
+    Entry* entry = sCurrentBatch->FindEntry(aAnimation);
     if (entry) {
       switch (entry->mState) {
         case eState_RemainedPresent:
           entry->mState = eState_Removed;
           break;
         case eState_Added:
           entry->mState = eState_RemainedAbsent;
           break;
         default:
           NS_NOTREACHED("shouldn't have observed an animation being removed "
                         "twice");
       }
     } else {
       entry = sCurrentBatch->mEntries.AppendElement();
-      entry->mPlayer = aPlayer;
+      entry->mAnimation = aAnimation;
       entry->mState = eState_Removed;
       entry->mChanged = false;
     }
   }
 
 private:
-  Entry* FindEntry(mozilla::dom::AnimationPlayer* aPlayer)
+  Entry* FindEntry(mozilla::dom::Animation* aAnimation)
   {
     for (Entry& e : mEntries) {
-      if (e.mPlayer == aPlayer) {
+      if (e.mAnimation == aAnimation) {
         return &e;
       }
     }
     return nullptr;
   }
 
   enum State {
     eState_RemainedPresent,
     eState_RemainedAbsent,
     eState_Added,
     eState_Removed
   };
 
   struct Entry
   {
-    nsRefPtr<mozilla::dom::AnimationPlayer> mPlayer;
+    nsRefPtr<mozilla::dom::Animation> mAnimation;
     State mState;
     bool mChanged;
   };
 
   static nsAutoAnimationMutationBatch* sCurrentBatch;
   nsAutoAnimationMutationBatch* mPreviousBatch;
   nsAutoTArray<nsDOMMutationObserver*, 2> mObservers;
   nsTArray<Entry> mEntries;

--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -14,17 +14,17 @@
 #include "nsIDOMEvent.h"
 #include "nsQueryContentEventResult.h"
 #include "nsGlobalWindow.h"
 #include "nsIDocument.h"
 #include "nsFocusManager.h"
 #include "nsFrameManager.h"
 #include "nsRefreshDriver.h"
 #include "mozilla/dom/Touch.h"
-#include "mozilla/PendingPlayerTracker.h"
+#include "mozilla/PendingAnimationTracker.h"
 #include "nsIObjectLoadingContent.h"
 #include "nsFrame.h"
 #include "mozilla/layers/ShadowLayers.h"
 #include "ClientLayerManager.h"
 #include "nsQueryObject.h"
 
 #include "nsIScrollableFrame.h"
 
@@ -2337,26 +2337,25 @@ ComputeAnimationValue(nsCSSProperty aPro
 NS_IMETHODIMP
 nsDOMWindowUtils::AdvanceTimeAndRefresh(int64_t aMilliseconds)
 {
   MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
 
   // Before we advance the time, we should trigger any animations that are
   // waiting to start. This is because there are many tests that call this
   // which expect animations to start immediately. Ideally, we should make
-  // all these tests do an asynchronous wait on the corresponding animation
-  // player's 'ready' promise before continuing. Then we could remove the
-  // special handling here and the code path followed when testing would
-  // more closely match the code path during regular operation. Filed as
-  // bug 1112957.
+  // all these tests do an asynchronous wait on the corresponding animation's
+  // 'ready' promise before continuing. Then we could remove the special
+  // handling here and the code path followed when testing would more closely
+  // match the code path during regular operation. Filed as bug 1112957.
   nsCOMPtr<nsIDocument> doc = GetDocument();
   if (doc) {
-    PendingPlayerTracker* tracker = doc->GetPendingPlayerTracker();
+    PendingAnimationTracker* tracker = doc->GetPendingAnimationTracker();
     if (tracker) {
-      tracker->TriggerPendingPlayersNow();
+      tracker->TriggerPendingAnimationsNow();
     }
   }
 
   nsRefreshDriver* driver = GetPresContext()->RefreshDriver();
   driver->AdvanceTimeAndRefresh(aMilliseconds);
 
   RefPtr<LayerTransactionChild> transaction = GetLayerTransaction();
   if (transaction && transaction->IPCOpen()) {

--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -2014,17 +2014,17 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFirstBaseNodeWithHref)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDOMImplementation)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mImageMaps)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOriginalDocument)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCachedEncoder)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStateObjectCached)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mUndoManager)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentTimeline)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPendingPlayerTracker)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPendingAnimationTracker)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTemplateContentsOwner)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChildrenCollection)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRegistry)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAnonymousContents)
 
   // Traverse all our nsCOMArrays.
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleSheets)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOnDemandBuiltInUASheets)
@@ -2098,17 +2098,17 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ns
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDisplayDocument)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mFirstBaseNodeWithHref)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDOMImplementation)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mImageMaps)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mOriginalDocument)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mCachedEncoder)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mUndoManager)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentTimeline)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mPendingPlayerTracker)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mPendingAnimationTracker)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mTemplateContentsOwner)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mChildrenCollection)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mRegistry)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mMasterDocument)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mImportManager)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mSubImportLinks)
 
   tmp->mParentDocument = nullptr;
@@ -7487,24 +7487,24 @@ nsDocument::GetAnimationController()
   // because they don't get OnPageShow / OnPageHide calls).
   if (!mIsShowing && !mIsBeingUsedAsImage) {
     mAnimationController->OnPageHide();
   }
 
   return mAnimationController;
 }
 
-PendingPlayerTracker*
-nsDocument::GetOrCreatePendingPlayerTracker()
-{
-  if (!mPendingPlayerTracker) {
-    mPendingPlayerTracker = new PendingPlayerTracker(this);
-  }
-
-  return mPendingPlayerTracker;
+PendingAnimationTracker*
+nsDocument::GetOrCreatePendingAnimationTracker()
+{
+  if (!mPendingAnimationTracker) {
+    mPendingAnimationTracker = new PendingAnimationTracker(this);
+  }
+
+  return mPendingAnimationTracker;
 }
 
 /**
  * Retrieve the "direction" property of the document.
  *
  * @lina 01/09/2001
  */
 NS_IMETHODIMP

--- a/dom/base/nsDocument.h
+++ b/dom/base/nsDocument.h
@@ -54,17 +54,17 @@
 #include "nsILoadContext.h"
 #include "nsIProgressEventSink.h"
 #include "nsISecurityEventSink.h"
 #include "nsIChannelEventSink.h"
 #include "imgIRequest.h"
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/EventStates.h"
 #include "mozilla/MemoryReporting.h"
-#include "mozilla/PendingPlayerTracker.h"
+#include "mozilla/PendingAnimationTracker.h"
 #include "mozilla/dom/DOMImplementation.h"
 #include "mozilla/dom/StyleSheetList.h"
 #include "nsDataHashtable.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/Attributes.h"
 #include "nsIDOMXPathEvaluator.h"
 #include "jsfriendapi.h"
 #include "ImportManager.h"
@@ -1045,24 +1045,24 @@ public:
     EnumerateExternalResources(nsSubDocEnumFunc aCallback, void* aData) override;
 
   nsTArray<nsCString> mHostObjectURIs;
 
   // Returns our (lazily-initialized) animation controller.
   // If HasAnimationController is true, this is guaranteed to return non-null.
   nsSMILAnimationController* GetAnimationController() override;
 
-  virtual mozilla::PendingPlayerTracker*
-  GetPendingPlayerTracker() final override
+  virtual mozilla::PendingAnimationTracker*
+  GetPendingAnimationTracker() final override
   {
-    return mPendingPlayerTracker;
+    return mPendingAnimationTracker;
   }
 
-  virtual mozilla::PendingPlayerTracker*
-  GetOrCreatePendingPlayerTracker() override;
+  virtual mozilla::PendingAnimationTracker*
+  GetOrCreatePendingAnimationTracker() override;
 
   void SetImagesNeedAnimating(bool aAnimating) override;
 
   virtual void SuppressEventHandling(SuppressionType aWhat,
                                      uint32_t aIncrease) override;
 
   virtual void UnsuppressEventHandlingAndFireEvents(SuppressionType aWhat,
                                                     bool aFireEvents) override;
@@ -1535,19 +1535,19 @@ protected:
 
   nsCOMArray<nsIStyleSheet> mStyleSheets;
   nsCOMArray<nsIStyleSheet> mOnDemandBuiltInUASheets;
   nsCOMArray<nsIStyleSheet> mAdditionalSheets[SheetTypeCount];
 
   // Array of observers
   nsTObserverArray<nsIDocumentObserver*> mObservers;
 
-  // Tracker for animation players that are waiting to start.
-  // nullptr until GetOrCreatePendingPlayerTracker is called.
-  nsRefPtr<mozilla::PendingPlayerTracker> mPendingPlayerTracker;
+  // Tracker for animations that are waiting to start.
+  // nullptr until GetOrCreatePendingAnimationTracker is called.
+  nsRefPtr<mozilla::PendingAnimationTracker> mPendingAnimationTracker;
 
   // Weak reference to the scope object (aka the script global object)
   // that, unlike mScriptGlobalObject, is never unset once set. This
   // is a weak reference to avoid leaks due to circular references.
   nsWeakPtr mScopeObject;
 
   // Stack of full-screen elements. When we request full-screen we push the
   // full-screen element onto this stack, and when we cancel full-screen we

--- a/dom/base/nsIAnimationObserver.h
+++ b/dom/base/nsIAnimationObserver.h
@@ -4,59 +4,59 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef nsIAnimationObserver_h___
 #define nsIAnimationObserver_h___
 
 #include "nsIMutationObserver.h"
 
 namespace mozilla {
 namespace dom {
-class AnimationPlayer;
+class Animation;
 }
 }
 
 #define NS_IANIMATION_OBSERVER_IID \
 { 0xed025fc7, 0xdeda, 0x48b9, \
   { 0x9c, 0x35, 0xf2, 0xb6, 0x1e, 0xeb, 0xd0, 0x8d } }
 
 class nsIAnimationObserver : public nsIMutationObserver
 {
 public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IANIMATION_OBSERVER_IID)
 
-  virtual void AnimationAdded(mozilla::dom::AnimationPlayer* aPlayer) = 0;
-  virtual void AnimationChanged(mozilla::dom::AnimationPlayer* aPlayer) = 0;
-  virtual void AnimationRemoved(mozilla::dom::AnimationPlayer* aPlayer) = 0;
+  virtual void AnimationAdded(mozilla::dom::Animation* aAnimation) = 0;
+  virtual void AnimationChanged(mozilla::dom::Animation* aAnimation) = 0;
+  virtual void AnimationRemoved(mozilla::dom::Animation* aAnimation) = 0;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsIAnimationObserver, NS_IANIMATION_OBSERVER_IID)
 
 #define NS_DECL_NSIANIMATIONOBSERVER_ANIMATIONADDED                          \
-    virtual void AnimationAdded(mozilla::dom::AnimationPlayer* aPlayer)      \
+    virtual void AnimationAdded(mozilla::dom::Animation* aAnimation)         \
       override;
 
 #define NS_DECL_NSIANIMATIONOBSERVER_ANIMATIONCHANGED                        \
-    virtual void AnimationChanged(mozilla::dom::AnimationPlayer* aPlayer)    \
+    virtual void AnimationChanged(mozilla::dom::Animation* aAnimation)       \
       override;
 
 #define NS_DECL_NSIANIMATIONOBSERVER_ANIMATIONREMOVED                        \
-    virtual void AnimationRemoved(mozilla::dom::AnimationPlayer* aPlayer)    \
+    virtual void AnimationRemoved(mozilla::dom::Animation* aAnimation)       \
       override;
 
 #define NS_IMPL_NSIANIMATIONOBSERVER_STUB(class_)                            \
 void                                                                         \
-class_::AnimationAdded(mozilla::dom::AnimationPlayer* aPlayer)               \
+class_::AnimationAdded(mozilla::dom::Animation* aAnimation)                  \
 {                                                                            \
 }                                                                            \
 void                                                                         \
-class_::AnimationChanged(mozilla::dom::AnimationPlayer* aPlayer)             \
+class_::AnimationChanged(mozilla::dom::Animation* aAnimation)                \
 {                                                                            \
 }                                                                            \
 void                                                                         \
-class_::AnimationRemoved(mozilla::dom::AnimationPlayer* aPlayer)             \
+class_::AnimationRemoved(mozilla::dom::Animation* aAnimation)                \
 {                                                                            \
 }                                                                            \
 NS_IMPL_NSIMUTATIONOBSERVER_CORE_STUB(class_)                                \
 NS_IMPL_NSIMUTATIONOBSERVER_CONTENT(class_)
 
 #define NS_DECL_NSIANIMATIONOBSERVER                                         \
     NS_DECL_NSIANIMATIONOBSERVER_ANIMATIONADDED                              \
     NS_DECL_NSIANIMATIONOBSERVER_ANIMATIONCHANGED                            \

--- a/dom/base/nsIDocument.h
+++ b/dom/base/nsIDocument.h
@@ -83,17 +83,17 @@ class nsDOMCaretPosition;
 class nsViewportInfo;
 class nsIGlobalObject;
 struct nsCSSSelectorList;
 
 namespace mozilla {
 class CSSStyleSheet;
 class ErrorResult;
 class EventStates;
-class PendingPlayerTracker;
+class PendingAnimationTracker;
 class SVGAttrAnimationRuleProcessor;
 
 namespace css {
 class Loader;
 class ImageLoader;
 } // namespace css
 
 namespace gfx {
@@ -1832,26 +1832,27 @@ public:
   // will have a non-null return value.
   bool HasAnimationController()  { return !!mAnimationController; }
 
   // Getter for this document's SMIL Animation Controller. Performs lazy
   // initialization, if this document supports animation and if
   // mAnimationController isn't yet initialized.
   virtual nsSMILAnimationController* GetAnimationController() = 0;
 
-  // Gets the tracker for animation players that are waiting to start.
-  // Returns nullptr if there is no pending player tracker for this document
+  // Gets the tracker for animations that are waiting to start.
+  // Returns nullptr if there is no pending animation tracker for this document
   // which will be the case if there have never been any CSS animations or
   // transitions on elements in the document.
-  virtual mozilla::PendingPlayerTracker* GetPendingPlayerTracker() = 0;
-
-  // Gets the tracker for animation players that are waiting to start and
+  virtual mozilla::PendingAnimationTracker* GetPendingAnimationTracker() = 0;
+
+  // Gets the tracker for animations that are waiting to start and
   // creates it if it doesn't already exist. As a result, the return value
   // will never be nullptr.
-  virtual mozilla::PendingPlayerTracker* GetOrCreatePendingPlayerTracker() = 0;
+  virtual mozilla::PendingAnimationTracker*
+  GetOrCreatePendingAnimationTracker() = 0;
 
   // Makes the images on this document capable of having their animation
   // active or suspended. An Image will animate as long as at least one of its
   // owning Documents needs it to animate; otherwise it can suspend.
   virtual void SetImagesNeedAnimating(bool aAnimating) = 0;
 
   enum SuppressionType {
     eAnimationsOnly = 0x1,

--- a/dom/base/nsINode.h
+++ b/dom/base/nsINode.h
@@ -1966,17 +1966,20 @@ public:
 #undef EVENT
 
 protected:
   static bool Traverse(nsINode *tmp, nsCycleCollectionTraversalCallback &cb);
   static void Unlink(nsINode *tmp);
 
   nsRefPtr<mozilla::dom::NodeInfo> mNodeInfo;
 
-  nsINode* mParent;
+  // mParent is an owning ref most of the time, except for the case of document
+  // nodes, so it cannot be represented by nsCOMPtr, so mark is as
+  // MOZ_OWNING_REF.
+  nsINode* MOZ_OWNING_REF mParent;
 
 private:
   // Boolean flags.
   uint32_t mBoolFlags;
 
 protected:
   // These references are non-owning and safe, as they are managed by
   // nsAttrAndChildArray.

--- a/dom/base/nsNodeUtils.cpp
+++ b/dom/base/nsNodeUtils.cpp
@@ -19,17 +19,17 @@
 #include "nsPIDOMWindow.h"
 #include "nsDocument.h"
 #ifdef MOZ_XUL
 #include "nsXULElement.h"
 #endif
 #include "nsBindingManager.h"
 #include "nsGenericHTMLElement.h"
 #include "mozilla/Assertions.h"
-#include "mozilla/dom/AnimationPlayer.h"
+#include "mozilla/dom/Animation.h"
 #include "mozilla/dom/HTMLImageElement.h"
 #include "mozilla/dom/HTMLMediaElement.h"
 #include "mozilla/dom/KeyframeEffect.h"
 #include "nsWrapperCacheInlines.h"
 #include "nsObjectLoadingContent.h"
 #include "nsDOMMutationObserver.h"
 #include "mozilla/dom/BindingUtils.h"
 #include "mozilla/dom/HTMLTemplateElement.h"
@@ -211,19 +211,19 @@ nsNodeUtils::ContentRemoved(nsINode* aCo
   }
 
   IMPL_MUTATION_NOTIFICATION(ContentRemoved, aContainer,
                              (document, container, aChild, aIndexInContainer,
                               aPreviousSibling));
 }
 
 static inline Element*
-GetTarget(AnimationPlayer* aPlayer)
+GetTarget(Animation* aAnimation)
 {
-  KeyframeEffectReadonly* effect = aPlayer->GetEffect();
+  KeyframeEffectReadonly* effect = aAnimation->GetEffect();
   if (!effect) {
     return nullptr;
   }
 
   Element* target;
   nsCSSPseudoElements::Type pseudoType;
   effect->GetTarget(target, pseudoType);
 
@@ -233,54 +233,54 @@ GetTarget(AnimationPlayer* aPlayer)
   if (pseudoType != nsCSSPseudoElements::ePseudo_NotPseudoElement) {
     return nullptr;
   }
 
   return effect->GetTarget();
 }
 
 void
-nsNodeUtils::AnimationAdded(AnimationPlayer* aPlayer)
+nsNodeUtils::AnimationAdded(Animation* aAnimation)
 {
-  Element* target = GetTarget(aPlayer);
+  Element* target = GetTarget(aAnimation);
   if (!target) {
     return;
   }
   nsIDocument* doc = target->OwnerDoc();
 
   if (doc->MayHaveAnimationObservers()) {
-    IMPL_ANIMATION_NOTIFICATION(AnimationAdded, target, (aPlayer));
+    IMPL_ANIMATION_NOTIFICATION(AnimationAdded, target, (aAnimation));
   }
 }
 
 void
-nsNodeUtils::AnimationChanged(AnimationPlayer* aPlayer)
+nsNodeUtils::AnimationChanged(Animation* aAnimation)
 {
-  Element* target = GetTarget(aPlayer);
+  Element* target = GetTarget(aAnimation);
   if (!target) {
     return;
   }
   nsIDocument* doc = target->OwnerDoc();
 
   if (doc->MayHaveAnimationObservers()) {
-    IMPL_ANIMATION_NOTIFICATION(AnimationChanged, target, (aPlayer));
+    IMPL_ANIMATION_NOTIFICATION(AnimationChanged, target, (aAnimation));
   }
 }
 
 void
-nsNodeUtils::AnimationRemoved(AnimationPlayer* aPlayer)
+nsNodeUtils::AnimationRemoved(Animation* aAnimation)
 {
-  Element* target = GetTarget(aPlayer);
+  Element* target = GetTarget(aAnimation);
   if (!target) {
     return;
   }
   nsIDocument* doc = target->OwnerDoc();
 
   if (doc->MayHaveAnimationObservers()) {
-    IMPL_ANIMATION_NOTIFICATION(AnimationRemoved, target, (aPlayer));
+    IMPL_ANIMATION_NOTIFICATION(AnimationRemoved, target, (aAnimation));
   }
 }
 
 void
 nsNodeUtils::LastRelease(nsINode* aNode)
 {
   nsINode::nsSlots* slots = aNode->GetExistingSlots();
   if (slots) {

--- a/dom/base/nsNodeUtils.h
+++ b/dom/base/nsNodeUtils.h
@@ -13,17 +13,17 @@
 
 struct CharacterDataChangeInfo;
 class nsIVariant;
 class nsIDOMNode;
 template<class E> class nsCOMArray;
 class nsCycleCollectionTraversalCallback;
 namespace mozilla {
 namespace dom {
-class AnimationPlayer;
+class Animation;
 }
 }
 
 class nsNodeUtils
 {
 public:
   /**
    * Send CharacterDataWillChange notifications to nsIMutationObservers.
@@ -122,19 +122,19 @@ public:
     if (slots && !slots->mMutationObservers.IsEmpty()) {
       NS_OBSERVER_ARRAY_NOTIFY_OBSERVERS(slots->mMutationObservers,
                                          nsIMutationObserver,
                                          ParentChainChanged,
                                          (aContent));
     }
   }
 
-  static void AnimationAdded(mozilla::dom::AnimationPlayer* aPlayer);
-  static void AnimationChanged(mozilla::dom::AnimationPlayer* aPlayer);
-  static void AnimationRemoved(mozilla::dom::AnimationPlayer* aPlayer);
+  static void AnimationAdded(mozilla::dom::Animation* aAnimation);
+  static void AnimationChanged(mozilla::dom::Animation* aAnimation);
+  static void AnimationRemoved(mozilla::dom::Animation* aAnimation);
 
   /**
    * To be called when reference count of aNode drops to zero.
    * @param aNode The node which is going to be deleted.
    */
   static void LastRelease(nsINode* aNode);
 
   /**

--- a/dom/base/nsObjectLoadingContent.cpp
+++ b/dom/base/nsObjectLoadingContent.cpp
@@ -2728,18 +2728,20 @@ nsObjectLoadingContent::GetPrintFrame(ns
 
 NS_IMETHODIMP
 nsObjectLoadingContent::PluginDestroyed()
 {
   // Called when our plugin is destroyed from under us, usually when reloading
   // plugins in plugin host. Invalidate instance owner / prototype but otherwise
   // don't take any action.
   TeardownProtoChain();
-  mInstanceOwner->Destroy();
-  mInstanceOwner = nullptr;
+  if (mInstanceOwner) {
+    mInstanceOwner->Destroy();
+    mInstanceOwner = nullptr;
+  }
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsObjectLoadingContent::PluginCrashed(nsIPluginTag* aPluginTag,
                                       const nsAString& pluginDumpID,
                                       const nsAString& browserDumpID,
                                       bool submittedCrashReport)

--- a/dom/bindings/Codegen.py
+++ b/dom/bindings/Codegen.py
@@ -8599,16 +8599,36 @@ class CGStaticMethodJitinfo(CGGeneric):
             "  JSJitInfo::AliasEverything, JSVAL_TYPE_MISSING, false, false,\n"
             "  false, false, 0\n"
             "};\n" %
             (IDLToCIdentifier(method.identifier.name),
              CppKeywords.checkMethodName(
                  IDLToCIdentifier(method.identifier.name))))
 
 
+class CGMethodIdentityTest(CGAbstractMethod):
+    """
+    A class to generate a method-identity test for a given IDL operation.
+    """
+    def __init__(self, descriptor, method):
+        self.method = method
+        name = "Is%sMethod" % MakeNativeName(method.identifier.name)
+        CGAbstractMethod.__init__(self, descriptor, name, 'bool',
+                                  [Argument('JS::Handle<JSObject*>', 'aObj')])
+
+    def definition_body(self):
+        return dedent(
+            """
+            MOZ_ASSERT(aObj);
+            return js::IsFunctionObject(aObj) &&
+                   js::FunctionObjectIsNative(aObj) &&
+                   FUNCTION_VALUE_TO_JITINFO(JS::ObjectValue(*aObj)) == &%s_methodinfo;
+            """ % IDLToCIdentifier(self.method.identifier.name))
+
+
 def getEnumValueName(value):
     # Some enum values can be empty strings.  Others might have weird
     # characters in them.  Deal with the former by returning "_empty",
     # deal with possible name collisions from that by throwing if the
     # enum value is actually "_empty", and throw on any value
     # containing non-ASCII chars for now. Replace all chars other than
     # [0-9A-Za-z_] with '_'.
     if re.match("[^\x20-\x7E]", value):
@@ -11195,16 +11215,18 @@ class CGDescriptor(CGThing):
                     elif descriptor.interface.hasInterfacePrototypeObject():
                         specializedMethod = CGSpecializedMethod(descriptor, m)
                         cgThings.append(specializedMethod)
                         if m.returnsPromise():
                             cgThings.append(CGMethodPromiseWrapper(descriptor, specializedMethod))
                         cgThings.append(CGMemberJITInfo(descriptor, m))
                         if props.isCrossOriginMethod:
                             crossOriginMethods.add(m.identifier.name)
+                        if m.getExtendedAttribute("MethodIdentityTestable"):
+                            cgThings.append(CGMethodIdentityTest(descriptor, m))
             elif m.isAttr():
                 if m.stringifier:
                     raise TypeError("Stringifier attributes not supported yet. "
                                     "See bug 824857.\n"
                                     "%s" % m.location)
                 if m.isStatic():
                     assert descriptor.interface.hasInterfaceObject()
                     cgThings.append(CGStaticGetter(descriptor, m))

--- a/dom/bindings/parser/WebIDL.py
+++ b/dom/bindings/parser/WebIDL.py
@@ -2771,17 +2771,17 @@ class IDLBuiltinType(IDLType):
                self._typeTag == IDLBuiltinType.Types.unrestricted_double
 
     def isUnrestricted(self):
         assert self.isFloat()
         return self._typeTag == IDLBuiltinType.Types.unrestricted_float or \
                self._typeTag == IDLBuiltinType.Types.unrestricted_double
 
     def isSerializable(self):
-        return self.isPrimitive() or self.isDOMString() or self.isDate()
+        return self.isPrimitive() or self.isString() or self.isDate()
 
     def includesRestrictedFloat(self):
         return self.isFloat() and not self.isUnrestricted()
 
     def tag(self):
         return IDLBuiltinType.TagLookup[self._typeTag]
 
     def isDistinguishableFrom(self, other):
@@ -4158,17 +4158,18 @@ class IDLMethod(IDLInterfaceMember, IDLS
               identifier == "NewObject" or
               identifier == "ChromeOnly" or
               identifier == "UnsafeInPrerendering" or
               identifier == "Pref" or
               identifier == "Deprecated" or
               identifier == "Func" or
               identifier == "AvailableIn" or
               identifier == "CheckPermissions" or
-              identifier == "BinaryName"):
+              identifier == "BinaryName" or
+              identifier == "MethodIdentityTestable"):
             # Known attributes that we don't need to do anything with here
             pass
         else:
             raise WebIDLError("Unknown extended attribute %s on method" % identifier,
                               [attr.location])
         IDLInterfaceMember.handleExtendedAttribute(self, attr)
 
     def returnsPromise(self):

--- a/dom/cache/Context.cpp
+++ b/dom/cache/Context.cpp
@@ -696,68 +696,77 @@ Context::ThreadsafeHandle::ContextDestro
   MOZ_ASSERT(!mStrongRef);
   MOZ_ASSERT(mWeakRef);
   MOZ_ASSERT(mWeakRef == aContext);
   mWeakRef = nullptr;
 }
 
 // static
 already_AddRefed<Context>
-Context::Create(Manager* aManager, Action* aQuotaIOThreadAction)
+Context::Create(Manager* aManager, Action* aQuotaIOThreadAction,
+                Context* aOldContext)
 {
   nsRefPtr<Context> context = new Context(aManager);
 
+  // Do this here to avoid doing an AddRef() in the constructor
   context->mInitRunnable = new QuotaInitRunnable(context, aManager,
                                                  aQuotaIOThreadAction);
-  nsresult rv = context->mInitRunnable->Dispatch();
-  if (NS_FAILED(rv)) {
-    // Shutdown must be delayed until all Contexts are destroyed.  Shutdown
-    // must also prevent any new Contexts from being constructed.  Crash
-    // for this invariant violation.
-    MOZ_CRASH("Failed to dispatch QuotaInitRunnable.");
+
+  if (aOldContext) {
+    aOldContext->SetNextContext(context);
+  } else {
+    context->Start();
   }
 
   return context.forget();
 }
 
 Context::Context(Manager* aManager)
   : mManager(aManager)
-  , mState(STATE_CONTEXT_INIT)
+  , mState(STATE_CONTEXT_PREINIT)
 {
   MOZ_ASSERT(mManager);
 }
 
 void
 Context::Dispatch(nsIEventTarget* aTarget, Action* aAction)
 {
   NS_ASSERT_OWNINGTHREAD(Context);
   MOZ_ASSERT(aTarget);
   MOZ_ASSERT(aAction);
 
   MOZ_ASSERT(mState != STATE_CONTEXT_CANCELED);
   if (mState == STATE_CONTEXT_CANCELED) {
     return;
-  } else if (mState == STATE_CONTEXT_INIT) {
+  } else if (mState == STATE_CONTEXT_INIT ||
+             mState == STATE_CONTEXT_PREINIT) {
     PendingAction* pending = mPendingActions.AppendElement();
     pending->mTarget = aTarget;
     pending->mAction = aAction;
     return;
   }
 
   MOZ_ASSERT(STATE_CONTEXT_READY);
   DispatchAction(aTarget, aAction);
 }
 
 void
 Context::CancelAll()
 {
   NS_ASSERT_OWNINGTHREAD(Context);
 
-  if (mInitRunnable) {
-    MOZ_ASSERT(mState == STATE_CONTEXT_INIT);
+  // In PREINIT state we have not dispatch the init runnable yet.  Just
+  // forget it.
+  if (mState == STATE_CONTEXT_PREINIT) {
+    mInitRunnable = nullptr;
+
+  // In INIT state we have dispatched the runnable, but not received the
+  // async completion yet.  Cancel the runnable, but don't forget about it
+  // until we get OnQuotaInit() callback.
+  } else if (mState == STATE_CONTEXT_INIT) {
     mInitRunnable->Cancel();
   }
 
   mState = STATE_CONTEXT_CANCELED;
   mPendingActions.Clear();
   {
     ActivityList::ForwardIterator iter(mActivityList);
     while (iter.HasMore()) {
@@ -818,16 +827,44 @@ Context::~Context()
   NS_ASSERT_OWNINGTHREAD(Context);
   MOZ_ASSERT(mManager);
 
   if (mThreadsafeHandle) {
     mThreadsafeHandle->ContextDestroyed(this);
   }
 
   mManager->RemoveContext(this);
+
+  if (mNextContext) {
+    mNextContext->Start();
+  }
+}
+
+void
+Context::Start()
+{
+  NS_ASSERT_OWNINGTHREAD(Context);
+
+  // Previous context closing delayed our start, but then we were canceled.
+  // In this case, just do nothing here.
+  if (mState == STATE_CONTEXT_CANCELED) {
+    MOZ_ASSERT(!mInitRunnable);
+    return;
+  }
+
+  MOZ_ASSERT(mState == STATE_CONTEXT_PREINIT);
+  mState = STATE_CONTEXT_INIT;
+
+  nsresult rv = mInitRunnable->Dispatch();
+  if (NS_FAILED(rv)) {
+    // Shutdown must be delayed until all Contexts are destroyed.  Shutdown
+    // must also prevent any new Contexts from being constructed.  Crash
+    // for this invariant violation.
+    MOZ_CRASH("Failed to dispatch QuotaInitRunnable.");
+  }
 }
 
 void
 Context::DispatchAction(nsIEventTarget* aTarget, Action* aAction)
 {
   NS_ASSERT_OWNINGTHREAD(Context);
 
   nsRefPtr<ActionRunnable> runnable =
@@ -900,11 +937,20 @@ Context::CreateThreadsafeHandle()
   NS_ASSERT_OWNINGTHREAD(Context);
   if (!mThreadsafeHandle) {
     mThreadsafeHandle = new ThreadsafeHandle(this);
   }
   nsRefPtr<ThreadsafeHandle> ref = mThreadsafeHandle;
   return ref.forget();
 }
 
+void
+Context::SetNextContext(Context* aNextContext)
+{
+  NS_ASSERT_OWNINGTHREAD(Context);
+  MOZ_ASSERT(aNextContext);
+  MOZ_ASSERT(!mNextContext);
+  mNextContext = aNextContext;
+}
+
 } // namespace cache
 } // namespace dom
 } // namespace mozilla

--- a/dom/cache/Context.h
+++ b/dom/cache/Context.h
@@ -106,17 +106,17 @@ public:
     virtual void Cancel() = 0;
     virtual bool MatchesCacheId(CacheId aCacheId) const = 0;
   };
 
   // Create a Context attached to the given Manager.  The given Action
   // will run on the QuotaManager IO thread.  Note, this Action must
   // be execute synchronously.
   static already_AddRefed<Context>
-  Create(Manager* aManager, Action* aQuotaIOThreadAction);
+  Create(Manager* aManager, Action* aQuotaIOThreadAction, Context* aOldContext);
 
   // Execute given action on the target once the quota manager has been
   // initialized.
   //
   // Only callable from the thread that created the Context.
   void Dispatch(nsIEventTarget* aTarget, Action* aAction);
 
   // Cancel any Actions running or waiting to run.  This should allow the
@@ -152,36 +152,41 @@ public:
   }
 
 private:
   class QuotaInitRunnable;
   class ActionRunnable;
 
   enum State
   {
+    STATE_CONTEXT_PREINIT,
     STATE_CONTEXT_INIT,
     STATE_CONTEXT_READY,
     STATE_CONTEXT_CANCELED
   };
 
   struct PendingAction
   {
     nsCOMPtr<nsIEventTarget> mTarget;
     nsRefPtr<Action> mAction;
   };
 
   explicit Context(Manager* aManager);
   ~Context();
+  void Start();
   void DispatchAction(nsIEventTarget* aTarget, Action* aAction);
   void OnQuotaInit(nsresult aRv, const QuotaInfo& aQuotaInfo,
                    nsMainThreadPtrHandle<OfflineStorage>& aOfflineStorage);
 
   already_AddRefed<ThreadsafeHandle>
   CreateThreadsafeHandle();
 
+  void
+  SetNextContext(Context* aNextContext);
+
   nsRefPtr<Manager> mManager;
   State mState;
   QuotaInfo mQuotaInfo;
   nsRefPtr<QuotaInitRunnable> mInitRunnable;
   nsTArray<PendingAction> mPendingActions;
 
   // Weak refs since activites must remove themselves from this list before
   // being destroyed by calling RemoveActivity().
@@ -189,16 +194,17 @@ private:
   ActivityList mActivityList;
 
   // The ThreadsafeHandle may have a strong ref back to us.  This creates
   // a ref-cycle that keeps the Context alive.  The ref-cycle is broken
   // when ThreadsafeHandle::AllowToClose() is called.
   nsRefPtr<ThreadsafeHandle> mThreadsafeHandle;
 
   nsMainThreadPtrHandle<OfflineStorage> mOfflineStorage;
+  nsRefPtr<Context> mNextContext;
 
 public:
   NS_INLINE_DECL_REFCOUNTING(cache::Context)
 };
 
 } // namespace cache
 } // namespace dom
 } // namespace mozilla

--- a/dom/cache/Manager.cpp
+++ b/dom/cache/Manager.cpp
@@ -152,42 +152,47 @@ public:
     nsRefPtr<Manager> ref = Get(aManagerId);
     if (!ref) {
       // TODO: replace this with a thread pool (bug 1119864)
       nsCOMPtr<nsIThread> ioThread;
       rv = NS_NewNamedThread("DOMCacheThread", getter_AddRefs(ioThread));
       if (NS_WARN_IF(NS_FAILED(rv))) { return rv; }
 
       ref = new Manager(aManagerId, ioThread);
-      ref->Init();
+
+      // There may be an old manager for this origin in the process of
+      // cleaning up.  We need to tell the new manager about this so
+      // that it won't actually start until the old manager is done.
+      nsRefPtr<Manager> oldManager = Get(aManagerId, Closing);
+      ref->Init(oldManager);
 
       MOZ_ASSERT(!sFactory->mManagerList.Contains(ref));
       sFactory->mManagerList.AppendElement(ref);
     }
 
     ref.forget(aManagerOut);
 
     return NS_OK;
   }
 
   static already_AddRefed<Manager>
-  Get(ManagerId* aManagerId)
+  Get(ManagerId* aManagerId, State aState = Open)
   {
     mozilla::ipc::AssertIsOnBackgroundThread();
 
     nsresult rv = MaybeCreateInstance();
     if (NS_WARN_IF(NS_FAILED(rv))) { return nullptr; }
 
-    ManagerList::ForwardIterator iter(sFactory->mManagerList);
+    // Iterate in reverse to find the most recent, matching Manager.  This
+    // is important when looking for a Closing Manager.  If a new Manager
+    // chains to an old Manager we want it to be the most recent one.
+    ManagerList::BackwardIterator iter(sFactory->mManagerList);
     while (iter.HasMore()) {
       nsRefPtr<Manager> manager = iter.GetNext();
-      // If there is an invalid Manager finishing up and a new Manager
-      // is created for the same origin, then the new Manager will
-      // be blocked until QuotaManager finishes clearing the origin.
-      if (!manager->IsClosing() && *manager->mManagerId == *aManagerId) {
+      if (aState == manager->GetState() && *manager->mManagerId == *aManagerId) {
         return manager.forget();
       }
     }
 
     return nullptr;
   }
 
   static void
@@ -1445,39 +1450,39 @@ Manager::RemoveContext(Context* aContext
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
   MOZ_ASSERT(mContext);
   MOZ_ASSERT(mContext == aContext);
 
   // Whether the Context destruction was triggered from the Manager going
   // idle or the underlying storage being invalidated, we should know we
   // are closing before the Conext is destroyed.
-  MOZ_ASSERT(mClosing);
+  MOZ_ASSERT(mState == Closing);
 
   mContext = nullptr;
 
   // Once the context is gone, we can immediately remove ourself from the
   // Factory list.  We don't need to block shutdown by staying in the list
   // any more.
   Factory::Remove(this);
 }
 
 void
 Manager::NoteClosing()
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
   // This can be called more than once legitimately through different paths.
-  mClosing = true;
+  mState = Closing;
 }
 
-bool
-Manager::IsClosing() const
+Manager::State
+Manager::GetState() const
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
-  return mClosing;
+  return mState;
 }
 
 void
 Manager::AddRefCacheId(CacheId aCacheId)
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
   for (uint32_t i = 0; i < mCacheIdRefs.Length(); ++i) {
     if (mCacheIdRefs[i].mCacheId == aCacheId) {
@@ -1588,17 +1593,17 @@ void
 Manager::ExecuteCacheOp(Listener* aListener, CacheId aCacheId,
                         const CacheOpArgs& aOpArgs)
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
   MOZ_ASSERT(aListener);
   MOZ_ASSERT(aOpArgs.type() != CacheOpArgs::TCacheAddAllArgs);
   MOZ_ASSERT(aOpArgs.type() != CacheOpArgs::TCachePutAllArgs);
 
-  if (mClosing) {
+  if (mState == Closing) {
     aListener->OnOpComplete(ErrorResult(NS_ERROR_FAILURE), void_t());
     return;
   }
 
   nsRefPtr<Context> context = mContext;
   MOZ_ASSERT(!context->IsCanceled());
 
   nsRefPtr<StreamList> streamList = new StreamList(this, context);
@@ -1632,17 +1637,17 @@ Manager::ExecuteCacheOp(Listener* aListe
 
 void
 Manager::ExecuteStorageOp(Listener* aListener, Namespace aNamespace,
                           const CacheOpArgs& aOpArgs)
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
   MOZ_ASSERT(aListener);
 
-  if (mClosing) {
+  if (mState == Closing) {
     aListener->OnOpComplete(ErrorResult(NS_ERROR_FAILURE), void_t());
     return;
   }
 
   nsRefPtr<Context> context = mContext;
   MOZ_ASSERT(!context->IsCanceled());
 
   nsRefPtr<StreamList> streamList = new StreamList(this, context);
@@ -1681,17 +1686,17 @@ void
 Manager::ExecutePutAll(Listener* aListener, CacheId aCacheId,
                        const nsTArray<CacheRequestResponse>& aPutList,
                        const nsTArray<nsCOMPtr<nsIInputStream>>& aRequestStreamList,
                        const nsTArray<nsCOMPtr<nsIInputStream>>& aResponseStreamList)
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
   MOZ_ASSERT(aListener);
 
-  if (mClosing) {
+  if (mState == Closing) {
     aListener->OnOpComplete(ErrorResult(NS_ERROR_FAILURE), CachePutAllResult());
     return;
   }
 
   nsRefPtr<Context> context = mContext;
   MOZ_ASSERT(!context->IsCanceled());
 
   ListenerId listenerId = SaveListener(aListener);
@@ -1703,48 +1708,53 @@ Manager::ExecutePutAll(Listener* aListen
   context->Dispatch(mIOThread, action);
 }
 
 Manager::Manager(ManagerId* aManagerId, nsIThread* aIOThread)
   : mManagerId(aManagerId)
   , mIOThread(aIOThread)
   , mContext(nullptr)
   , mShuttingDown(false)
-  , mClosing(false)
+  , mState(Open)
 {
   MOZ_ASSERT(mManagerId);
   MOZ_ASSERT(mIOThread);
 }
 
 Manager::~Manager()
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
-  MOZ_ASSERT(mClosing);
+  MOZ_ASSERT(mState == Closing);
   MOZ_ASSERT(!mContext);
 
   nsCOMPtr<nsIThread> ioThread;
   mIOThread.swap(ioThread);
 
   // Don't spin the event loop in the destructor waiting for the thread to
   // shutdown.  Defer this to the main thread, instead.
   nsCOMPtr<nsIRunnable> runnable =
     NS_NewRunnableMethod(ioThread, &nsIThread::Shutdown);
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(NS_DispatchToMainThread(runnable)));
 }
 
 void
-Manager::Init()
+Manager::Init(Manager* aOldManager)
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
 
+  nsRefPtr<Context> oldContext;
+  if (aOldManager) {
+    oldContext = aOldManager->mContext;
+  }
+
   // Create the context immediately.  Since there can at most be one Context
   // per Manager now, this lets us cleanly call Factory::Remove() once the
   // Context goes away.
   nsRefPtr<Action> setupAction = new SetupAction();
-  nsRefPtr<Context> ref = Context::Create(this, setupAction);
+  nsRefPtr<Context> ref = Context::Create(this, setupAction, oldContext);
   mContext = ref;
 }
 
 void
 Manager::Shutdown()
 {
   NS_ASSERT_OWNINGTHREAD(Manager);
 

--- a/dom/cache/Manager.h
+++ b/dom/cache/Manager.h
@@ -114,32 +114,39 @@ public:
                  const nsTArray<SavedResponse>& aSavedResponseList,
                  const nsTArray<SavedRequest>& aSavedRequestList,
                  StreamList* aStreamList) { }
 
   protected:
     ~Listener() { }
   };
 
+  enum State
+  {
+    Open,
+    Closing
+  };
+
   static nsresult GetOrCreate(ManagerId* aManagerId, Manager** aManagerOut);
   static already_AddRefed<Manager> Get(ManagerId* aManagerId);
 
   // Synchronously shutdown from main thread.  This spins the event loop.
   static void ShutdownAllOnMainThread();
 
   // Must be called by Listener objects before they are destroyed.
   void RemoveListener(Listener* aListener);
 
   // Must be called by Context objects before they are destroyed.
   void RemoveContext(Context* aContext);
 
   // Marks the Manager "invalid".  Once the Context completes no new operations
   // will be permitted with this Manager.  New actors will get a new Manager.
   void NoteClosing();
-  bool IsClosing() const;
+
+  State GetState() const;
 
   // If an actor represents a long term reference to a cache or body stream,
   // then they must call AddRefCacheId() or AddRefBodyId().  This will
   // cause the Manager to keep the backing data store alive for the given
   // object.  The actor must then call ReleaseCacheId() or ReleaseBodyId()
   // exactly once for every AddRef*() call it made.  Any delayed deletion
   // will then be performed.
   void AddRefCacheId(CacheId aCacheId);
@@ -180,17 +187,17 @@ private:
   class StorageOpenAction;
   class StorageDeleteAction;
   class StorageKeysAction;
 
   typedef uint64_t ListenerId;
 
   Manager(ManagerId* aManagerId, nsIThread* aIOThread);
   ~Manager();
-  void Init();
+  void Init(Manager* aOldManager);
   void Shutdown();
   already_AddRefed<Context> CurrentContext();
 
   ListenerId SaveListener(Listener* aListener);
   Listener* GetListener(ListenerId aListenerId) const;
 
   bool SetCacheIdOrphanedIfRefed(CacheId aCacheId);
   bool SetBodyIdOrphanedIfRefed(const nsID& aBodyId);
@@ -244,17 +251,17 @@ private:
   typedef nsTArray<ListenerEntry> ListenerList;
   ListenerList mListeners;
   static ListenerId sNextListenerId;
 
   // Weak references cleared by RemoveStreamList() in StreamList destructors.
   nsTArray<StreamList*> mStreamLists;
 
   bool mShuttingDown;
-  bool mClosing;
+  State mState;
 
   struct CacheIdRefCounter
   {
     CacheId mCacheId;
     MozRefCountType mCount;
     bool mOrphaned;
   };
   nsTArray<CacheIdRefCounter> mCacheIdRefs;

--- a/dom/cache/test/mochitest/serviceworker_driver.js
+++ b/dom/cache/test/mochitest/serviceworker_driver.js
@@ -33,21 +33,12 @@ function serviceWorkerTestExec(testFile)
       var iframe = document.createElement("iframe");
       iframe.src = "message_receiver.html";
       iframe.onload = function() {
         worker.postMessage({ script: testFile });
       };
       document.body.appendChild(iframe);
     }
 
-    navigator.serviceWorker.register("worker_wrapper.js", {scope: "."})
-      .then(function(registration) {
-        if (registration.installing) {
-          registration.installing.onstatechange = function(e) {
-            e.target.onstatechange = null;
-            setupSW(registration);
-          };
-        } else {
-          setupSW(registration);
-        }
-      });
+    navigator.serviceWorker.ready.then(setupSW);
+    navigator.serviceWorker.register("worker_wrapper.js", {scope: "."});
   });
 }

--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -4264,17 +4264,20 @@ CanvasRenderingContext2D::DrawImage(cons
       mCurrentVideoSize.width = srcImage->GetSize().width;
       mCurrentVideoSize.height = srcImage->GetSize().height;
       gl->fTexImage2D(LOCAL_GL_TEXTURE_2D, 0, LOCAL_GL_RGB, srcImage->GetSize().width, srcImage->GetSize().height, 0, LOCAL_GL_RGB, LOCAL_GL_UNSIGNED_SHORT_5_6_5, nullptr);
       gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_S, LOCAL_GL_CLAMP_TO_EDGE);
       gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_T, LOCAL_GL_CLAMP_TO_EDGE);
       gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER, LOCAL_GL_LINEAR);
       gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_LINEAR);
     }
-    bool ok = gl->BlitHelper()->BlitImageToTexture(srcImage.get(), srcImage->GetSize(), mVideoTexture, LOCAL_GL_TEXTURE_2D, 1);
+    const gl::OriginPos destOrigin = gl::OriginPos::TopLeft;
+    bool ok = gl->BlitHelper()->BlitImageToTexture(srcImage.get(), srcImage->GetSize(),
+                                                   mVideoTexture, LOCAL_GL_TEXTURE_2D,
+                                                   destOrigin);
     if (ok) {
       NativeSurface texSurf;
       texSurf.mType = NativeSurfaceType::OPENGL_TEXTURE;
       texSurf.mFormat = SurfaceFormat::R5G6B5;
       texSurf.mSize.width = mCurrentVideoSize.width;
       texSurf.mSize.height = mCurrentVideoSize.height;
       texSurf.mSurface = (void*)((uintptr_t)mVideoTexture);
 

--- a/dom/canvas/WebGLContext.cpp
+++ b/dom/canvas/WebGLContext.cpp
@@ -1832,21 +1832,23 @@ WebGLContext::TexImageFromVideoElement(c
                            info.Height() == srcImage->GetSize().height;
     if (!dimensionsMatch) {
         // we need to allocation
         gl->fTexImage2D(texImageTarget.get(), level, internalFormat,
                         srcImage->GetSize().width, srcImage->GetSize().height,
                         0, format, type, nullptr);
     }
 
+    const gl::OriginPos destOrigin = mPixelStoreFlipY ? gl::OriginPos::BottomLeft
+                                                      : gl::OriginPos::TopLeft;
     bool ok = gl->BlitHelper()->BlitImageToTexture(srcImage.get(),
                                                    srcImage->GetSize(),
                                                    tex->GLName(),
                                                    texImageTarget.get(),
-                                                   mPixelStoreFlipY);
+                                                   destOrigin);
     if (ok) {
         TexInternalFormat effectiveInternalFormat =
             EffectiveInternalFormatFromInternalFormatAndType(internalFormat,
                                                              type);
         MOZ_ASSERT(effectiveInternalFormat != LOCAL_GL_NONE);
         tex->SetImageInfo(texImageTarget, level, srcImage->GetSize().width,
                           srcImage->GetSize().height, 1,
                           effectiveInternalFormat,

--- a/dom/filesystem/Directory.cpp
+++ b/dom/filesystem/Directory.cpp
@@ -193,39 +193,30 @@ Directory::RemoveInternal(const StringOr
   nsresult error = NS_OK;
   nsString realPath;
   nsRefPtr<FileImpl> file;
 
   // Check and get the target path.
 
   if (aPath.IsFile()) {
     file = aPath.GetAsFile().Impl();
-    goto parameters_check_done;
-  }
-
-  if (aPath.IsString()) {
+  } else if (aPath.IsString()) {
     if (!DOMPathToRealPath(aPath.GetAsString(), realPath)) {
       error = NS_ERROR_DOM_FILESYSTEM_INVALID_PATH_ERR;
     }
-    goto parameters_check_done;
-  }
-
-  if (!mFileSystem->IsSafeDirectory(&aPath.GetAsDirectory())) {
+  } else if (!mFileSystem->IsSafeDirectory(&aPath.GetAsDirectory())) {
     error = NS_ERROR_DOM_SECURITY_ERR;
-    goto parameters_check_done;
+  } else {
+    realPath = aPath.GetAsDirectory().mPath;
+    // The target must be a descendant of this directory.
+    if (!FileSystemUtils::IsDescendantPath(mPath, realPath)) {
+      error = NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR;
+    }
   }
 
-  realPath = aPath.GetAsDirectory().mPath;
-  // The target must be a descendant of this directory.
-  if (!FileSystemUtils::IsDescendantPath(mPath, realPath)) {
-    error = NS_ERROR_DOM_FILESYSTEM_NO_MODIFICATION_ALLOWED_ERR;
-  }
-
-parameters_check_done:
-
   nsRefPtr<RemoveTask> task = new RemoveTask(mFileSystem, mPath, file, realPath,
     aRecursive, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
   task->SetError(error);
   FileSystemPermissionRequest::RequestForTask(task);
   return task->GetPromise();

--- a/dom/html/HTMLTextAreaElement.cpp
+++ b/dom/html/HTMLTextAreaElement.cpp
@@ -1456,25 +1456,17 @@ NS_IMETHODIMP_(bool)
 HTMLTextAreaElement::IsPasswordTextControl() const
 {
   return false;
 }
 
 NS_IMETHODIMP_(int32_t)
 HTMLTextAreaElement::GetCols()
 {
-  const nsAttrValue* attr = GetParsedAttr(nsGkAtoms::cols);
-  if (attr) {
-    int32_t cols = attr->Type() == nsAttrValue::eInteger ?
-                   attr->GetIntegerValue() : 0;
-    // XXX why a default of 1 char, why hide it
-    return (cols <= 0) ? 1 : cols;
-  }
-
-  return DEFAULT_COLS;
+  return Cols();
 }
 
 NS_IMETHODIMP_(int32_t)
 HTMLTextAreaElement::GetWrapCols()
 {
   // wrap=off means -1 for wrap width no matter what cols is
   nsHTMLTextWrap wrapProp;
   nsITextControlElement::GetWrapPropertyEnum(this, wrapProp);

--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -2355,16 +2355,23 @@ ContentParent::~ContentParent()
 #endif
 }
 
 void
 ContentParent::InitInternal(ProcessPriority aInitialPriority,
                             bool aSetupOffMainThreadCompositing,
                             bool aSendRegisteredChrome)
 {
+    if (aSendRegisteredChrome) {
+        nsCOMPtr<nsIChromeRegistry> registrySvc = nsChromeRegistry::GetService();
+        nsChromeRegistryChrome* chromeRegistry =
+            static_cast<nsChromeRegistryChrome*>(registrySvc.get());
+        chromeRegistry->SendRegisteredChrome(this);
+    }
+
     // Initialize the message manager (and load delayed scripts) now that we
     // have established communications with the child.
     mMessageManager->InitWithCallback(this);
 
     // Set the subprocess's priority.  We do this early on because we're likely
     // /lowering/ the process's CPU and memory priority, which it has inherited
     // from this process.
     //
@@ -2397,23 +2404,16 @@ ContentParent::InitInternal(ProcessPrior
 #endif
         }
 #ifdef MOZ_WIDGET_GONK
         DebugOnly<bool> opened = PSharedBufferManager::Open(this);
         MOZ_ASSERT(opened);
 #endif
     }
 
-    if (aSendRegisteredChrome) {
-        nsCOMPtr<nsIChromeRegistry> registrySvc = nsChromeRegistry::GetService();
-        nsChromeRegistryChrome* chromeRegistry =
-            static_cast<nsChromeRegistryChrome*>(registrySvc.get());
-        chromeRegistry->SendRegisteredChrome(this);
-    }
-
     if (gAppData) {
         nsCString version(gAppData->version);
         nsCString buildID(gAppData->buildID);
         nsCString name(gAppData->name);
         nsCString UAName(gAppData->UAName);
         nsCString ID(gAppData->ID);
         nsCString vendor(gAppData->vendor);
 

--- a/dom/media/fmp4/android/AndroidDecoderModule.cpp
+++ b/dom/media/fmp4/android/AndroidDecoderModule.cpp
@@ -67,20 +67,24 @@ public:
   bool WantCopy() {
     // Allocating a texture is incredibly slow on PowerVR
     return mGLContext->Vendor() != GLVendor::Imagination;
   }
 
   EGLImage CopySurface(layers::Image* img) {
     mGLContext->MakeCurrent();
 
-    GLuint tex = CreateTextureForOffscreen(mGLContext, mGLContext->GetGLFormats(), img->GetSize());
+    GLuint tex = CreateTextureForOffscreen(mGLContext, mGLContext->GetGLFormats(),
+                                           img->GetSize());
 
-    GLBlitHelper helper(mGLContext);
-    if (!helper.BlitImageToTexture(img, img->GetSize(), tex, LOCAL_GL_TEXTURE_2D)) {
+    auto helper = mGLContext->BlitHelper();
+    const gl::OriginPos destOrigin = gl::OriginPos::TopLeft;
+    if (!helper->BlitImageToTexture(img, img->GetSize(), tex, LOCAL_GL_TEXTURE_2D,
+                                    destOrigin))
+    {
       mGLContext->fDeleteTextures(1, &tex);
       return nullptr;
     }
 
     EGLint attribs[] = {
       LOCAL_EGL_IMAGE_PRESERVED_KHR, LOCAL_EGL_TRUE,
       LOCAL_EGL_NONE, LOCAL_EGL_NONE
     };
@@ -129,17 +133,17 @@ public:
       }
 
       img = mImageContainer->CreateImage(ImageFormat::EGLIMAGE);
       layers::EGLImageImage::Data data;
       data.mImage = eglImage;
       data.mSync = eglSync;
       data.mOwns = true;
       data.mSize = mConfig.mDisplay;
-      data.mOriginPos = gl::OriginPos::BottomLeft;
+      data.mOriginPos = gl::OriginPos::TopLeft;
 
       layers::EGLImageImage* typedImg = static_cast<layers::EGLImageImage*>(img.get());
       typedImg->SetData(data);
     }
 
     nsresult rv;
     int32_t flags;
     NS_ENSURE_SUCCESS(rv = aInfo->Flags(&flags), rv);

--- a/dom/media/gmp/GMPAudioDecoderParent.cpp
+++ b/dom/media/gmp/GMPAudioDecoderParent.cpp
@@ -27,16 +27,17 @@ extern PRLogModuleInfo* GetGMPLog();
 #define LOG(level, msg)
 #endif
 
 namespace gmp {
 
 GMPAudioDecoderParent::GMPAudioDecoderParent(GMPContentParent* aPlugin)
   : mIsOpen(false)
   , mShuttingDown(false)
+  , mActorDestroyed(false)
   , mPlugin(aPlugin)
   , mCallback(nullptr)
 {
   MOZ_ASSERT(mPlugin);
 }
 
 GMPAudioDecoderParent::~GMPAudioDecoderParent()
 {
@@ -169,26 +170,29 @@ GMPAudioDecoderParent::Shutdown()
 
   // Notify client we're gone!  Won't occur after Close()
   if (mCallback) {
     mCallback->Terminated();
     mCallback = nullptr;
   }
 
   mIsOpen = false;
-  unused << SendDecodingComplete();
+  if (!mActorDestroyed) {
+    unused << SendDecodingComplete();
+  }
 
   return NS_OK;
 }
 
 // Note: Keep this sync'd up with DecodingComplete
 void
 GMPAudioDecoderParent::ActorDestroy(ActorDestroyReason aWhy)
 {
   mIsOpen = false;
+  mActorDestroyed = true;
   if (mCallback) {
     // May call Close() (and Shutdown()) immediately or with a delay
     mCallback->Terminated();
     mCallback = nullptr;
   }
   if (mPlugin) {
     // Ignore any return code. It is OK for this to fail without killing the process.
     mPlugin->AudioDecoderDestroyed(this);

--- a/dom/media/gmp/GMPAudioDecoderParent.h
+++ b/dom/media/gmp/GMPAudioDecoderParent.h
@@ -50,16 +50,17 @@ private:
   virtual bool RecvDrainComplete() override;
   virtual bool RecvResetComplete() override;
   virtual bool RecvError(const GMPErr& aError) override;
   virtual bool RecvShutdown() override;
   virtual bool Recv__delete__() override;
 
   bool mIsOpen;
   bool mShuttingDown;
+  bool mActorDestroyed;
   nsRefPtr<GMPContentParent> mPlugin;
   GMPAudioDecoderCallbackProxy* mCallback;
 };
 
 } // namespace gmp
 } // namespace mozilla
 
 #endif // GMPAudioDecoderParent_h_

--- a/dom/media/gmp/GMPDecryptorParent.cpp
+++ b/dom/media/gmp/GMPDecryptorParent.cpp
@@ -9,16 +9,17 @@
 #include "mozilla/unused.h"
 
 namespace mozilla {
 namespace gmp {
 
 GMPDecryptorParent::GMPDecryptorParent(GMPContentParent* aPlugin)
   : mIsOpen(false)
   , mShuttingDown(false)
+  , mActorDestroyed(false)
   , mPlugin(aPlugin)
   , mCallback(nullptr)
 #ifdef DEBUG
   , mGMPThread(aPlugin->GMPThread())
 #endif
 {
   MOZ_ASSERT(mPlugin && mGMPThread);
   mPluginId = aPlugin->GetPluginId();
@@ -342,24 +343,27 @@ GMPDecryptorParent::Shutdown()
 
   // Notify client we're gone!  Won't occur after Close()
   if (mCallback) {
     mCallback->Terminated();
     mCallback = nullptr;
   }
 
   mIsOpen = false;
-  unused << SendDecryptingComplete();
+  if (!mActorDestroyed) {
+    unused << SendDecryptingComplete();
+  }
 }
 
 // Note: Keep this sync'd up with Shutdown
 void
 GMPDecryptorParent::ActorDestroy(ActorDestroyReason aWhy)
 {
   mIsOpen = false;
+  mActorDestroyed = true;
   if (mCallback) {
     // May call Close() (and Shutdown()) immediately or with a delay
     mCallback->Terminated();
     mCallback = nullptr;
   }
   if (mPlugin) {
     mPlugin->DecryptorDestroyed(this);
     mPlugin = nullptr;

--- a/dom/media/gmp/GMPDecryptorParent.h
+++ b/dom/media/gmp/GMPDecryptorParent.h
@@ -106,16 +106,17 @@ private:
 
   virtual bool RecvShutdown() override;
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
   virtual bool Recv__delete__() override;
 
   bool mIsOpen;
   bool mShuttingDown;
+  bool mActorDestroyed;
   nsRefPtr<GMPContentParent> mPlugin;
   nsCString mPluginId;
   GMPDecryptorProxyCallback* mCallback;
 #ifdef DEBUG
   nsIThread* const mGMPThread;
 #endif
 };
 

--- a/dom/media/gmp/GMPVideoDecoderParent.cpp
+++ b/dom/media/gmp/GMPVideoDecoderParent.cpp
@@ -42,16 +42,17 @@ namespace gmp {
 //    on ActorDestroy -> Dead
 //    on Shutdown -> Dead
 // Dead: mIsOpen == false
 
 GMPVideoDecoderParent::GMPVideoDecoderParent(GMPContentParent* aPlugin)
   : GMPSharedMemManager(aPlugin)
   , mIsOpen(false)
   , mShuttingDown(false)
+  , mActorDestroyed(false)
   , mPlugin(aPlugin)
   , mCallback(nullptr)
   , mVideoHost(this)
 {
   MOZ_ASSERT(mPlugin);
 }
 
 GMPVideoDecoderParent::~GMPVideoDecoderParent()
@@ -208,26 +209,29 @@ GMPVideoDecoderParent::Shutdown()
 
   // Notify client we're gone!  Won't occur after Close()
   if (mCallback) {
     mCallback->Terminated();
     mCallback = nullptr;
   }
 
   mIsOpen = false;
-  unused << SendDecodingComplete();
+  if (!mActorDestroyed) {
+    unused << SendDecodingComplete();
+  }
 
   return NS_OK;
 }
 
 // Note: Keep this sync'd up with Shutdown
 void
 GMPVideoDecoderParent::ActorDestroy(ActorDestroyReason aWhy)
 {
   mIsOpen = false;
+  mActorDestroyed = true;
   mVideoHost.DoneWithAPI();
 
   if (mCallback) {
     // May call Close() (and Shutdown()) immediately or with a delay
     mCallback->Terminated();
     mCallback = nullptr;
   }
   if (mPlugin) {

--- a/dom/media/gmp/GMPVideoDecoderParent.h
+++ b/dom/media/gmp/GMPVideoDecoderParent.h
@@ -76,16 +76,17 @@ private:
   virtual bool RecvShutdown() override;
   virtual bool RecvParentShmemForPool(Shmem&& aEncodedBuffer) override;
   virtual bool AnswerNeedShmem(const uint32_t& aFrameBufferSize,
                                Shmem* aMem) override;
   virtual bool Recv__delete__() override;
 
   bool mIsOpen;
   bool mShuttingDown;
+  bool mActorDestroyed;
   nsRefPtr<GMPContentParent> mPlugin;
   GMPVideoDecoderCallbackProxy* mCallback;
   GMPVideoHostImpl mVideoHost;
 };
 
 } // namespace gmp
 } // namespace mozilla
 

--- a/dom/media/gmp/GMPVideoEncoderParent.cpp
+++ b/dom/media/gmp/GMPVideoEncoderParent.cpp
@@ -49,16 +49,17 @@ namespace gmp {
 //    on ActorDestroy -> Dead
 //    on Shutdown -> Dead
 // Dead: mIsOpen == false
 
 GMPVideoEncoderParent::GMPVideoEncoderParent(GMPContentParent *aPlugin)
 : GMPSharedMemManager(aPlugin),
   mIsOpen(false),
   mShuttingDown(false),
+  mActorDestroyed(false),
   mPlugin(aPlugin),
   mCallback(nullptr),
   mVideoHost(this)
 {
   MOZ_ASSERT(mPlugin);
 
   nsresult rv = NS_NewNamedThread("GMPEncoded", getter_AddRefs(mEncodedThread));
   if (NS_FAILED(rv)) {
@@ -230,31 +231,34 @@ GMPVideoEncoderParent::Shutdown()
   // Notify client we're gone!  Won't occur after Close()
   if (mCallback) {
     mCallback->Terminated();
     mCallback = nullptr;
   }
   mVideoHost.DoneWithAPI();
 
   mIsOpen = false;
-  unused << SendEncodingComplete();
+  if (!mActorDestroyed) {
+    unused << SendEncodingComplete();
+  }
 }
 
 static void
 ShutdownEncodedThread(nsCOMPtr<nsIThread>& aThread)
 {
   aThread->Shutdown();
 }
 
 // Note: Keep this sync'd up with Shutdown
 void
 GMPVideoEncoderParent::ActorDestroy(ActorDestroyReason aWhy)
 {
   LOGD(("%s::%s: %p (%d)", __CLASS__, __FUNCTION__, this, (int) aWhy));
   mIsOpen = false;
+  mActorDestroyed = true;
   if (mCallback) {
     // May call Close() (and Shutdown()) immediately or with a delay
     mCallback->Terminated();
     mCallback = nullptr;
   }
   // Must be shut down before VideoEncoderDestroyed(), since this can recurse
   // the GMPThread event loop.  See bug 1049501
   if (mEncodedThread) {