Run smooth scroll animations on the compositor when possible

third_party/WebKit/Source/platform/scroll/ScrollAnimatorCompositorCoordinator.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "platform/scroll/ScrollAnimatorCompositorCoordinator.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/ScrollableArea.h"
@@ skipping 34 matching lines @@
 }
 
 bool ScrollAnimatorCompositorCoordinator::hasAnimationThatRequiresService() const
 {
     switch (m_runState) {
     case RunState::Idle:
     case RunState::RunningOnCompositor:
         return false;
     case RunState::WaitingToSendToCompositor:
     case RunState::RunningOnMainThread:
+    case RunState::RunningOnCompositorButNeedsUpdate:
     case RunState::WaitingToCancelOnCompositor:
         return true;
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
 bool ScrollAnimatorCompositorCoordinator::addAnimation(
     PassOwnPtr<WebCompositorAnimation> animation)
 {
@@ skipping 12 matching lines @@
 {
     if (m_compositorPlayer) {
         if (m_compositorPlayer->isLayerAttached())
             m_compositorPlayer->removeAnimation(m_compositorAnimationId);
     } else {
         if (GraphicsLayer* layer = scrollableArea()->layerForScrolling())
             layer->removeAnimation(m_compositorAnimationId);
     }
 }
 
+void ScrollAnimatorCompositorCoordinator::abortAnimation()
+{
+    if (m_compositorPlayer) {
+        if (m_compositorPlayer->isLayerAttached())
+            m_compositorPlayer->abortAnimation(m_compositorAnimationId);
+    } else {
+        if (GraphicsLayer* layer = scrollableArea()->layerForScrolling())
+            layer->abortAnimation(m_compositorAnimationId);
+    }
+}
+
 void ScrollAnimatorCompositorCoordinator::cancelAnimation()
 {
     switch (m_runState) {
     case RunState::Idle:
     case RunState::WaitingToCancelOnCompositor:
         break;
     case RunState::WaitingToSendToCompositor:
         if (m_compositorAnimationId) {
             // We still have a previous animation running on the compositor.
             m_runState = RunState::WaitingToCancelOnCompositor;
         } else {
             resetAnimationState();
         }
         break;
     case RunState::RunningOnMainThread:
         resetAnimationState();
         break;
+    case RunState::RunningOnCompositorButNeedsUpdate:
     case RunState::RunningOnCompositor:
         m_runState = RunState::WaitingToCancelOnCompositor;
 
         // Get serviced the next time compositor updates are allowed.
         scrollableArea()->registerForAnimation();
     }
 }
 
 void ScrollAnimatorCompositorCoordinator::compositorAnimationFinished(
     int groupId)
 {
     if (m_compositorAnimationGroupId != groupId)
         return;
 
     m_compositorAnimationId = 0;
     m_compositorAnimationGroupId = 0;
 
     switch (m_runState) {
     case RunState::Idle:
     case RunState::RunningOnMainThread:
         ASSERT_NOT_REACHED();
         break;
     case RunState::WaitingToSendToCompositor:
         break;
     case RunState::RunningOnCompositor:
+    case RunState::RunningOnCompositorButNeedsUpdate:
     case RunState::WaitingToCancelOnCompositor:
         resetAnimationState();
     }
 }
 
 void ScrollAnimatorCompositorCoordinator::reattachCompositorPlayerIfNeeded(
     WebCompositorAnimationTimeline* timeline)
 {
     int compositorAnimationAttachedToLayerId = 0;
     if (scrollableArea()->layerForScrolling())
@@ skipping 29 matching lines @@
 {
     notifyCompositorAnimationFinished(group);
 }
 
 WebCompositorAnimationPlayer* ScrollAnimatorCompositorCoordinator::compositorPlayer() const
 {
     return m_compositorPlayer.get();
 }
 
 } // namespace blink