Animation: Cancel same-property animations on compositor

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 228 matching lines @@
         cancelAnimationOnCompositor();
         m_compositorState = nullptr;
     }
 
     if (!shouldStart) {
         m_currentTimePending = false;
     }
 
     if (shouldStart) {
         m_compositorGroup = compositorGroup;
-        if (startOnCompositor && maybeStartAnimationOnCompositor()) {
-            m_compositorState = adoptPtr(new CompositorState(*this));
+        if (startOnCompositor) {
+            if (maybeStartAnimationOnCompositor())
+                m_compositorState = adoptPtr(new CompositorState(*this));
+            else
+                cancelIncompatibleAnimationsOnCompositor();
         }
     }
 }
 
 void AnimationPlayer::postCommit(double timelineTime)
 {
     PlayStateUpdateScope updateScope(*this, TimingUpdateOnDemand, DoNotSetCompositorPending);
 
     m_compositorPending = false;
 
@@ skipping 63 matching lines @@
         }
 
         // FIXME: This avoids marking this player as outdated needlessly when a start time
         // is notified, but we should refactor how outdating works to avoid this.
         m_outdated = false;
 
         m_currentTimePending = false;
     }
 }
 
+bool AnimationPlayer::affects(const Element& element, CSSPropertyID property) const
+{
+    if (!m_content || !m_content->isAnimation())
+        return false;
+
+    const Animation* animation = toAnimation(m_content.get());
+    return (animation->target() == &element) && animation->affects(property);
+}
+
 double AnimationPlayer::calculateStartTime(double currentTime) const
 {
     return m_timeline->effectiveTime() - currentTime / m_playbackRate;
 }
 
 double AnimationPlayer::calculateCurrentTime() const
 {
     ASSERT(!m_held);
     if (isNull(m_startTime) || !m_timeline)
         return 0;
@@ skipping 339 matching lines @@
     }
 
     if (sourceChanged || !m_compositorState
         || !playing() || m_compositorState->playbackRate != m_playbackRate
         || m_compositorState->startTime != m_startTime) {
         m_compositorPending = true;
         timeline()->document()->compositorPendingAnimations().add(this);
     }
 }
 
+void AnimationPlayer::cancelAnimationOnCompositor()
+{
+    if (hasActiveAnimationsOnCompositor())
+        toAnimation(m_content.get())->cancelAnimationOnCompositor();
+}
+
+void AnimationPlayer::cancelIncompatibleAnimationsOnCompositor()
+{
+    if (m_content && m_content->isAnimation())
+        toAnimation(m_content.get())->cancelIncompatibleAnimationsOnCompositor();
+}
+
 bool AnimationPlayer::hasActiveAnimationsOnCompositor()
 {
     if (!m_content || !m_content->isAnimation())
         return false;
 
     return toAnimation(m_content.get())->hasActiveAnimationsOnCompositor();
 }
 
-void AnimationPlayer::cancelAnimationOnCompositor()
-{
-    if (hasActiveAnimationsOnCompositor())
-        toAnimation(m_content.get())->cancelAnimationOnCompositor();
-}
-
 bool AnimationPlayer::update(TimingUpdateReason reason)
 {
     if (!m_timeline)
         return false;
 
     PlayStateUpdateScope updateScope(*this, reason, DoNotSetCompositorPending);
 
     m_outdated = false;
     bool idle = playStateInternal() == Idle;
 
@@ skipping 82 matching lines @@
 
 AnimationPlayer::PlayStateUpdateScope::~PlayStateUpdateScope()
 {
     AnimationPlayState oldPlayState = m_initialPlayState;
     AnimationPlayState newPlayState = m_player->calculatePlayState();
 
     m_player->m_playState = newPlayState;
     if (oldPlayState != newPlayState) {
         bool wasActive = oldPlayState == Pending || oldPlayState == Running;
         bool isActive = newPlayState == Pending || newPlayState == Running;
-
         if (!wasActive && isActive)
             TRACE_EVENT_NESTABLE_ASYNC_BEGIN1("blink.animations," TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Animation", m_player, "data", InspectorAnimationEvent::data(*m_player));
         else if (wasActive && !isActive)
             TRACE_EVENT_NESTABLE_ASYNC_END1("blink.animations," TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Animation", m_player, "endData", InspectorAnimationStateEvent::data(*m_player));
         else
             TRACE_EVENT_NESTABLE_ASYNC_INSTANT1("blink.animations," TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Animation", m_player, "data", InspectorAnimationStateEvent::data(*m_player));
     }
 
     // Ordering is important, the ready promise should resolve/reject before
     // the finished promise.
@@ skipping 81 matching lines @@
     visitor->trace(m_content);
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     visitor->trace(m_finishedPromise);
     visitor->trace(m_readyPromise);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace