Web Animations CSS: Start running animations on the compositor

Source/core/animation/Player.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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 
 #include "config.h"
 #include "core/animation/Player.h"
 
+#include "core/animation/Animation.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/animation/TimedItem.h"
 
 namespace WebCore {
 
-namespace {
-
-double effectiveTime(double time) { return isNull(time) ? 0 : time; }
-
-} // namespace
-
 PassRefPtr<Player> Player::create(DocumentTimeline& timeline, TimedItem* content)
 {
     return adoptRef(new Player(timeline, content));
 }
 
 Player::Player(DocumentTimeline& timeline, TimedItem* content)
     : m_pauseStartTime(nullValue())
     , m_playbackRate(1)
     , m_timeDrift(0)
     , m_startTime(nullValue())
@@ skipping 19 matching lines @@
     update();
 }
 
 double Player::currentTimeBeforeDrift() const
 {
     if (isNull(m_startTime))
         return 0;
     return (effectiveTime(m_timeline.currentTime()) - startTime()) * m_playbackRate;
 }
 
+bool Player::isCandidateForCompositorAnimation() const
+{
+    if (!m_content || !m_content->isAnimation())
+        return false;
+
+    const Animation* animation = toAnimation(m_content.get());
+    if (hasStartTime()) {
+        // FIXME: Support starting compositor animations that have a fixed
+        // start time.
+        return animation->isRunningCompositorAnimation();
+    }
+
+    return animation->isCandidateForCompositorAnimation();
+}
+
+bool Player::startCompositorAnimations()
+{
+    // FIXME: Support starting compositor animations that have a fixed
+    // start time.
+    ASSERT(!hasStartTime());
+    if (!m_content || !m_content->isAnimation())
+        return false;
+
+    return toAnimation(m_content.get())->startCompositorAnimations();
+}
+
+bool Player::isRunningCompositorAnimation(const Element* element, CSSPropertyID property)
+{
+    if (!m_content || !m_content->isAnimation())
+        return false;
+    return toAnimation(m_content.get())->isRunningCompositorAnimation(element, property);
+}
+
+void Player::cancelCompositorAnimations()
+{
+    if (isRunningCompositorAnimation())
+        toAnimation(m_content.get())->cancelCompositorAnimations();
+}
+
 double Player::pausedTimeDrift() const
 {
     ASSERT(pausedInternal());
     return currentTimeBeforeDrift() - m_pauseStartTime;
 }
 
 double Player::timeDrift() const
 {
     return pausedInternal() ? pausedTimeDrift() : m_timeDrift;
 }
@@ skipping 37 matching lines @@
     if (pausedInternal())
         m_pauseStartTime = seekTime;
     else
         m_timeDrift = currentTimeBeforeDrift() - seekTime;
 
     update();
 }
 
 void Player::pauseForTesting()
 {
-    ASSERT(!paused());
+    RELEASE_ASSERT(!isRunningCompositorAnimation());
+    RELEASE_ASSERT(!paused());
     m_isPausedForTesting = true;
     setPausedImpl(true);
 }
 
 void Player::setPaused(bool newValue)
 {
     ASSERT(!m_isPausedForTesting);
     setPausedImpl(newValue);
 }
 
@@ skipping 11 matching lines @@
 }
 
 void Player::setPlaybackRate(double newRate)
 {
     double previousTime = currentTime();
     m_playbackRate = newRate;
     setCurrentTime(previousTime);
 }
 
 } // namespace