Web Animations: Overhaul and trace play state in AnimationPlayer

Source/core/animation/AnimationPlayer.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 56 matching lines @@
     //  0         - if this player requires an update on the next frame
     //  n         - if this player requires an update after 'n' units of time
     double timeToEffectChange();
 
     void cancel();
 
     double currentTime(bool& isNull);
     double currentTime();
     void setCurrentTime(double newCurrentTime);
 
-    double calculateCurrentTime() const;
-    double currentTimeInternal();
+    double currentTimeInternal() const;
+
     void setCurrentTimeInternal(double newCurrentTime, TimingUpdateReason = TimingUpdateOnDemand);
-
     bool paused() const { return m_paused && !m_isPausedForTesting; }
-    String playState();
-    AnimationPlayState playStateInternal();
+    static const char* playStateString(AnimationPlayState);
+    String playState() { return playStateString(playStateInternal()); }
+    AnimationPlayState playStateInternal() const;
 
     void pause();
     void play();
     void reverse();
     void finish(ExceptionState&);
-    bool finished() { return !m_idle && limited(currentTimeInternal()); }
-    bool playing() { return !(finished() || m_paused || m_isPausedForTesting || m_idle); }
+    bool finished() const { return m_playState != Idle && limited(currentTimeInternal()); }
+    bool playing() const { return !(playStateInternal() == Idle || finished() || m_paused || m_isPausedForTesting); }
     // FIXME: Resolve whether finished() should just return the flag, and
     // remove this method.
     bool finishedInternal() const { return m_finished; }
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(finish);
 
     virtual const AtomicString& interfaceName() const override;
     virtual ExecutionContext* executionContext() const override;
     virtual bool hasPendingActivity() const override;
     virtual void stop() override;
@@ skipping 28 matching lines @@
 
     void setOutdated();
     bool outdated() { return m_outdated; }
 
     bool canStartAnimationOnCompositor();
     bool maybeStartAnimationOnCompositor();
     void cancelAnimationOnCompositor();
     bool hasActiveAnimationsOnCompositor();
     void setCompositorPending(bool sourceChanged = false);
     void notifyCompositorStartTime(double timelineTime);
+    void notifyStartTime(double timelineTime);
 
 
     void preCommit(bool startOnCompositor);
     void postCommit(double timelineTime);
 
     unsigned sequenceNumber() const { return m_sequenceNumber; }
 
     static bool hasLowerPriority(AnimationPlayer* player1, AnimationPlayer* player2)
     {
         return player1->sequenceNumber() < player2->sequenceNumber();
     }
 
 #if !ENABLE(OILPAN)
     // Checks if the AnimationStack is the last reference holder to the Player.
     // This won't be needed when AnimationPlayer is moved to Oilpan.
     bool canFree() const;
 #endif
 
     virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture = false) override;
 
     virtual void trace(Visitor*) override;
 
 private:
     AnimationPlayer(ExecutionContext*, AnimationTimeline&, AnimationNode*);
+
     double sourceEnd() const;
     bool limited(double currentTime) const;
+
+    AnimationPlayState calculatePlayState();
+    double calculateCurrentTime() const;
+
+    void unpauseInternal();
+    void uncancel();
     void setPlaybackRateInternal(double);
     void updateCurrentTimingState(TimingUpdateReason);
-    void unpauseInternal();
-    void uncancel();
-    void setFinished(bool);
 
+
+    AnimationPlayState m_playState;
     double m_playbackRate;
-
     double m_startTime;
     double m_holdTime;
 
     unsigned m_sequenceNumber;
 
     RefPtrWillBeMember<AnimationNode> m_content;
     RawPtrWillBeMember<AnimationTimeline> m_timeline;
     // Reflects all pausing, including via pauseForTesting().
     bool m_paused;
     bool m_held;
@@ skipping 25 matching lines @@
             , sourceChanged(false)
             , pendingAction(Start)
         { }
         double startTime;
         double holdTime;
         double playbackRate;
         bool sourceChanged;
         CompositorAction pendingAction;
     };
 
+    enum CompositorPendingChange {
+        SetCompositorPending,
+        SetCompositorPendingWithSourceChanged,
+        DoNotSetCompositorPending,
+    };
+
+    class PlayStateUpdateScope {
+        STACK_ALLOCATED();
+    public:
+        PlayStateUpdateScope(AnimationPlayer&, TimingUpdateReason, CompositorPendingChange = SetCompositorPending);
+        ~PlayStateUpdateScope();
+    private:
+        AnimationPlayer& m_player;
+        AnimationPlayState m_initial;
+        CompositorPendingChange m_compositorPendingChange;
+    };
+
     // This mirrors the known compositor state. It is created when a compositor
     // animation is started. Updated once the start time is known and each time
     // modifications are pushed to the compositor.
     OwnPtr<CompositorState> m_compositorState;
     bool m_compositorPending;
     bool m_currentTimePending;
-    bool m_idle;
 };
 
 } // namespace blink
 
 #endif