dom/animation/Animation.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_Animation_h
   8 #define mozilla_dom_Animation_h
   9
  10 #include "X11UndefineNone.h"
  11 #include "nsCycleCollectionParticipant.h"
  12 #include "mozilla/AnimationPerformanceWarning.h"
  13 #include "mozilla/Attributes.h"
  14 #include "mozilla/BasePrincipal.h"
  15 #include "mozilla/DOMEventTargetHelper.h"
  16 #include "mozilla/EffectCompositor.h"  // For EffectCompositor::CascadeLevel
  17 #include "mozilla/LinkedList.h"
  18 #include "mozilla/Maybe.h"
  19 #include "mozilla/PostRestyleMode.h"
  20 #include "mozilla/StickyTimeDuration.h"
  21 #include "mozilla/TimeStamp.h"             // for TimeStamp, TimeDuration
  22 #include "mozilla/dom/AnimationBinding.h"  // for AnimationPlayState
  23 #include "mozilla/dom/AnimationTimeline.h"
  24
  25 struct JSContext;
  26 class nsCSSPropertyIDSet;
  27 class nsIFrame;
  28 class nsIGlobalObject;
  29
  30 namespace mozilla {
  31
  32 struct AnimationRule;
  33 class MicroTaskRunnable;
  34
  35 namespace dom {
  36
  37 class AnimationEffect;
  38 class AsyncFinishNotification;
  39 class CSSAnimation;
  40 class CSSTransition;
  41 class Document;
  42 class Promise;
  43
  44 class Animation : public DOMEventTargetHelper,
  45                   public LinkedListElement<Animation> {
  46  protected:
  47   virtual ~Animation();
  48
  49  public:
  50   explicit Animation(nsIGlobalObject* aGlobal);
  51
  52   // Constructs a copy of |aOther| with a new effect and timeline.
  53   // This is only intended to be used while making a static clone of a document
  54   // during printing, and does not assume that |aOther| is in the same document
  55   // as any of the other arguments.
  56   static already_AddRefed<Animation> ClonePausedAnimation(
  57       nsIGlobalObject* aGlobal, const Animation& aOther,
  58       AnimationEffect& aEffect, AnimationTimeline& aTimeline);
  59
  60   NS_DECL_ISUPPORTS_INHERITED
  61   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(Animation, DOMEventTargetHelper)
  62
  63   nsIGlobalObject* GetParentObject() const { return GetOwnerGlobal(); }
  64
  65   /**
  66    * Utility function to get the target (pseudo-)element associated with an
  67    * animation.
  68    */
  69   NonOwningAnimationTarget GetTargetForAnimation() const;
  70
  71   virtual JSObject* WrapObject(JSContext* aCx,
  72                                JS::Handle<JSObject*> aGivenProto) override;
  73
  74   virtual CSSAnimation* AsCSSAnimation() { return nullptr; }
  75   virtual const CSSAnimation* AsCSSAnimation() const { return nullptr; }
  76   virtual CSSTransition* AsCSSTransition() { return nullptr; }
  77   virtual const CSSTransition* AsCSSTransition() const { return nullptr; }
  78
  79   /**
  80    * Flag to pass to Play to indicate whether or not it should automatically
  81    * rewind the current time to the start point if the animation is finished.
  82    * For regular calls to play() from script we should do this, but when a CSS
  83    * animation's animation-play-state changes we shouldn't rewind the animation.
  84    */
  85   enum class LimitBehavior { AutoRewind, Continue };
  86
  87   // Animation interface methods
  88   static already_AddRefed<Animation> Constructor(
  89       const GlobalObject& aGlobal, AnimationEffect* aEffect,
  90       const Optional<AnimationTimeline*>& aTimeline, ErrorResult& aRv);
  91
  92   void GetId(nsAString& aResult) const { aResult = mId; }
  93   void SetId(const nsAString& aId);
  94
  95   AnimationEffect* GetEffect() const { return mEffect; }
  96   virtual void SetEffect(AnimationEffect* aEffect);
  97   void SetEffectNoUpdate(AnimationEffect* aEffect);
  98
  99   // FIXME: Bug 1676794. This is a tentative solution before we implement
 100   // ScrollTimeline interface. If the timeline is scroll/view timeline, we
 101   // return null. Once we implement ScrollTimeline interface, we can drop this.
 102   already_AddRefed<AnimationTimeline> GetTimelineFromJS() const {
 103     return mTimeline && mTimeline->IsScrollTimeline() ? nullptr
 104                                                       : do_AddRef(mTimeline);
 105   }
 106   void SetTimelineFromJS(AnimationTimeline* aTimeline) {
 107     SetTimeline(aTimeline);
 108   }
 109
 110   AnimationTimeline* GetTimeline() const { return mTimeline; }
 111   void SetTimeline(AnimationTimeline* aTimeline);
 112   void SetTimelineNoUpdate(AnimationTimeline* aTimeline);
 113
 114   Nullable<TimeDuration> GetStartTime() const { return mStartTime; }
 115   Nullable<double> GetStartTimeAsDouble() const;
 116   void SetStartTime(const Nullable<TimeDuration>& aNewStartTime);
 117   void SetPendingReadyTime(const TimeStamp& aReadyTime) {
 118     mPendingReadyTime = aReadyTime;
 119   }
 120   virtual void SetStartTimeAsDouble(const Nullable<double>& aStartTime);
 121
 122   // This is deliberately _not_ called GetCurrentTime since that would clash
 123   // with a macro defined in winbase.h
 124   Nullable<TimeDuration> GetCurrentTimeAsDuration() const {
 125     return GetCurrentTimeForHoldTime(mHoldTime);
 126   }
 127   Nullable<double> GetCurrentTimeAsDouble() const;
 128   void SetCurrentTime(const TimeDuration& aSeekTime);
 129   void SetCurrentTimeNoUpdate(const TimeDuration& aSeekTime);
 130   void SetCurrentTimeAsDouble(const Nullable<double>& aCurrentTime,
 131                               ErrorResult& aRv);
 132
 133   double PlaybackRate() const { return mPlaybackRate; }
 134   void SetPlaybackRate(double aPlaybackRate);
 135
 136   AnimationPlayState PlayState() const;
 137   virtual AnimationPlayState PlayStateFromJS() const { return PlayState(); }
 138
 139   bool Pending() const { return mPendingState != PendingState::NotPending; }
 140   virtual bool PendingFromJS() const { return Pending(); }
 141   AnimationReplaceState ReplaceState() const { return mReplaceState; }
 142
 143   virtual Promise* GetReady(ErrorResult& aRv);
 144   Promise* GetFinished(ErrorResult& aRv);
 145
 146   IMPL_EVENT_HANDLER(finish);
 147   IMPL_EVENT_HANDLER(cancel);
 148   IMPL_EVENT_HANDLER(remove);
 149
 150   void Cancel(PostRestyleMode aPostRestyle = PostRestyleMode::IfNeeded);
 151
 152   void Finish(ErrorResult& aRv);
 153
 154   void Play(ErrorResult& aRv, LimitBehavior aLimitBehavior);
 155   virtual void PlayFromJS(ErrorResult& aRv) {
 156     Play(aRv, LimitBehavior::AutoRewind);
 157   }
 158
 159   void Pause(ErrorResult& aRv);
 160   virtual void PauseFromJS(ErrorResult& aRv) { Pause(aRv); }
 161
 162   void UpdatePlaybackRate(double aPlaybackRate);
 163   virtual void Reverse(ErrorResult& aRv);
 164
 165   void Persist();
 166   MOZ_CAN_RUN_SCRIPT void CommitStyles(ErrorResult& aRv);
 167
 168   bool IsRunningOnCompositor() const;
 169
 170   using TickState = AnimationTimeline::TickState;
 171   virtual void Tick(TickState&);
 172   bool NeedsTicks() const {
 173     return Pending() ||
 174            (PlayState() == AnimationPlayState::Running &&
 175             // An animation with a zero playback rate doesn't need ticks even if
 176             // it is running since it effectively behaves as if it is paused.
 177             //
 178             // It's important we return false in this case since a zero playback
 179             // rate animation in the before or after phase that doesn't fill
 180             // won't be relevant and hence won't be returned by GetAnimations().
 181             // We don't want its timeline to keep it alive (which would happen
 182             // if we return true) since otherwise it will effectively be leaked.
 183             PlaybackRate() != 0.0) ||
 184            // Always return true for not idle animations attached to not
 185            // monotonically increasing timelines even if the animation is
 186            // finished. This is required to accommodate cases where timeline
 187            // ticks back in time.
 188            (mTimeline && !mTimeline->IsMonotonicallyIncreasing() &&
 189             PlayState() != AnimationPlayState::Idle);
 190   }
 191   /**
 192    * For the monotonically increasing timeline, we use this only for testing:
 193    * Start or pause a pending animation using the current timeline time. This
 194    * is used to support existing tests that expect animations to begin
 195    * immediately. Ideally we would rewrite the those tests and get rid of this
 196    * method, but there are a lot of them.
 197    */
 198   bool TryTriggerNow();
 199   /**
 200    * As with the start time, we should use the pending playback rate when
 201    * producing layer animations.
 202    */
 203   double CurrentOrPendingPlaybackRate() const {
 204     return mPendingPlaybackRate.valueOr(mPlaybackRate);
 205   }
 206   bool HasPendingPlaybackRate() const { return mPendingPlaybackRate.isSome(); }
 207
 208   /**
 209    * The following relationship from the definition of the 'current time' is
 210    * re-used in many algorithms so we extract it here into a static method that
 211    * can be re-used:
 212    *
 213    *   current time = (timeline time - start time) * playback rate
 214    *
 215    * As per https://drafts.csswg.org/web-animations-1/#current-time
 216    */
 217   static TimeDuration CurrentTimeFromTimelineTime(
 218       const TimeDuration& aTimelineTime, const TimeDuration& aStartTime,
 219       float aPlaybackRate) {
 220     return (aTimelineTime - aStartTime).MultDouble(aPlaybackRate);
 221   }
 222
 223   /**
 224    * As with calculating the current time, we often need to calculate a start
 225    * time from a current time. The following method simply inverts the current
 226    * time relationship.
 227    *
 228    * In each case where this is used, the desired behavior for playbackRate ==
 229    * 0 is to return the specified timeline time (often referred to as the ready
 230    * time).
 231    */
 232   static TimeDuration StartTimeFromTimelineTime(
 233       const TimeDuration& aTimelineTime, const TimeDuration& aCurrentTime,
 234       float aPlaybackRate) {
 235     TimeDuration result = aTimelineTime;
 236     if (aPlaybackRate == 0) {
 237       return result;
 238     }
 239
 240     result -= aCurrentTime.MultDouble(1.0 / aPlaybackRate);
 241     return result;
 242   }
 243
 244   /**
 245    * Converts a time in the timescale of this Animation's currentTime, to a
 246    * TimeStamp. Returns a null TimeStamp if the conversion cannot be performed
 247    * because of the current state of this Animation (e.g. it has no timeline, a
 248    * zero playbackRate, an unresolved start time etc.) or the value of the time
 249    * passed-in (e.g. an infinite time).
 250    */
 251   TimeStamp AnimationTimeToTimeStamp(const StickyTimeDuration& aTime) const;
 252
 253   // Converts an AnimationEvent's elapsedTime value to an equivalent TimeStamp
 254   // that can be used to sort events by when they occurred.
 255   TimeStamp ElapsedTimeToTimeStamp(
 256       const StickyTimeDuration& aElapsedTime) const;
 257
 258   bool IsPausedOrPausing() const {
 259     return PlayState() == AnimationPlayState::Paused;
 260   }
 261
 262   bool HasCurrentEffect() const;
 263   bool IsInEffect() const;
 264
 265   bool IsPlaying() const {
 266     return mPlaybackRate != 0.0 && mTimeline &&
 267            !mTimeline->GetCurrentTimeAsDuration().IsNull() &&
 268            PlayState() == AnimationPlayState::Running;
 269   }
 270
 271   bool ShouldBeSynchronizedWithMainThread(
 272       const nsCSSPropertyIDSet& aPropertySet, const nsIFrame* aFrame,
 273       AnimationPerformanceWarning::Type& aPerformanceWarning /* out */) const;
 274
 275   bool IsRelevant() const { return mIsRelevant; }
 276   void UpdateRelevance();
 277
 278   // https://drafts.csswg.org/web-animations-1/#replaceable-animation
 279   bool IsReplaceable() const;
 280
 281   /**
 282    * Returns true if this Animation satisfies the requirements for being
 283    * removed when it is replaced.
 284    *
 285    * Returning true does not imply this animation _should_ be removed.
 286    * Determining that depends on the other effects in the same EffectSet to
 287    * which this animation's effect, if any, contributes.
 288    */
 289   bool IsRemovable() const;
 290
 291   /**
 292    * Make this animation's target effect no-longer part of the effect stack
 293    * while preserving its timing information.
 294    */
 295   void Remove();
 296
 297   /**
 298    * Returns true if this Animation has a lower composite order than aOther.
 299    */
 300   bool HasLowerCompositeOrderThan(const Animation& aOther) const;
 301
 302   /**
 303    * Returns the level at which the effect(s) associated with this Animation
 304    * are applied to the CSS cascade.
 305    */
 306   virtual EffectCompositor::CascadeLevel CascadeLevel() const {
 307     return EffectCompositor::CascadeLevel::Animations;
 308   }
 309
 310   /**
 311    * Returns true if this animation does not currently need to update
 312    * style on the main thread (e.g. because it is empty, or is
 313    * running on the compositor).
 314    */
 315   bool CanThrottle() const;
 316
 317   /**
 318    * Updates various bits of state that we need to update as the result of
 319    * running ComposeStyle().
 320    * See the comment of KeyframeEffect::WillComposeStyle for more detail.
 321    */
 322   void WillComposeStyle();
 323
 324   /**
 325    * Updates |aComposeResult| with the animation values of this animation's
 326    * effect, if any.
 327    * Any properties contained in |aPropertiesToSkip| will not be added or
 328    * updated in |aComposeResult|.
 329    */
 330   void ComposeStyle(StyleAnimationValueMap& aComposeResult,
 331                     const nsCSSPropertyIDSet& aPropertiesToSkip);
 332
 333   void NotifyEffectTimingUpdated();
 334   void NotifyEffectPropertiesUpdated();
 335   void NotifyEffectTargetUpdated();
 336
 337   /**
 338    * Used by subclasses to synchronously queue a cancel event in situations
 339    * where the Animation may have been cancelled.
 340    *
 341    * We need to do this synchronously because after a CSS animation/transition
 342    * is canceled, it will be released by its owning element and may not still
 343    * exist when we would normally go to queue events on the next tick.
 344    */
 345   virtual void MaybeQueueCancelEvent(const StickyTimeDuration& aActiveTime){};
 346
 347   Maybe<uint32_t>& CachedChildIndexRef() { return mCachedChildIndex; }
 348
 349   void SetPartialPrerendered(uint64_t aIdOnCompositor) {
 350     mIdOnCompositor = aIdOnCompositor;
 351     mIsPartialPrerendered = true;
 352   }
 353   bool IsPartialPrerendered() const { return mIsPartialPrerendered; }
 354   uint64_t IdOnCompositor() const { return mIdOnCompositor; }
 355   /**
 356    * Needs to be called when the pre-rendered animation is going to no longer
 357    * run on the compositor.
 358    */
 359   void ResetPartialPrerendered() {
 360     MOZ_ASSERT(mIsPartialPrerendered);
 361     mIsPartialPrerendered = false;
 362     mIdOnCompositor = 0;
 363   }
 364   /**
 365    * Called via NotifyJankedAnimations IPC call from the compositor to update
 366    * pre-rendered area on the main-thread.
 367    */
 368   void UpdatePartialPrerendered() {
 369     ResetPartialPrerendered();
 370     PostUpdate();
 371   }
 372
 373   bool UsingScrollTimeline() const {
 374     return mTimeline && mTimeline->IsScrollTimeline();
 375   }
 376
 377   /**
 378    * Returns true if this is at the progress timeline boundary.
 379    * https://drafts.csswg.org/web-animations-2/#at-progress-timeline-boundary
 380    */
 381   enum class ProgressTimelinePosition : uint8_t { Boundary, NotBoundary };
 382   static ProgressTimelinePosition AtProgressTimelineBoundary(
 383       const Nullable<TimeDuration>& aTimelineDuration,
 384       const Nullable<TimeDuration>& aCurrentTime,
 385       const TimeDuration& aEffectStartTime, const double aPlaybackRate);
 386   ProgressTimelinePosition AtProgressTimelineBoundary() const {
 387     Nullable<TimeDuration> currentTime = GetUnconstrainedCurrentTime();
 388     return AtProgressTimelineBoundary(
 389         mTimeline ? mTimeline->TimelineDuration() : nullptr,
 390         // Set unlimited current time based on the first matching condition:
 391         // 1. start time is resolved:
 392         //    (timeline time - start time) × playback rate
 393         // 2. Otherwise:
 394         //    animation’s current time
 395         !currentTime.IsNull() ? currentTime : GetCurrentTimeAsDuration(),
 396         mStartTime.IsNull() ? TimeDuration() : mStartTime.Value(),
 397         mPlaybackRate);
 398   }
 399
 400   void SetHiddenByContentVisibility(bool hidden);
 401   bool IsHiddenByContentVisibility() const {
 402     return mHiddenByContentVisibility;
 403   }
 404   void UpdateHiddenByContentVisibility();
 405
 406   DocGroup* GetDocGroup();
 407
 408  protected:
 409   void SilentlySetCurrentTime(const TimeDuration& aNewCurrentTime);
 410   void CancelNoUpdate();
 411   void PlayNoUpdate(ErrorResult& aRv, LimitBehavior aLimitBehavior);
 412   void ResumeAt(const TimeDuration& aReadyTime);
 413   void PauseAt(const TimeDuration& aReadyTime);
 414   void FinishPendingAt(const TimeDuration& aReadyTime) {
 415     if (mPendingState == PendingState::PlayPending) {
 416       ResumeAt(aReadyTime);
 417     } else if (mPendingState == PendingState::PausePending) {
 418       PauseAt(aReadyTime);
 419     } else {
 420       MOZ_ASSERT_UNREACHABLE(
 421           "Can't finish pending if we're not in a pending state");
 422     }
 423   }
 424   void ApplyPendingPlaybackRate() {
 425     if (mPendingPlaybackRate) {
 426       mPlaybackRate = mPendingPlaybackRate.extract();
 427     }
 428   }
 429
 430   /**
 431    * Finishing behavior depends on if changes to timing occurred due
 432    * to a seek or regular playback.
 433    */
 434   enum class SeekFlag { NoSeek, DidSeek };
 435
 436   enum class SyncNotifyFlag { Sync, Async };
 437
 438   virtual void UpdateTiming(SeekFlag aSeekFlag, SyncNotifyFlag aSyncNotifyFlag);
 439   void UpdateFinishedState(SeekFlag aSeekFlag, SyncNotifyFlag aSyncNotifyFlag);
 440   void UpdateEffect(PostRestyleMode aPostRestyle);
 441   /**
 442    * Flush all pending styles other than throttled animation styles (e.g.
 443    * animations running on the compositor).
 444    */
 445   void FlushUnanimatedStyle() const;
 446   void PostUpdate();
 447   void ResetFinishedPromise();
 448   void MaybeResolveFinishedPromise();
 449   void DoFinishNotification(SyncNotifyFlag aSyncNotifyFlag);
 450   friend class AsyncFinishNotification;
 451   void DoFinishNotificationImmediately(MicroTaskRunnable* aAsync = nullptr);
 452   void QueuePlaybackEvent(const nsAString& aName,
 453                           TimeStamp&& aScheduledEventTime);
 454
 455   /**
 456    * Remove this animation from the pending animation tracker and reset
 457    * mPendingState as necessary. The caller is responsible for resolving or
 458    * aborting the mReady promise as necessary.
 459    */
 460   void CancelPendingTasks();
 461
 462   /**
 463    * Performs the same steps as CancelPendingTasks and also rejects and
 464    * recreates the ready promise if the animation was pending.
 465    */
 466   void ResetPendingTasks();
 467   StickyTimeDuration EffectEnd() const;
 468
 469   Nullable<TimeDuration> GetCurrentTimeForHoldTime(
 470       const Nullable<TimeDuration>& aHoldTime) const;
 471   Nullable<TimeDuration> GetUnconstrainedCurrentTime() const {
 472     return GetCurrentTimeForHoldTime(Nullable<TimeDuration>());
 473   }
 474
 475   void ScheduleReplacementCheck();
 476   void MaybeScheduleReplacementCheck();
 477
 478   // Earlier side of the elapsed time range reported in CSS Animations and CSS
 479   // Transitions events.
 480   //
 481   // https://drafts.csswg.org/css-animations-2/#interval-start
 482   // https://drafts.csswg.org/css-transitions-2/#interval-start
 483   StickyTimeDuration IntervalStartTime(
 484       const StickyTimeDuration& aActiveDuration) const;
 485
 486   // Later side of the elapsed time range reported in CSS Animations and CSS
 487   // Transitions events.
 488   //
 489   // https://drafts.csswg.org/css-animations-2/#interval-end
 490   // https://drafts.csswg.org/css-transitions-2/#interval-end
 491   StickyTimeDuration IntervalEndTime(
 492       const StickyTimeDuration& aActiveDuration) const;
 493
 494   TimeStamp GetTimelineCurrentTimeAsTimeStamp() const {
 495     return mTimeline ? mTimeline->GetCurrentTimeAsTimeStamp() : TimeStamp();
 496   }
 497
 498   Document* GetRenderedDocument() const;
 499   Document* GetTimelineDocument() const;
 500
 501   bool HasFiniteTimeline() const {
 502     return mTimeline && !mTimeline->IsMonotonicallyIncreasing();
 503   }
 504
 505   void UpdateScrollTimelineAnimationTracker(AnimationTimeline* aOldTimeline,
 506                                             AnimationTimeline* aNewTimeline);
 507
 508   RefPtr<AnimationTimeline> mTimeline;
 509   RefPtr<AnimationEffect> mEffect;
 510   // The beginning of the delay period.
 511   Nullable<TimeDuration> mStartTime;            // Timeline timescale
 512   Nullable<TimeDuration> mHoldTime;             // Animation timescale
 513   Nullable<TimeDuration> mPreviousCurrentTime;  // Animation timescale
 514   double mPlaybackRate = 1.0;
 515   Maybe<double> mPendingPlaybackRate;
 516
 517   // A Promise that is replaced on each call to Play()
 518   // and fulfilled when Play() is successfully completed.
 519   // This object is lazily created by GetReady.
 520   // See http://drafts.csswg.org/web-animations/#current-ready-promise
 521   RefPtr<Promise> mReady;
 522
 523   // A Promise that is resolved when we reach the end of the effect, or
 524   // 0 when playing backwards. The Promise is replaced if the animation is
 525   // finished but then a state change makes it not finished.
 526   // This object is lazily created by GetFinished.
 527   // See http://drafts.csswg.org/web-animations/#current-finished-promise
 528   RefPtr<Promise> mFinished;
 529
 530   static uint64_t sNextAnimationIndex;
 531
 532   // The relative position of this animation within the global animation list.
 533   //
 534   // Note that subclasses such as CSSTransition and CSSAnimation may repurpose
 535   // this member to implement their own brand of sorting. As a result, it is
 536   // possible for two different objects to have the same index.
 537   uint64_t mAnimationIndex;
 538
 539   // While ordering Animation objects for event dispatch, the index of the
 540   // target node in its parent may be cached in mCachedChildIndex.
 541   Maybe<uint32_t> mCachedChildIndex;
 542
 543   // Indicates if the animation is in the pending state (and what state it is
 544   // waiting to enter when it finished pending).
 545   enum class PendingState : uint8_t { NotPending, PlayPending, PausePending };
 546   PendingState mPendingState = PendingState::NotPending;
 547
 548   // Handling of this animation's target effect when filling while finished.
 549   AnimationReplaceState mReplaceState = AnimationReplaceState::Active;
 550
 551   bool mFinishedAtLastComposeStyle = false;
 552   bool mWasReplaceableAtLastTick = false;
 553   // When we create a new pending animation, this tracks whether we've seen at
 554   // least one refresh driver tick. This is used to guarantee that a whole tick
 555   // has run before triggering the animation, which guarantees (for most pages)
 556   // that we've actually painted.
 557   bool mSawTickWhilePending = false;
 558
 559   bool mHiddenByContentVisibility = false;
 560
 561   // Indicates that the animation should be exposed in an element's
 562   // getAnimations() list.
 563   bool mIsRelevant = false;
 564
 565   // True if mFinished is resolved or would be resolved if mFinished has
 566   // yet to be created. This is not set when mFinished is rejected since
 567   // in that case mFinished is immediately reset to represent a new current
 568   // finished promise.
 569   bool mFinishedIsResolved = false;
 570
 571   RefPtr<MicroTaskRunnable> mFinishNotificationTask;
 572
 573   nsString mId;
 574
 575   bool mResetCurrentTimeOnResume = false;
 576
 577   // Whether the Animation is System, ResistFingerprinting, or neither
 578   RTPCallerType mRTPCallerType;
 579
 580   // The time at which our animation should be ready.
 581   TimeStamp mPendingReadyTime;
 582
 583  private:
 584   // The id for this animation on the compositor.
 585   uint64_t mIdOnCompositor = 0;
 586   bool mIsPartialPrerendered = false;
 587 };
 588
 589 }  // namespace dom
 590 }  // namespace mozilla
 591
 592 #endif  // mozilla_dom_Animation_h