Web Animations: Add a name to AnimationNode and trace running players

Source/core/animation/AnimationPlayer.cpp

 /*
  * 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 18 matching lines @@
  */
 
 #include "config.h"
 #include "core/animation/AnimationPlayer.h"
 
 #include "core/animation/Animation.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/dom/Document.h"
 #include "core/events/AnimationPlayerEvent.h"
 #include "core/frame/UseCounter.h"
+#include "platform/TraceEvent.h"
 
 namespace blink {
 
 namespace {
 
 static unsigned nextSequenceNumber()
 {
     static unsigned next = 0;
     return ++next;
 }
@@ skipping 69 matching lines @@
             outdated = true;
         m_holdTime = newCurrentTime;
         if (m_paused || !m_playbackRate) {
             m_startTime = nullValue();
         } else if (isLimited && std::isnan(m_startTime) && reason == TimingUpdateForAnimationFrame) {
             m_startTime = calculateStartTime(newCurrentTime);
         }
     } else {
         m_holdTime = nullValue();
         m_startTime = calculateStartTime(newCurrentTime);
-        m_finished = false;
+        setFinished(false);
         outdated = true;
     }
 
     if (outdated) {
         setOutdated();
     }
 }
 
 // Update timing to reflect updated animation clock due to tick
 void AnimationPlayer::updateCurrentTimingState(TimingUpdateReason reason)
@@ skipping 310 matching lines @@
     setCompositorPending();
     uncancel();
     unpauseInternal();
     if (!m_content)
         return;
     double currentTime = this->currentTimeInternal();
     if (m_playbackRate > 0 && (currentTime < 0 || currentTime >= sourceEnd()))
         setCurrentTimeInternal(0, TimingUpdateOnDemand);
     else if (m_playbackRate < 0 && (currentTime <= 0 || currentTime > sourceEnd()))
         setCurrentTimeInternal(sourceEnd(), TimingUpdateOnDemand);
-    m_finished = false;
+    setFinished(false);
 }
 
 void AnimationPlayer::reverse()
 {
     if (!m_playbackRate) {
         return;
     }
 
     uncancel();
     setPlaybackRate(-m_playbackRate);
@@ skipping 35 matching lines @@
     return ActiveDOMObject::executionContext();
 }
 
 bool AnimationPlayer::hasPendingActivity() const
 {
     return m_pendingFinishedEvent || (!m_finished && hasEventListeners(EventTypeNames::finish));
 }
 
 void AnimationPlayer::stop()
 {
-    m_finished = true;
+    setFinished(true);
     m_pendingFinishedEvent = nullptr;
 }
 
 bool AnimationPlayer::dispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     if (m_pendingFinishedEvent == event)
         m_pendingFinishedEvent = nullptr;
     return EventTargetWithInlineData::dispatchEvent(event);
 }
 
 void AnimationPlayer::setPlaybackRate(double playbackRate)
 {
     if (!std::isfinite(playbackRate))
         return;
     if (playbackRate == m_playbackRate)
         return;
 
     setCompositorPending();
     if (!finished() && !paused() && hasStartTime())
         m_currentTimePending = true;
 
     double storedCurrentTime = currentTimeInternal();
     if ((m_playbackRate < 0 && playbackRate >= 0) || (m_playbackRate > 0 && playbackRate <= 0))
-        m_finished = false;
+        setFinished(false);
 
     m_playbackRate = playbackRate;
     m_startTime = std::numeric_limits<double>::quiet_NaN();
     setCurrentTimeInternal(storedCurrentTime, TimingUpdateOnDemand);
 }
 
 void AnimationPlayer::setOutdated()
 {
     m_outdated = true;
     if (m_timeline)
@@ skipping 66 matching lines @@
     if ((m_idle || finished()) && !m_finished) {
         if (reason == TimingUpdateForAnimationFrame && (m_idle || hasStartTime())) {
             const AtomicString& eventType = EventTypeNames::finish;
             if (executionContext() && hasEventListeners(eventType)) {
                 double eventCurrentTime = currentTimeInternal() * 1000;
                 m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
                 m_pendingFinishedEvent->setTarget(this);
                 m_pendingFinishedEvent->setCurrentTarget(this);
                 m_timeline->document()->enqueueAnimationFrameEvent(m_pendingFinishedEvent);
             }
-            m_finished = true;
+            setFinished(true);
         }
     }
     ASSERT(!m_outdated);
     return !m_finished;
 }
 
 double AnimationPlayer::timeToEffectChange()
 {
     ASSERT(!m_outdated);
     if (m_held || !hasStartTime())
         return std::numeric_limits<double>::infinity();
     if (!m_content)
         return -currentTimeInternal() / m_playbackRate;
     if (m_playbackRate > 0)
         return m_content->timeToForwardsEffectChange() / m_playbackRate;
     return m_content->timeToReverseEffectChange() / -m_playbackRate;
 }
 
+void AnimationPlayer::setFinished(bool finished)
+{
+    if (m_finished && !finished) {
+        if (m_content) {
+            TRACE_EVENT_ASYNC_BEGIN1("blink", "Animation", this, "Name", TRACE_STR_COPY(m_content->name().utf8().data()));
+        } else {
+            TRACE_EVENT_ASYNC_BEGIN0("blink", "Animation", this);
+        }
+    }
+    if (!m_finished && finished) {
+        TRACE_EVENT_ASYNC_END0("blink", "Animation", this);
+    }
+    m_finished = finished;
+}
+
 void AnimationPlayer::cancel()
 {
+    if (m_idle)
+        return;
+
     m_holdTime = currentTimeInternal();
     m_held = true;
     m_idle = true;
     m_startTime = nullValue();
     m_currentTimePending = false;
     setCompositorPending();
 }
 
+void AnimationPlayer::uncancel()
+{
+    if (!m_idle)
+        return;
+
+    m_idle = false;
+    m_held = true;
+    m_holdTime = 0;
+    setFinished(false);
+}
+
+
 #if !ENABLE(OILPAN)
 bool AnimationPlayer::canFree() const
 {
     ASSERT(m_content);
     return hasOneRef() && m_content->isAnimation() && m_content->hasOneRef();
 }
 #endif
 
 bool AnimationPlayer::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
 {
@@ skipping 14 matching lines @@
 
 void AnimationPlayer::trace(Visitor* visitor)
 {
     visitor->trace(m_content);
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace