Send takeover msg from MT to CC using the animation path.

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 "platform/scroll/ScrollAnimatorCompositorCoordinator.h"
 
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/animation/CompositorAnimationHost.h"
 #include "platform/animation/CompositorAnimationPlayer.h"
 #include "platform/animation/CompositorAnimationTimeline.h"
 #include "platform/graphics/CompositorFactory.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 
 namespace blink {
 
 ScrollAnimatorCompositorCoordinator::ScrollAnimatorCompositorCoordinator()
     : m_compositorAnimationAttachedToLayerId(0)
     , m_runState(RunState::Idle)
     , m_compositorAnimationId(0)
     , m_compositorAnimationGroupId(0)
+    , m_implOnlyAnimationTakeover(false)
 {
     ThreadState::current()->registerPreFinalizer(this);
     m_compositorPlayer = adoptPtr(CompositorFactory::current().createAnimationPlayer());
     ASSERT(m_compositorPlayer);
     m_compositorPlayer->setAnimationDelegate(this);
 }
 
 ScrollAnimatorCompositorCoordinator::~ScrollAnimatorCompositorCoordinator()
 {
 }
 
 void ScrollAnimatorCompositorCoordinator::dispose()
 {
     m_compositorPlayer->setAnimationDelegate(nullptr);
     m_compositorPlayer.clear();
 }
 
 void ScrollAnimatorCompositorCoordinator::resetAnimationState()
 {
     m_runState = RunState::Idle;
     m_compositorAnimationId = 0;
     m_compositorAnimationGroupId = 0;
 }
 
 bool ScrollAnimatorCompositorCoordinator::hasAnimationThatRequiresService() const
 {
-    if (!m_implOnlyAnimationAdjustment.isZero())
+    if (hasImplOnlyAnimationUpdate())
         return true;
 
     switch (m_runState) {
     case RunState::Idle:
     case RunState::RunningOnCompositor:
         return false;
     case RunState::WaitingToCancelOnCompositorButNewScroll:
     case RunState::PostAnimationCleanup:
     case RunState::WaitingToSendToCompositor:
     case RunState::RunningOnMainThread:
@@ skipping 50 matching lines @@
     case RunState::WaitingToCancelOnCompositorButNewScroll:
     case RunState::RunningOnCompositorButNeedsUpdate:
     case RunState::RunningOnCompositor:
         m_runState = RunState::WaitingToCancelOnCompositor;
 
         // Get serviced the next time compositor updates are allowed.
         getScrollableArea()->registerForAnimation();
     }
 }
 
-void ScrollAnimatorCompositorCoordinator::takeoverCompositorAnimation()
+void ScrollAnimatorCompositorCoordinator::takeOverCompositorAnimation()
 {
     switch (m_runState) {
     case RunState::Idle:
+        takeOverImplOnlyScrollOffsetAnimation();
+        break;
     case RunState::WaitingToCancelOnCompositor:
     case RunState::WaitingToCancelOnCompositorButNewScroll:
     case RunState::PostAnimationCleanup:
     case RunState::RunningOnCompositorButNeedsTakeover:
     case RunState::WaitingToSendToCompositor:
     case RunState::RunningOnMainThread:
         break;
     case RunState::RunningOnCompositorButNeedsUpdate:
     case RunState::RunningOnCompositor:
         // We call abortAnimation that makes changes to the animation running on
@@ skipping 99 matching lines @@
     offset.moveBy(getScrollableArea()->scrollOrigin());
     return offset;
 }
 
 FloatPoint ScrollAnimatorCompositorCoordinator::blinkOffsetFromCompositorOffset(FloatPoint offset)
 {
     offset.moveBy(-getScrollableArea()->scrollOrigin());
     return offset;
 }
 
+bool ScrollAnimatorCompositorCoordinator::hasImplOnlyAnimationUpdate() const
+{
+    return !m_implOnlyAnimationAdjustment.isZero() || m_implOnlyAnimationTakeover;
+}
+
 void ScrollAnimatorCompositorCoordinator::updateCompositorAnimations()
 {
-    if (!getScrollableArea()->scrollAnimatorEnabled() || m_implOnlyAnimationAdjustment.isZero())
+    if (!getScrollableArea()->scrollAnimatorEnabled() || !hasImplOnlyAnimationUpdate())
         return;
 
     GraphicsLayer* layer = getScrollableArea()->layerForScrolling();
     CompositorAnimationTimeline* timeline = getScrollableArea()->compositorAnimationTimeline();
     if (layer && timeline && !timeline->compositorAnimationHost().isNull()) {
         CompositorAnimationHost host = timeline->compositorAnimationHost();
-        host.updateImplOnlyScrollOffsetAnimation(
-            gfx::Vector2dF(m_implOnlyAnimationAdjustment.width(), m_implOnlyAnimationAdjustment.height()),
-            layer->platformLayer()->id());
+        int elementId = layer->platformLayer()->id();
+        if (!m_implOnlyAnimationAdjustment.isZero()) {
+            host.adjustImplOnlyScrollOffsetAnimation(
+                elementId,
+                gfx::Vector2dF(m_implOnlyAnimationAdjustment.width(), m_implOnlyAnimationAdjustment.height()));
+        }
+        if (m_implOnlyAnimationTakeover)
+            host.takeOverImplOnlyScrollOffsetAnimation(elementId);
     }
     m_implOnlyAnimationAdjustment = FloatSize();
+    m_implOnlyAnimationTakeover = false;
 }
 
-void ScrollAnimatorCompositorCoordinator::updateImplOnlyScrollOffsetAnimation(
+void ScrollAnimatorCompositorCoordinator::adjustImplOnlyScrollOffsetAnimation(
     const FloatSize& adjustment)
 {
     if (!getScrollableArea()->scrollAnimatorEnabled())
         return;
 
     m_implOnlyAnimationAdjustment.expand(adjustment.width(), adjustment.height());
 
     getScrollableArea()->registerForAnimation();
 }
 
+void ScrollAnimatorCompositorCoordinator::takeOverImplOnlyScrollOffsetAnimation()
+{
+    if (!getScrollableArea()->scrollAnimatorEnabled())
+        return;
+
+    m_implOnlyAnimationTakeover = true;
+
+    getScrollableArea()->registerForAnimation();
+}
+
 String ScrollAnimatorCompositorCoordinator::runStateAsText() const
 {
     switch (m_runState) {
     case RunState::Idle:
         return String("Idle");
     case RunState::WaitingToSendToCompositor:
         return String("WaitingToSendToCompositor");
     case RunState::RunningOnCompositor:
         return String("RunningOnCompositor");
     case RunState::RunningOnMainThread:
         return String("RunningOnMainThread");
     case RunState::RunningOnCompositorButNeedsUpdate:
         return String("RunningOnCompositorButNeedsUpdate");
     case RunState::WaitingToCancelOnCompositor:
         return String("WaitingToCancelOnCompositor");
     case RunState::PostAnimationCleanup:
         return String("PostAnimationCleanup");
     case RunState::RunningOnCompositorButNeedsTakeover:
         return String("RunningOnCompositorButNeedsTakeover");
     case RunState::WaitingToCancelOnCompositorButNewScroll:
         return String("WaitingToCancelOnCompositorButNewScroll");
     }
     ASSERT_NOT_REACHED();
     return String();
 }
 
 } // namespace blink